ThreadLocal

迷南。 2022-03-18 10:39 249阅读 0赞

# ThreadLocal #

### 什么是ThreadLocal ###

*  ThreadLocal，可以称作线程本地变量，也可以称作线程本地存储，ThreadLocal为变量在每个线程中创建了一个副本，那么每个线程可以访问自己的线程。
 *  ThreadLocal为解决多线程程序的并发问题提供了一种新的思路，使用这个工具类可以很简洁的编出优美的多线程程序。当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立的改变自己的副本，而不会影响其他的线程对应的副本
 *  例子说明
    
     *  程序
    
     
    
        class ConnectionManager {
        
            private static Connection connect = null;
        
            public static Connection openConnection() {
                if(connect == null){
                    connect = DriverManager.getConnection();
                }
                return connect;
            }
        
            public static void closeConnection() {
                if(connect!=null)
                    connect.close();
            }
        }
    
     *  问题：这段数据库链接代码在单线程中使用是完全没有问题的，但是在多线程中使用会存在线程安全问题。首先方法没有同步，可能会多次创建connect；其次，由于connect是共享变量，在调用connect的地方需要同步来保证线程的安全，因为一个线程在使用在连接数据库，另一个在关闭数据库。
     *  解决方案之同步：可以进行同步的操作，但是造成的后果是执行效率的低下，因为一个线程在使用的时候，其他的线程必然只有等待
     *  解决方案之不共享变量，即去掉static修饰，程序如下，但是这样做每次都是在方法内部进行创建的连接，会导致服务器的压力非常大，严重影响程序执行性能（因为在方法中需要频繁的开启和关闭数据库）：
        
         
        
            class ConnectionManager {
            
                private  Connection connect = null;
            
                public Connection openConnection() {
                    if(connect == null){
                        connect = DriverManager.getConnection();
                    }
                    return connect;
                }
            
                public void closeConnection() {
                    if(connect!=null)
                        connect.close();
                }
            }
     *  解决之ThreadLocal：由于每个线程都创建了副本，所以要考虑它对资源的消耗，内存的消耗要大一些

### ThreadLocal类 ###

*  方法
    
    1.  public T get()\{\} 此方法是用来获取ThreadLocal在当前线程中保存的变量副本
    2.  public void set(T value)\{\} 此方法用来设置当前线程中变量的副本
    3.  public void remove()\{\} 此方法用来移除当前线程中变量的副本
    4.  protected T initialValue()\{\} 此方法是一个protected方法，一般是用来在使用时进行 重写的，它是一个延迟加载的方法
 *  ThreadLocal为每一个线程创建副本
    
     *  get方法的具体实现
        
         
        
            public T get(){
                Thread t = Thread.currentThread();//获得当前线程
                ThreadLocalMap map=getMap(t);//获取Map，类型为ThreadLocalMap
                if(map != null){
                    ThreadLocallMap.Entry e=map.getEntry(this);//注意：这里传进去的是this
                    if(e!=null){
                        return (T)e.value;
                    }
                }
                return setInitialValue();
            }
     *  getMap方法的具体实现
        
         
        
            ThreadLocalMap getMap(Thread t){
                return t.threadLocals;//threadLocals是线程中Thread的一个变量
            }
     *  内部类ThreadLocalMap的具体实现
        
         
        
            static class ThreadLocalMap{
                static class Entry extends WeakReference<ThreadLocal>{
                    Object value;
                    Entry(ThreadLocal k,Object v){
                        super(k);//ThreadLocal作为了键值
                        value=v;
                    }
                }
            }
     *  setInitialValue方法的具体实现
        
         
        
            private T setInitialValue(){
                T value=initialValue();
                Thread t=Thread.currentThread();
                ThreadLocalMap map=getMap(t);
                if(map!=null){
                    map.set(this,value);
                }else{
                    createMap(t,value);//创建map为空时，则创建Map
                }
                return value;
            }
     *  createMap方法的具体实现
        
         
        
            void createMap(Thread t,T firstValue){
                t.threadLocals=new ThreadLocalMap(this,firstValue);
            }
 *  过程
    
     *  首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadlocals就是用来存储实际的变量副本的，键值为当前的ThreadLocal变量，value为变量副本（即T类型的变量）；初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量通过get方法或者set方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。
 *  例子
    
     *  程序
        
         
        
            public class Test {
                ThreadLocal<Long> longLocal = new ThreadLocal<Long>();
                ThreadLocal<String> stringLocal = new ThreadLocal<String>();
            
            
                public void set() {
                    longLocal.set(Thread.currentThread().getId());
                    stringLocal.set(Thread.currentThread().getName());
                }
            
                public long getLong() {
                    return longLocal.get();
                }
            
                public String getString() {
                    return stringLocal.get();
                }
            
                public static void main(String[] args) throws InterruptedException {
                    final Test test = new Test();
            
            
                    test.set();
                    System.out.println(test.getLong());
                    System.out.println(test.getString());
            
            
                    Thread thread1 = new Thread(){
                        public void run() {
                            test.set();
                            System.out.println(test.getLong());
                            System.out.println(test.getString());
                        };
                    };
                    thread1.start();
                    thread1.join();
            
                    System.out.println(test.getLong());
                    System.out.println(test.getString());
                }
            }
     *  执行结果
        
         
        
            1
            main
            2
            Thread-0
            1
            main
 *  注意
    
    1.  ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的
    2.  每个线程可以有多个threadLocals变量，即可以创建不同泛型的ThreadLocal
    3.  在get之前，必须set，否则会报空指针异常（注:如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue方法，默认情况下，initialValue方法返回的是null）
        
         
        
            ThreadLocal<Long> longLocal = new ThreadLocal<Long>(){
                    protected Long initialValue() {
                        return Thread.currentThread().getId();
                    };
                };
                ThreadLocal<String> stringLocal = new ThreadLocal<String>(){;
                    protected String initialValue() {
                        return Thread.currentThread().getName();
                    };
                };

### 使用场景 ###

1.  数据库连接
    
     
    
        private static ThreadLocal<Connection> connectionHolder= new ThreadLocal<Connection>() {
            public Connection initialValue() {
                return DriverManager.getConnection(DB_URL);
            }
        };
        
        public static Connection getConnection() {
            return connectionHolder.get();
        }
2.  Session管理
    
     
    
        private static final ThreadLocal threadSession = new ThreadLocal();
        
        public static Session getSession() throws InfrastructureException {
            Session s = (Session) threadSession.get();
            try {
                if (s == null) {
                    s = getSessionFactory().openSession();
                    threadSession.set(s);
                }
            } catch (HibernateException ex) {
                throw new InfrastructureException(ex);
            }
            return s;
        }

### 延伸--Thread同步机制 ###

*  ThreadLocal和线程的同步机制都是为了解决多线程在中相同变量的访问冲突，在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量，这时该变量是多个线程共享的，使用同步机制要求程序=缜密的分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写的难度相对较大。而ThreadLocal则从另一个角度来解决多线程的并发访问，Threadlocal会为每个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突，因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。
 *  同步机制【以时间换空间】；ThreadLocal【以空间换时间】