ThreadLocal使用实例介绍和原理分析

1. ThreadLocal的作用

1.1 一句话简介

  ThreadLocal又称为线程本地存储区（Thread Local Storage，简称为TLS），每个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。

1.2 两个使用场景

(1) 每个线程需要有自己单独的实例。
(2) 实例需要在一个线程的多个方法中共享，但不希望被多线程共享。
  这种使用场景，不是必须用ThreadLocal来实现，只不过ThreadLocal更加简洁优雅。
  对于第一点，每个线程拥有自己实例，实现它的方式很多。例如可以在线程内部构建一个单独的实例。ThreadLocal 可以以非常方便的形式满足该需求。
  对于第二点，可以在满足第一点（每个线程有自己的实例）的条件下，通过方法间引用传递的形式实现。ThreadLocal 使得代码耦合度更低，且实现更优雅。

1.3 代码验证

///java main函数实现
public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("当前线程的名字 = " + Thread.currentThread());
            System.out.println("当前线程的ThreadLocal哈希值= " + ThreadLocalBean.tlsb.hashCode());
            System.out.println("当前线程的StringBuilder哈希值 = " + ThreadLocalBean.sb.hashCode());
            System.out.println("当前线程的tlsb的StringBuilder = " + ThreadLocalBean.tlsb.get().hashCode());
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            System.out.println("当前线程的名字 = " + Thread.currentThread());
            System.out.println("当前线程的ThreadLocal哈希值= " + ThreadLocalBean.tlsb.hashCode());
            System.out.println("当前线程的StringBuilder哈希值 = " + ThreadLocalBean.sb.hashCode());
            System.out.println("当前线程的tlsb的StringBuilder = " + ThreadLocalBean.tlsb.get().hashCode());
        }).start();
    }

//ThreadLocalBean实现
public class ThreadLocalBean {
    public static ThreadLocal<StringBuilder> tlsb = new ThreadLocal<StringBuilder>() {
        @Override
        protected StringBuilder initialValue() {
            return new StringBuilder();
        }
    };
    //这里添加一个static的sb就是为了和ThreadLocal维护的StringBuilder进行对比的，我们知道静态的sb是一个类只有一个，因此可以预知这个sb的hash值在不同的线程中是一致的。
    public static StringBuffer sb = new StringBuffer();
}

当前线程的名字 = Thread[Thread-0,5,main]
当前线程的ThreadLocal哈希值= 1037172763
当前线程的StringBuilder哈希值 = 857078225
当前线程的tlsb的StringBuilder = 925526891

当前线程的名字 = Thread[Thread-1,5,main]
当前线程的ThreadLocal哈希值= 1037172763
当前线程的StringBuilder哈希值 = 857078225
当前线程的tlsb的StringBuilder = 1037842724

打印结果如上所示，由此得出结论：

1. 由于tlsb和sb是静态的，所以不同线程共享该对象，hashcode相同
2. 由tlsb，也即是ThreadLocal维护的StringBuilder则是线程隔离的，不同线程拥有自己的StringBuilder，同线程内所有所有方法获得StringBuilder相同。不同线程无法看到

2. 使用实例分析

  第一节中已经验证了ThreadLocal的作用，那么我们看看具体的应用，怎么能够更加优雅的写出代码。

2.1 不使用ThreadLocal

public class SessionBean {
    public static class Session {
        private String id;
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
    }

    public Session createSession() {
        return new Session();
    }

    public void setId(Session session, String id) {
        session.setId(id);
    }
    public String getId(Session session) {
        return session.getId();
    }
    public static void main(String[] args) {
    //没有使用ThreadLocal，在方法间共享session需要进行session在方法间的传递
        new Thread(() -> {
            SessionBean bean = new SessionBean();
            Session session = bean.createSession();
            bean.setId(session, "susan");
            System.out.println(bean.getId(session));
        }).start();
    }
}

  上述代码中，session需要在方法见传递才可以修改和读取，保证线程中各方法操作的是一个。

2.2 使用ThreadLocal

public class SessionBean {
//定义一个静态ThreadLocal变量session，就能够保证各个线程有自己的一份，并且方法可以方便获取，不用传递
    private static ThreadLocal<Session> session = new ThreadLocal<>();
    public static class Session {
        private String id;
        public String getId() {
            return id;
        }
        public void setId(String id) {
            this.id = id;
        }
    }

    public void createSession() {
        session.set(new Session());
    }

    public void setId(String id) {
        session.get().setId(id);
    }

    public String getId() {
        return session.get().getId();
    }

    public static void main(String[] args) {
        new Thread(() -> {
            SessionBean bean = new SessionBean();
            bean.createSession();
            bean.setId("susan");
            System.out.println(bean.getId());
        }).start();
    }
}

  在方法的内部实现，直接可以通过session.get()获取到当前线程的session，保证方法间用的是同一个，省掉了传递的环节。

3. ThreadLocal实现原理

查看ThreadLocal set和get方法源码

//ThreadLocal的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);
    }
//ThreadLocal的set方法源码
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();
    }

我们可以发现：
(1) getMap方法传入当前线程，获得一个ThreadLocalMap对象，说明每一个线程维护了自己的一个map，保证读取出来的value是自己线程的。
(2) ThreadLocalMap 是ThreadLocal静态内部类，存储value的键值就是ThreadLocal本身。
(3) 因此可以断定，每个线程维护一个ThreadLocalMap的键值对映射Map。不同线程的Map的键值是一样的，都是ThreadLocal，但是value是不同的。