ThreadLocal使用、场景、原理

待我称王封你为后i 2022-06-08 11:36 316阅读 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();
        }
    }

假设有这样一个数据库链接管理类，这段代码在单线程中使用是没有任何问题的，但是如果在多线程中使用呢？很显然，在多线程中使用会存在线程安全问题：第一，这里面的2个方法都没有进行同步，很可能在openConnection方法中会多次创建connect；第二，由于connect是共享变量，那么必然在调用connect的地方需要使用到同步来保障线程安全，因为很可能一个线程在使用connect进行数据库操作，而另外一个线程调用closeConnection关闭链接。

所以出于线程安全的考虑，必须将这段代码的两个方法进行同步处理，并且在调用connect的地方需要进行同步处理。

这样将会大大影响程序执行效率，因为一个线程在使用connect进行数据库操作的时候，其他线程只有等待。

那么大家来仔细分析一下这个问题，这地方到底需不需要将connect变量进行共享？事实上，是不需要的。假如每个线程中都有一个connect变量，各个线程之间对connect变量的访问实际上是没有依赖关系的，即一个线程不需要关心其他线程是否对这个connect进行了修改的。

到这里，可能会有朋友想到，既然不需要在线程之间共享这个变量，可以直接这样处理，在每个需要使用数据库连接的方法中具体使用时才创建数据库链接，然后在方法调用完毕再释放这个连接。比如下面这样：

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();
        }
    }
     
     
    class Dao{
        public void insert() {
            ConnectionManager connectionManager = new ConnectionManager();
            Connection connection = connectionManager.openConnection();
             
            //使用connection进行操作
             
            connectionManager.closeConnection();
        }
    }

这样处理确实也没有任何问题，由于每次都是在方法内部创建的连接，那么线程之间自然不存在线程安全问题。但是这样会有一个致命的影响：导致服务器压力非常大，并且严重影响程序执行性能。由于在方法中需要频繁地开启和关闭数据库连接，这样不尽严重影响程序执行效率，还可能导致服务器压力巨大。

那么这种情况下使用ThreadLocal是再适合不过的了，因为ThreadLocal在每个线程中对该变量会创建一个副本，即每个线程内部都会有一个该变量，且在线程内部任何地方都可以使用，线程之间互不影响，这样一来就不存在线程安全问题，也不会严重影响程序执行性能。

但是要注意，虽然ThreadLocal能够解决上面说的问题，但是由于在每个线程中都创建了副本，所以要考虑它对资源的消耗，比如内存的占用会比不使用ThreadLocal要大。

# 二、ThreadLocal实现原理 #

ThreadLocal类提供的几个方法：

public T get() { }
    public void set(T value) { }
    public void remove() { }
    protected T initialValue() { }

get方法的实现：

public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

set方法的实现：

public void set(T value) {  
           Thread t = Thread.currentThread();  
           ThreadLocalMap map = getMap(t);  
           if (map != null)  
               map.set(this, value);  
           else  
               createMap(t, value);  
       }

第一句是取得当前线程，然后通过getMap(t)方法获取到一个map，map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对，注意这里获取键值对传进去的是  this，而不是当前线程t。

如果获取成功，则返回value值。

如果map为空，则调用setInitialValue方法返回value。

为了加深理解，我们接着看上面代码中出现的getMap和createMap方法的实现：

ThreadLocalMap getMap(Thread t) {  
        return t.threadLocals;  
    }

void createMap(Thread t, T firstValue) {  
        t.threadLocals = new ThreadLocalMap(this, firstValue);  
    }

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);  
           return value;  
       }

首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。

初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

# 三、ThreadLocal使作场景 #

当很多线程需要多次使用同一个对象，并且需要该对象具有相同初始化值的时候最适合使用ThreadLocal。最常见的ThreadLocal使用场景为 用来解决 数据库连接、Session管理等。

public class ConnectionUtil {
        private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
        private static Connection initConn = null;
        static {
            try {
                initConn = DriverManager.getConnection("url, name and password");
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        
        public Connection getConn() {
            Connection c = tl.get();
            if(null == c) tl.set(initConn);
            return tl.get();
        }

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;
    }

# 四、ThreadLocal是解决线程安全的吗？ #

线程安全问题产生的两个前提条件：   
1. 数据共享。多个线程访问同样的数据。   
2. 共享数据是可变的。多个线程对访问的共享数据作出了修改。

定义一个共享数据：

1.  **public** **static** **int** a = 0;

多线程多该共享数据进行修改：

private static void plus() {  
        for (int i = 0; i < 10; i++) {  
            new Thread() {  
                public void run() {  
                    a++;  
                    try {  
                        Thread.sleep(1);  
                    } catch (InterruptedException e) {  
                        e.printStackTrace();  
                    }  
                    System.out.println("plus:" + Thread.currentThread().getName() + ": " + a);  
                }  
            }.start();  
        }  
    }

输出结果：

plus:Thread-5: 5  
    plus:Thread-2: 5  
    plus:Thread-6: 5  
    plus:Thread-9: 5  
    plus:Thread-1: 6  
    plus:Thread-0: 8  
    plus:Thread-4: 8  
    plus:Thread-3: 10  
    plus:Thread-7: 10  
    plus:Thread-8: 10

很明显，在第一次输出a的值的时候，a的值就已经被其他线程修改到5了，显然线程不安全。 利用synchronized关键字将修改a值的地方和输出的地方上锁。让这段代码在某一个时间段内始终只有一个   
线程在执行：

private static void plus() {  
        for (int i = 0; i < 10; i++) {  
            new Thread() {  
                public void run() {  
                    synchronized (JavaVariable.class) {  
                        a++;  
                        try {  
                            Thread.sleep(1);  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                        System.out.println("plus:" + Thread.currentThread().getName() + ": " + a);  
                    }  
                }  
            }.start();  
        }  
    }

plus:Thread-2: 1  
    plus:Thread-6: 2  
    plus:Thread-7: 3  
    plus:Thread-3: 4  
    plus:Thread-8: 5  
    plus:Thread-4: 6  
    plus:Thread-0: 7  
    plus:Thread-9: 8  
    plus:Thread-5: 9  
    plus:Thread-1: 10

那么，如果ThreadLocal是为了解决线程安全设计的，请同样用ThreadLocal解决上面的问题。即，我需要多个线程共同修改一个值，但是要保持这个值递增，就是说后面的线程不能在前一个线程还没有输出就又去修改。  当然可以尝试一下，首先定义一个ThreadLocal。

private static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {  
        protected Integer initialValue() {  
            return 0;  
        }  
    };

private static void plus() throws Exception {  
        for (int i = 0; i < 10; i++) {  
            new Thread() {  
                public void run() {  
                    //1  
                    a = threadLocal.get();  
                    a++;  
                      
                    //2  
                    threadLocal.set(a);  
                    System.out.println("plus:" + Thread.currentThread().getName() + ": " + threadLocal.get());  
                }  
            }.start();  
        }  
    }

我都不想运行结果了，全部会输出1。很明显，在代码“1”的时候，每一个线程都会将threadLocal的初始值0赋值给共享变量a，因为每一个线程从threadLocal.get()拿到的值都是自己threadLocal保存的。所以，就没有所以了。   
所以对于共享变量a来讲，每个线程都会首先将自己threadLocal里面的初始值0赋值给a，然后将共享变量a+1，然后将a+1的值设置到自己的ThreadLocalMap中，其他线程就访问不到了。下一个线程来的时候又会将自己threadLocal里面的初始值0赋值给a，然后将 a+1，然后... 如此周而复始。a只是被在0和1之间改来改去，最终放到每一个线程的threadLocal里面的a+1的值就不再共享。对于a这个共享变量来讲，如果在for循环创建的某线程A即将执行代码“2”之前，被其他for循环以外的某个线程改了一把。那么存到线程A的ThreadLocalMap中的值就是被改过的值了。   
  
综上所述：   
Java的ThreadLocal不是设计用来解决多线程安全问题的，事实证明也解决不了，共享变量a还是会被随意更改。ThreadLocal无能为力。所以，一般用ThreadLocal都不会将一个共享变量放到线程的ThreadLocal中。一般来讲，存放到ThreadLocal中的变量都是当前线程   
本身就独一无二的一个变量。其他线程本身就不能访问，存到ThreadLocal中只是为了方便在程序中同一个线程之间传递这个变量。   
所以，ThreadLocal和解决线程安全没有关系。

# 五、ThreadLocal使用（在Runnable中创建ThreadLocal） #

1、在多线程的类（如ThreadDemo类）中，创建一个ThreadLocal对象threadXxx，用来保存线程间需要隔离处理的对象xxx。   
2、在ThreadDemo类中，创建一个获取要隔离访问的数据的方法getXxx()，在方法中判断，若ThreadLocal对象为null时候，应该new()一个隔离访问类型的对象，并强制转换为要应用的类型。   
3、在ThreadDemo类的run()方法中，通过调用getXxx()方法获取要操作的数据，这样可以保证每个线程对应一个数据对象，在任何时刻都操作的是这个对象。

package com.liuhai;
    
    import java.util.Random;
    
    public class Test2 implements Runnable{
        
        ThreadLocal<Studen> studenThreadLocal = new ThreadLocal<Studen>();
    
        @Override
        public void run() {
            String currentThreadName = Thread.currentThread().getName();
            System.out.println(currentThreadName + " is running...");
            Random random = new Random();
            int age = random.nextInt(100);
            System.out.println(currentThreadName + " is set age: "  + age);
            Studen studen = getStudent(); //通过这个方法，为每个线程都独立的new一个student对象，每个线程的的student对象都可以设置不同的值
            studen.setAge(age);
            System.out.println(currentThreadName + " is first get age: " + studen.getAge());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println( currentThreadName + " is second get age: " + studen.getAge());
            
        }
        
        private Studen getStudent() {
            Studen studen = studenThreadLocal.get();
            if (null == studen) {
                studen = new Studen();
                studenThreadLocal.set(studen);
            }
            return studen;
        }
    
        public static void main(String[] args) {
           Test2 t = new Test2();
            Thread t1 = new Thread(t,"Thread A");
            Thread t2 = new Thread(t,"Thread B");
            t1.start();
            t2.start();
        }
        
    }
    
    class Studen{
        int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        
    }

结果：Thread A is running...  
Thread B is running...  
Thread B is set age: 89  
Thread A is set age: 52  
Thread A is first get age: 52  
Thread B is first get age: 89  
Thread B is second get age: 89  
Thread A is second get age: 52