ThreadLocal-------线程范围内的数据共享

偏执的太偏执、 2022-07-14 07:54 248阅读 0赞

1、ThreadLocal的简介

ThreadLocal，即线程变量，是一个以ThreadLocal对象为键、任意对象为值的存储结构。这个结构被附带在线程上，也就是说一个线程可以根据一个ThreadLocal对象查询到绑定在这个线程上的一个值。  
        **可以通过set(T)方法来设置一个值，在当前线程下再通过get()方法获取到原先设置的值。**

2、时间差的计算

在下面的例子中，构建了一个常用的Profiler类，它具有begin()和end()两个方法，而end()方法返回从begin()方法调用开始到end()方法被调用时的时间差，单位是毫秒。

public class Profiler {
    
    	private static ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal<Long>();
    
    	public static final void begin() {
    		Long time = TIME_THREADLOCAL.get();
    		if (time == null) {
    			TIME_THREADLOCAL.set(System.currentTimeMillis());
    		}
    	}
    
    	public static final long end() {
    		return System.currentTimeMillis() - TIME_THREADLOCAL.get();
    	}
    
    }

测试代码

public class Test {
    	public static void main(String[] args) {
    		Profiler.begin();
    		try {
    			Thread.sleep(3000);
    		} catch (InterruptedException e) {
    			e.printStackTrace();
    		}
    		System.out.println("Cost: " + Profiler.end() + " mills");
    	}
    }

3、线程范围内的数据共享,注意ThreadLocal的用法

// 线程内的共享数据,每次获取的实例都是和当前线程相关的  
    class MyThreadScopeData {  
      
        public MyThreadScopeData() {  
        }  
      
        // 利用ThreadLocal存储和线程相关的ThreadScopeData.java的实例  
        private static ThreadLocal<MyThreadScopeData> map = new ThreadLocal<MyThreadScopeData>();  
      
        // 用于获取ThreadScopeData.java和当前线程相关的实例  
        public static MyThreadScopeData getThreadInstance() {  
            MyThreadScopeData instance = map.get();  
            if (instance == null) {  
                instance = new MyThreadScopeData();  
                map.set(instance);  
            }  
            return instance;  
        }  
      
        private int age;  
        private String name;  
      
        public int getAge() {  
            return age;  
        }  
      
        public void setAge(int age) {  
            this.age = age;  
        }  
      
        public String getName() {  
            return name;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        @Override  
        public String toString() {  
            return "ThreadScopeData [age=" + age + ", name=" + name + "]";  
        }  
      
    }

测试代码

public class ThreadScopeDataShare {  
      
        public static void main(String[] args) {  
            // 模拟线程  
            for (int i = 0; i < 2; i++) {  
                new Thread(new Runnable() {  
                    @Override  
                    public void run() {  
                        int data = new Random().nextInt();  
                        MyThreadScopeData myThreadScopeData = MyThreadScopeData  
                                .getThreadInstance();  
                        myThreadScopeData.setAge(data);  
                        myThreadScopeData.setName(data + "");  
                        System.out.println(Thread.currentThread().getName()  
                                + " has put data is "  
                                + myThreadScopeData.toString());  
                        // 模拟A模块使用数据  
                        new A().get();  
                        // 模拟B模块使用数据  
                        new B().get();  
                    }  
                }).start();  
            }  
      
        }  
      
        // A模块  
        static class A {  
      
            public void get() {  
                MyThreadScopeData myThreadScopeData = MyThreadScopeData  
                        .getThreadInstance();  
                System.out.println("A from " + Thread.currentThread().getName()  
                        + " has put data is " + myThreadScopeData.toString());  
            }  
      
        }  
      
        // 模块  
        static class B {  
            public void get() {  
                MyThreadScopeData myThreadScopeData = MyThreadScopeData  
                        .getThreadInstance();  
                System.out.println("B from " + Thread.currentThread().getName()  
                        + " has put data is " + myThreadScopeData.toString());  
            }  
        }  
    }

测试结果

Thread-0 has put data is ThreadScopeData [age=-1607661362, name=-1607661362]  
    Thread-1 has put data is ThreadScopeData [age=-715028589, name=-715028589]  
    A from Thread-0 has put data is ThreadScopeData [age=-1607661362, name=-1607661362]  
    A from Thread-1 has put data is ThreadScopeData [age=-715028589, name=-715028589]  
    B from Thread-0 has put data is ThreadScopeData [age=-1607661362, name=-1607661362]  
    B from Thread-1 has put data is ThreadScopeData [age=-715028589, name=-715028589]

4、利用ThreadLocal来保存之和当前线程有关的数据库连接

/** 
     * 数据库连接管理类 
     * @author 爽 
     * 
     */  
    public class ConnectionManager {  
      
        /** 线程内共享Connection，ThreadLocal通常是全局的，支持泛型 */  
        private static ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();  
          
        public static Connection getCurrConnection() {  
            // 获取当前线程内共享的Connection  
            Connection conn = threadLocal.get();  
            try {  
                // 判断连接是否可用  
                if(conn == null || conn.isClosed()) {  
                    // 创建新的Connection赋值给conn(略)  
                    // 保存Connection  
                    threadLocal.set(conn);  
                }  
            } catch (SQLException e) {  
                // 异常处理  
            }  
            return conn;  
        }  
          
        /** 
         * 关闭当前数据库连接 
         */  
        public static void close() {  
            // 获取当前线程内共享的Connection  
            Connection conn = threadLocal.get();  
            try {  
                // 判断是否已经关闭  
                if(conn != null && !conn.isClosed()) {  
                    // 关闭资源  
                    conn.close();  
                    // 移除Connection  
                    threadLocal.remove();  
                    conn = null;  
                }  
            } catch (SQLException e) {  
                // 异常处理  
            }  
        }  
    }

** 这样处理的好处：**

1.  统一管理Connection；
2.  不需要显示传参Connection，代码更优雅；
3.  降低耦合性。

5、模拟多线程的途径，使用FOR循环

// 模拟多线程的访问  
            for (int i = 0; i < 2; i++) {  
                new Thread(new Runnable() {  
                    @Override  
                    public void run() {  
                          
                    }  
                }).start();  
            }