ThreadLocal使用及原理

男娘i 2022-05-17 13:40 245阅读 0赞

1.ThreadLocal的简单使用

从ThreadLocal的名字上可以看到，这是个线程的局部变量。也就是说只有当前线程可以访问，既然是只有当前线程池可以访问的数据自然是线程安全的。

package thread;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.locks.ReentrantLock;
    
    public class ThreadLocalDemo {
    
    	private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>();
    
    //如果不想要下面的t1.set则可以通过这种方式构造ThreadLocal.
    //	private static ThreadLocal<SimpleDateFormat> t1 = new ThreadLocal<SimpleDateFormat>() {
    //		public SimpleDateFormat initialValue() {
    //			return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //		}
    //	};
    	private static final SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    	private static ReentrantLock lock = new ReentrantLock();
    
    	public static class ParseDate implements Runnable {
    
    		int i = 0;
    
    		public ParseDate(int i) {
    			this.i = i;
    		}
    
    		// @Override
    		// public void run() {
    		// try {
    		// lock.lock();
    		// Date date = sm.parse("2018-8-12 17:30:" + i + "");
    		// System.out.println(i + "--" + date);
    		// lock.unlock();
    		// Thread.sleep(1000);
    		// } catch (ParseException e) {
    		// // TODO Auto-generated catch block
    		// e.printStackTrace();
    		// } catch (InterruptedException e) {
    		// // TODO Auto-generated catch block
    		// e.printStackTrace();
    		// }
    		// }
    
    		// @Override
    		// public void run() {
    		// try {
    		// synchronized (ParseDate.class) {
    		// Date date = sm.parse("2018-8-12 17:30:"+i+"");
    		// System.out.println(i+"--"+date);
    		// }
    		// Thread.sleep(1000);
    		// } catch (ParseException e) {
    		// // TODO Auto-generated catch block
    		// e.printStackTrace();
    		// } catch (InterruptedException e) {
    		// // TODO Auto-generated catch block
    		// e.printStackTrace();
    		// }
    		// }
    
    		@Override
    		public void run() {
    			if (t1.get() == null)
    				t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    
    			try {
    				Date date = t1.get().parse("2018-8-12 17:30:" + i + "");
    				System.out.println(i + "--" + date);
    				Thread.sleep(1000);
    			} catch (ParseException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			} catch (InterruptedException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    
    	}
    
    	public static void main(String[] args) {
    		ExecutorService es = Executors.newFixedThreadPool(10);
    
    		for (int i = 0; i < 30; i++)
    			es.execute(new ParseDate(i));
    	}
    
    }

![70][]

可以看到输出结果也是正确地。这里我有三种方式保证线程的安全性，锁和重入锁还有就是ThreadLocal。在线程ThreadLocal中if (t1.get() == null)  
                t1.set(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));

这两行代码的含义是，如果当前线程不持有SimpleDateFormat对象的实例则新建一个并将其设置到当前线程中。如果有则直接使用。从这里也可以看到为每个线程人手分配一个对象的工作并不是由ThreadLocal来完成的而是在应用层保证的。如果在应用上为每一个线程分配相同的对象实例，那么ThreadLocal也不能保证线程安全。（注意：为每个线程分配不同的对象，需要在应用层保证。ThreadLocal只是起到简单容器的作用。）

2.ThreadLocal的实现原理

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()拿到线程ThreadLocalMap，然后将值设入ThreadLocalMap中。（ThreadLocalMap可以简单的理解为一个Map，它是定义在Thread内部的成员。）

![70 1][]

设置到ThreadLocal中的数据，也是写入了threadLocals这个Map中。其中key为ThreadLocal当前对象，value则是我们需要的值这里是：new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")。而threadLocals本身就保存了当前自己所在线程的所有局部变量，也就是一个ThreadLocal变量的集合。

get()操作：

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

它也是先获取当前线程的ThreadLocalMap对象，然后通过将自己作为key取得内部的实际数据。

因为这些变量是维护在Thread类内部的,所以这意味着只要线程不退出，对象的引用将一直存在。而当线程退出时，Thread类会进行清理工作：

![70 2][]

因此如果使用线程池，这就意味着当前线程未必会退出（比如固定大小的线程池。）如果这样将一些太大的对象设置到ThreadLocal中（实际会保存在线程持有的threadLocals Map中）。可能会使系统出现内存泄露的可能。

此时如果希望及时的回收对象，最好使用ThreadLocal.remove()方法将这个变量移除。或者可以直接通过将ThreadLocal对象设为null的方式，让系统自行垃圾回收。

ThreadLocal的使用场景一般是共享对象对于竞争的处理容易引起性能的损失，这时候可以考虑使用ThreadLocal为每个线程分配单独的对象。

[70]: /images/20220517/9e56c116af804033b7b5ddafc15fca01.png
[70 1]: /images/20220517/f859d19b35a94f5597a4cbc01d35d812.png
[70 2]: /images/20220517/2a47fcf9759e4c18b86baaada47d5028.png