vi企业设计/快速排名seo软件

首先再讨论题主的这个观点之前我们要明确一下ThreadLocal的用途是什么？

ThreadLocal并不是用来解决共享对象的多线程访问问题。

看了许多有关ThreadLocal的博客，看完之后会给人一种错觉，ThreadLocal就是用于在多线程情况下防止共享对象的线程安全问题，使用ThreadLocal之后，ThreadLocal的对象就不会有线程安全问题，但是一定是这样么,看如下代码

1. public class test {
2. public static void main(String[] args) throws InterruptedException {
3. new A().start();
4. new A().start();
5. new A().start();
6. new A().start();
7. }
9. static class A extends Thread {
10. static List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
11. static ThreadLocal<List<Integer>> threadLocal = new ThreadLocal<List<Integer>>() {
12. @Override
13. protected List<Integer> initialValue() {
14. return list;
15. }
16. };
18. @Override
19. public void run() {
20. List<Integer> threadList = threadLocal.get();
21. threadList.add(threadList.size());
22. System.out.println(threadList.toString());
23. }
25. }
26. }

该代码很简单，就是在多线程的情况下输出ThreadLocal的list集合状态，如果此时线程安全的话，输出的4个语句应该是完全一样的输出结果如下：

[1, 2, 3, 4, 5, 5]
[1, 2, 3, 4, 5, 5, 6]
[1, 2, 3, 4, 5, 5, 6, 7]

[1, 2, 3, 4, 5, 5, 6, 7, 8]

 

很明显可以看到，线程是不安全的，从结果也能看出来4个线程中ThreadLocal中的List是同一个对象，被四个线程所共享。

接下来我们分析一下原因的发生原因，我们去看ThreadLocal的get()方法

1. public T get() {
2. Thread t = Thread.currentThread();
3. ThreadLocalMap map = getMap(t);
4. if (map != null) {
5. ThreadLocalMap.Entry e = map.getEntry(this);
6. if (e != null) {
7. @SuppressWarnings("unchecked")
8. T result = (T)e.value;
9. return result;
10. }
11. }
12. return setInitialValue();
13. }

如果一个线程第一次调用threadLocal.get()方法时，我们通过调试可以发现此时拿到的map是null，会调用setInitialValue()，继续看该方法

1. private T setInitialValue() {
2. T value = initialValue();
3. Thread t = Thread.currentThread();
4. ThreadLocalMap map = getMap(t);
5. if (map != null)
6. map.set(this, value);
7. else
8. createMap(t, value);
9. return value;
10. }

可以看到这个方法里面有一个value，而这个value就是ThreadLocal中即将要保存的只对线程所见的"副本",而这个value使用过initialValue()方法得到的,这个方法如果你没有重写的话默认返回时一个null，而在我们的例子当中他返回的是我们定义的静态变量list,而这个list是一个单例的(只会被类第一次访问时进行初始化)，也就是说我们的例子中每个线程的ThreadLocal里面get的都是同一个list，所以就造成了线程安全的问题.

接下来改善一下我们的代码

1. static class A extends Thread {
2. static ThreadLocal<List<Integer>> threadLocal = new ThreadLocal<List<Integer>>() {
3. @Override
4. protected List<Integer> initialValue() {
5. return new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
6. }
7. };
9. @Override
10. public void run() {
11. List<Integer> threadList = threadLocal.get();
12. threadList.add(threadList.size());
13. System.out.println(threadList.toString());
14. }
16. }

运行结果

[1, 2, 3, 4, 5, 5]
[1, 2, 3, 4, 5, 5]

[1, 2, 3, 4, 5, 5]

[1, 2, 3, 4, 5, 5]

 

接下来回到主题，ThreadLocal的作用是什么：

ThreadLocal使得各线程能够保持各自独立的一个对象，而实现原理其实是通过，每个线程都会重新创建一个对象，不是什么对象的拷贝或副本，而线程是否安全取决于你如何去创建这个对象。

然后总结一下：

1.ThreadLocal作用不是为了解决共享对象的多线程安全问题，而是为了避免通多参数传递的方式去拿到一个对象，网上有些例子就一开始拿线程安全举例子，然后抛砖引玉出ThreadLocal，会把人带偏。。。博主就是一个。

2.ThreadLocal中保存的不是什么对象的副本，里面没有需要保存的对象做任何复制，拷贝操作，这个对象完全取决于你的iniialtValue方法中如何去创建，所以这里需要考虑使用ThreadLocal的性能问题，是否会大量创建一个对象。