JAVA线程本地存储（ThreadLocal）

我就是我 2022-05-17 01:46 159阅读 0赞

今天看书看到这么一句话，“防止任务在共享资源上产生冲突的第二种方式是根除对变量的共享。线程本地存储是一种自动化机制，可以为使用相同变量的每个不同线程都创建不同的存储”。（第一种方式就是进行同步控制，比如加锁喽）

那么什么是线程本地存储，个人理解就是，对一个苹果，大家都把苹果放在一个桌子上存放（给域赋值），等你去拿的时候发现拿到的可能不是自己那个苹果了，ThreadLocal的做法就是你的苹果，你放在那，等你去拿，拿到的就是你原先那个。

假设我们现在有个共享的苹果存放区，人人都想把苹果放在上面（把苹果的ID改为自己的ID），在不做同步控制的情况下，很快就会发现明明刻上自己名字的苹果，拿到手里一看居然是别人的名字，哈哈，我们试验一下。

写个Apple类，就一个实例域AppleID，一个 set 一个 get

package dailyprg0804;
    
    public class Apple {
    	private int AppleID;
    
    	Apple(){}
    
    	Apple(int AppleID){
    		this.AppleID = AppleID;
    	}
    
    	public int getAppleID() {
    		return AppleID;
    	}
    
    	public void setAppleID (int appleID) {
    		AppleID = appleID;
    	}
    	
    }

写一个测试类，除main外跑5个线程，用线程池

package dailyprg0804;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadLocalTest {
    	public static void main(String[] args) throws Exception{
            Apple apple = new Apple();
    
            class RunApple implements Runnable{
                private final int id;
                RunApple(int id){
                    this.id = id;
                }
            
                @Override
                public void run(){
                    while(!Thread.currentThread().isInterrupted()){
                        apple.setAppleID(id);
                        Thread.yield();
                        System.out.println(this);
                    }
                    
                        
                }
    
                @Override
                public String toString(){
                    return "#" + id + ":" + apple.getAppleID();
                }
            }
    
            ExecutorService exec = Executors.newCachedThreadPool();
            for(int i=0;i<5;i++){
                exec.execute(new RunApple(i));
            }
            TimeUnit.SECONDS.sleep(1);
            exec.shutdownNow();
        }
    }

稍微运行一会儿就关掉线程池，看下输出

![70][]

可以发现已经分不清是谁的苹果了。

为了解决这个问题，**直接点就是加锁，synchronized或者Lock，**我们就用synchronized试下，我们把“给苹果刻上自己名字然后看苹果上是谁的名字”这个过程同步起来，哈哈，就是一个人把苹果放上去，然后霸占着桌子，不让别人放。

稍微修改下代码

@Override
                public void run(){
                    while(!Thread.currentThread().isInterrupted()){
                        synchronized(apple){
                            apple.setAppleID(id);
                            Thread.yield();
                            System.out.println(this);
                        }
                    }

稍微运行久一点，看下结果

![70 1][]

没有问题的，毕竟加锁了

说回 **ThreadLocal**，怎么确保拿到的是自己的苹果呢。

当然我们可以在任务里面new一个苹果出来，但这样做意义上就不太一样了，我的苹果一直放在我口袋里，没放到桌子上，就是局部变量，局部变量的缺点就是我知道我有个苹果，但我同事不知道，局部变量不能被线程里所有的方法可见，可能会造成额外的参数传递，或者多次new苹果出来。。

看来要在苹果这个类上做文章了。

怎么带呢？好难描述啊，这里看下 Thread 和 ThreadLocal 类的源码吧。

在Thread类中有个**ThreadLocalMap**

/* ThreadLocal values pertaining to this thread. This map is maintained
         * by the ThreadLocal class. */
        ThreadLocal.ThreadLocalMap threadLocals = null;

这个map类的键值对是

Entry(ThreadLocal<?> k, Object v)

就是这个map在每个Thread里存了ThreadLocal对象和对应的其他某个对象，这里的某个对象就可以是我们说的苹果。

ThreadLocal类有两个重要方法 **set** 和 **get** ，

get就是获取这个ThreadLocal变量在当前类的值，源码如下

/**
         * Returns the value in the current thread's copy of this
         * thread-local variable.  If the variable has no value for the
         * current thread, it is first initialized to the value returned
         * by an invocation of the {@link #initialValue} method.
         *
         * @return the current thread's value of this thread-local
         */
        public T get() {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null) {
                ThreadLocalMap.Entry e = map.getEntry(this);
                if (e != null) {
                    @SuppressWarnings("unchecked")
                    T result = (T)e.value;
                    return result;
                }
            }
            return setInitialValue();
        }

可以看到这个方法先要获取当前线程的map，然后在 map 里面找 this ThreadLocal 变量对应的值。

如果这个对象没有值就调用setInitialValue()

/**
         * Variant of set() to establish initialValue. Used instead
         * of set() in case user has overridden the set() method.
         *
         * @return the initial value
         */
        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;
        }

protected T initialValue() {
            return null;
        }

再看set，set就是给当前线程设置一个ThreadLocal变量对应的值，这个值是Object

/**
         * Sets the current thread's copy of this thread-local variable
         * to the specified value.  Most subclasses will have no need to
         * override this method, relying solely on the {@link #initialValue}
         * method to set the values of thread-locals.
         *
         * @param value the value to be stored in the current thread's copy of
         *        this thread-local.
         */
        public void set(T value) {
            Thread t = Thread.currentThread();
            ThreadLocalMap map = getMap(t);
            if (map != null)
                map.set(this, value);
            else
                createMap(t, value);
        }

GET 和 SET 都有这个一句

Thread t = Thread.currentThread();

就是定位到了当前线程。

到此，我们可以重写一下Apple类并做下测试了。

package dailyprg0804;
    
    public class Apple {
    	private  final ThreadLocal<Integer> appleThreadLocal
    		= new ThreadLocal<>();
    
    	public int getAppleID() {
    		return appleThreadLocal.get();
    	}
    
    	public void setAppleID(int appleID) {
    		appleThreadLocal.set(appleID);
    	}
    	
    }

就是我们在设置AppleID的时候其实是在设置Thread本地ThreadLocalMap里的appleThreadLocal对应的ID，

这样修改了Apple，测试类的代码就不用动了，还是那个没有synchronized的版本，

我们测试下

![70 2][]

每个线程都是在修改自己本地的变量，相互之间没有交集，所以不会有冲突。

但是这样写放到线程本地的只是苹果的AppleID了，也就是一个整数，而不是苹果这个对象，我们再修改一下代码，不修改Apple这个类，把ThreadLocal的实例放到测试类里面去，

Apple类的代码不变，

修改测试类

package dailyprg0804;
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.TimeUnit;
    
    public class ThreadLocalTest {
        private static ThreadLocal<Apple> appleThreadLocal
            = new ThreadLocal<>();
    
    	public static void main(String[] args) throws Exception{
    
            class RunApple implements Runnable{
                private final int id;
                RunApple(int id){
                    this.id = id;
                }
            
                @Override
                public void run(){
                    while(!Thread.currentThread().isInterrupted()){
                        appleThreadLocal.set(new Apple(id));
                        Thread.yield();
                        System.out.println(this);
                    }
                    
                }
    
                @Override
                public String toString(){
                    return "#" + id + ":" + appleThreadLocal.get().getAppleID();
                }
            }
    
            ExecutorService exec = Executors.newCachedThreadPool();
            for(int i=0;i<5;i++){
                exec.execute(new RunApple(i));
            }
            TimeUnit.SECONDS.sleep(1);
            exec.shutdownNow();
        }
    }

测试一下

![70 3][]

也是OK的。

另外还在其他书上看到过，如果线程自然死亡，那么ThreadLcoal的数据也会跟着消失，如果是线程池，在线程会被复用的情况下，要手动清除。可以把map中的值set成null，让GC可以工作，也可以调用ThreadLocal的remove方法。

并发编程实战这本书里也提到ThreadLocal会降低代码的可重用性，并在类之间引入隐含的耦合性，因此在使用时要格外小心。

有位博主说过，对于Java线程，自己写线程或者线程池的机会挺少的，都被类库或者框架给封装好了，**我们要做的其实就是要理解概念和思路，以及别人是怎么给我们实现的**。

[70]: /images/20220517/7acba7b9fe594148bac4bf78288cd847.png
[70 1]: /images/20220517/447f199db4f543a99e6580bd9f5ede67.png
[70 2]: /images/20220517/134a005591d44c13a0598dfaaba91442.png
[70 3]: /images/20220517/07257a7c9c0b4032a18036140c8cc7cc.png