ThreadLocal-----线程局部变量

• 介绍
  多线程访问同一个共享变量的时候容易出现并发问题，特别是多个线程对一个变量进行写入的时候，为了保证线程安全，一般使用者在访问共享变量的时候需要进行额外的同步措施才能保证线程安全性。ThreadLocal是除了加锁这种同步方式之外的一种保证一种规避多线程访问出现线程不安全的方法，当我们在创建一个变量后，如果每个线程对其进行访问的时候访问的都是线程自己的变量这样就不会存在线程不安全问题。

• 简单使用

  public class ThreadLocalTest {
  	static ThreadLocal<Person> tl = new ThreadLocal<>();
  	public static void main(String[] args) {
  		new Thread(() -> {
  			try {
  				TimeUnit.SECONDS.sleep(3);
  			} catch (InterruptedException e) {
  				e.printStackTrace();
  			}
  			tl.set(new Person());
  			System.out.println("----- " + tl.get().name);
  		}).start();
  		new Thread(() -> {
  			try {
  				TimeUnit.SECONDS.sleep(1);
  			} catch (InterruptedException e) {
  				e.printStackTrace();
  			}
  			Person p=new Person();
  			p.name="word";
  			tl.set(p);
  			System.out.println("===== " + tl.get().name);
  		}).start();
  	}
  	static class Person {
  		String name = "hello";
  	}
  }
  

• set方法源码

  public void set(T value) {
      Thread t = Thread.currentThread(); //获取当前线程（调用者线程）
      ThreadLocalMap map = getMap(t);//以当前线程作为key值，去查找对应的线程变量，找到对应的ThreadLocalMap
      if (map != null){
     		//如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
          map.set(this, value);
      }else{
      	//如果map为null，说明首次添加，需要首先创建出对应的ThreadLocalMap
          createMap(t, value);
     }
  }
  ThreadLocalMap getMap(Thread t) {
  	//获取线程自己的变量threadLocals，并绑定到当前调用线程的成员变量threadLocals上
  	return t.threadLocals; 
  }
  void createMap(Thread t, T firstValue) {
  	//创建当前线程threadLocals，同时也将要添加的本地变量值添加到了threadLocals中。
      t.threadLocals = new ThreadLocalMap(this, firstValue);
  }
  

• get方法源码

  public T get() {
      Thread t = Thread.currentThread();//获取当前线程
      ThreadLocalMap map = getMap(t);//通过当前线程，获取ThreadLocalMap
      if (map != null) {
      	//如果map变量不为null，就可以在map中查找到本地变量的值
          ThreadLocalMap.Entry e = map.getEntry(this);
          if (e != null) {
              @SuppressWarnings("unchecked")
              T result = (T)e.value;
              return result;
          }
      }
      //如果map为null,则初始化当前线程ThreadLocalMap
      return setInitialValue();
  }
  
  private T setInitialValue() {
      T value = initialValue();
      Thread t = Thread.currentThread();//获取当前线程
      ThreadLocalMap map = getMap(t);//通过当前线程，获取ThreadLocalMap
      if (map != null){
      	//如果map不为null，就直接添加本地变量，key为当前线程，值为添加的本地变量值
          map.set(this, value);
      }else{
      	//如果map为null，说明首次添加，需要首先创建出对应的ThreadLocalMap
          createMap(t, value);
      }
      return value;
  }
  

• remove方法的源码

  public void remove() {
       ThreadLocalMap m = getMap(Thread.currentThread());//根据当前线程，获取ThreadLoaclMap
       if (m != null)
       	//不等于null，就移除当前线程中指定ThreadLocal实例的本地变量
           m.remove(this);
   }
  

• 使用场景
  开一个事务AbstractPlatformTransactionManager#startTransaction中调用DataSourceTransactionManager#doBegin方法，创建连接并且标newConnectionHolder标记为true,调用TransactionSynchronizationManager#bindResource方法将connection与ThreadLocal绑定，事务提交或者回滚后，解除绑定。

  private static final ThreadLocal<Map<Object, Object>> resources =
  		new NamedThreadLocal<>("Transactional resources");
  
  private static final ThreadLocal<Set<TransactionSynchronization>> synchronizations =
  		new NamedThreadLocal<>("Transaction synchronizations");
  
  private static final ThreadLocal<String> currentTransactionName =
  		new NamedThreadLocal<>("Current transaction name");
  
  private static final ThreadLocal<Boolean> currentTransactionReadOnly =
  		new NamedThreadLocal<>("Current transaction read-only status");
  
  private static final ThreadLocal<Integer> currentTransactionIsolationLevel =
  		new NamedThreadLocal<>("Current transaction isolation level");
  
  private static final ThreadLocal<Boolean> actualTransactionActive =
  		new NamedThreadLocal<>("Actual transaction active");
  
  

• Java中的四种引用

  • 1、强引用
    如果一个对象具有强引用，它就不会被垃圾回收器回收。即使当前内存空间不足，JVM也不会回收它，而是抛出 OutOfMemoryError 错误，使程序异常终止。如果想中断强引用和某个对象之间的关联，可以显式地将引用赋值为null，这样一来的话，JVM在合适的时间就会回收该对象。

    M m = new M();
    m = null;//如果m设置为null，jvm垃圾回收时会回收m，否则永远不会
    System.gc();//垃圾回收
    

  • 2、软引用
    只有在内存空间不足时，软引用才会被垃圾回收器回收。

    -Xms20M -Xmx20M 提前修改虚拟机内存大写
    
    public static void main(String[] args) {
        SoftReference<byte[]> m = new SoftReference<>(new byte[1024*1024*10]);
        System.out.println(m.get());//输出一个地址
        System.gc();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(m.get());//输出一个地址
        //再分配一个数组，heap将装不下，这时候系统会垃圾回收，先回收一次，如果不够，会把软引用干掉
        byte[] b = new byte[1024*1024*15];
        System.out.println(m.get()); //输出 null，m被垃圾回收
    }
    

  • 3、弱引用
    当 JVM 进行垃圾回收，一旦发现弱引用对象，无论当前内存空间是否充足，都会将弱引用回收。
    ThreadLocal中的ThreadLocalMap中Entry继承WeakReference,Entry的key值是一个弱引用，当ThreadLocal对象的引用消失，那么Entry中的弱引用会自动回收；但是，value的值永远不会被回收，会造成内存泄漏，所以在ThreadLocal对象在不使用时调用remove方法。

    public static void main(String[] args) {
    
    	WeakReference<Object> m = new WeakReference<>(new Object());
    
        System.out.println(m.get());
        System.gc();
        System.out.println(m.get());
    
        ThreadLocal<Object> tl = new ThreadLocal<>();
        tl.set(new Object());
        tl.remove();
    }
    

  • 4、虚引用
    任何时候都可能被垃圾回收器回收，虚引用必须和引用队列关联使用，当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会把这个虚引用加入到与之关联的引用队列中。

    private static final List<Object> list = new LinkedList<>();
    private static final  ReferenceQueue<String> queue = new ReferenceQueue<String>();
    
    PhantomReference<String> pr = new PhantomReference<String>(new String(), queue);
    new Thread(() -> {
        while (true) {
            list.add(new byte[1024 * 1024]);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
                Thread.currentThread().interrupt();
            }
            System.out.println(phantomReference.get());
        }
    }).start();