java 中ThreadLocal实例分析

时间:2022-11-08 22:18:59

java  中ThreadLocal实例分析

从概念上理解,threadlocal使变量在多个线程中相互隔离实现线程安全,threadlocal包装的变量最终都专属于对应的每个线程,线程之间相互独立,用一个具体实现来说明:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
public interface Consumer {
  int consume();
}
public class ComsumeThread implements Runnable {
 
  private Consumer consumer;
 
  public ComsumeThread(Consumer consumer) {
    this.consumer = consumer;
  }
 
  @Override
  public void run() {
    for(int i=0;i<10;i++){
      System.out.println(Thread.currentThread().getName()+" After Consume left:"+consumer.consume());
    }
 
  }
}
public class ConsumeClientA implements Consumer {
 
  private static int leftNum = 30;
 
  @Override
  public int consume() {
    int orgLeftNum = leftNum;
    Random random = new Random(System.currentTimeMillis());
    try {
      Thread.sleep(random.nextInt(3));
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    orgLeftNum = orgLeftNum -1;
    leftNum = orgLeftNum;
    return leftNum;
  }
 
  public static void main(String[] args){
    Consumer consumer = new ConsumeClientA();
    Thread thread1 = new Thread(new ComsumeThread(consumer));
    Thread thread2 = new Thread(new ComsumeThread(consumer));
    Thread thread3 = new Thread(new ComsumeThread(consumer));
 
    thread1.start();
    thread2.start();
    thread3.start();
  }
}

ConsumeClientA是在没有做任何线程安全处理,结果如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Thread-2 After Consume left:29
Thread-1 After Consume left:29
Thread-3 After Consume left:29
Thread-2 After Consume left:28
Thread-1 After Consume left:28
Thread-3 After Consume left:28
Thread-2 After Consume left:27
Thread-1 After Consume left:27
Thread-2 After Consume left:26
Thread-3 After Consume left:27
Thread-1 After Consume left:25
Thread-2 After Consume left:25
Thread-3 After Consume left:25
Thread-1 After Consume left:24
Thread-2 After Consume left:24
Thread-3 After Consume left:24
Thread-1 After Consume left:23
Thread-2 After Consume left:23
Thread-3 After Consume left:23
Thread-1 After Consume left:22
Thread-2 After Consume left:22
Thread-3 After Consume left:22
Thread-1 After Consume left:21
Thread-2 After Consume left:21
Thread-3 After Consume left:21
Thread-1 After Consume left:20
Thread-2 After Consume left:20
Thread-3 After Consume left:20
Thread-1 After Consume left:19
Thread-3 After Consume left:18

增加threadlocal处理,每个线程相互独立,实现如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class ConsumeClientB implements Consumer {
  private ThreadLocal<Integer> leftNumThreadLocal = new ThreadLocal<Integer>(){
    @Override
    protected Integer initialValue() {
      return 30;
    }
  };
 
  @Override
  public int consume() {
    int orgLeftNum = leftNumThreadLocal.get();
    Random random = new Random(System.currentTimeMillis());
    try {
      Thread.sleep(random.nextInt(3));
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    orgLeftNum = orgLeftNum -1;
    leftNumThreadLocal.set(orgLeftNum);
    return leftNumThreadLocal.get();
  }
 
  public static void main(String[] args){
    Consumer consumer = new ConsumeClientB();
    Thread thread1 = new Thread(new ComsumeThread(consumer));
    Thread thread2 = new Thread(new ComsumeThread(consumer));
    Thread thread3 = new Thread(new ComsumeThread(consumer));
 
    thread1.start();
    thread2.start();
    thread3.start();
  }
}

运行的结果如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Thread-1 After Consume left:29
Thread-3 After Consume left:29
Thread-2 After Consume left:29
Thread-1 After Consume left:28
Thread-3 After Consume left:28
Thread-2 After Consume left:28
Thread-1 After Consume left:27
Thread-3 After Consume left:27
Thread-2 After Consume left:27
Thread-1 After Consume left:26
Thread-3 After Consume left:26
Thread-2 After Consume left:26
Thread-1 After Consume left:25
Thread-3 After Consume left:25
Thread-2 After Consume left:25
Thread-1 After Consume left:24
Thread-3 After Consume left:24
Thread-2 After Consume left:24
Thread-1 After Consume left:23
Thread-3 After Consume left:23
Thread-2 After Consume left:23
Thread-1 After Consume left:22
Thread-3 After Consume left:22
Thread-2 After Consume left:22
Thread-1 After Consume left:21
Thread-3 After Consume left:21
Thread-2 After Consume left:21
Thread-1 After Consume left:20
Thread-3 After Consume left:20
Thread-2 After Consume left:20

每个线程拥有自己的独立变量,相互隔离实现线程安全。

那ThreadLocal是怎样实现这种线程隔离的线程安全的呢?

从ThreadLocal源码可以看到,真正实现线程隔离,与线程挂钩的,其实是ThreadLocal.ThreadLocalMap这个实现类,最明显的体现就在于Thread类源码的这样一个变量申明说明了ThreadLocal.ThreadLocalMap与Thread的关系:

?
1
ThreadLocal.ThreadLocalMap threadLocals, inheritableThreadLocals;

Thread类是包含threadLocals对象的,ThreadLocal的具体实现就是根据提供的get,set等接口,对当前thread的threadLocals变量进行相关操作的,如get操作代码如下:

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

可以看到,getMap()方法就是从当前thread获取对应的threadLocals变量,然后从这个ThreadLocal.ThreadLocalMap类型的threadLocals变量中获取对应线程中该ThreadLocal对象对应的变量值。

set方法的操作也是一样:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public void set(T value) {
  Thread t = Thread.currentThread();
  ThreadLocal.ThreadLocalMap map = getMap(t);
  if(map != null) {
    map.set(this, value);
  } else {
    this.createMap(t, value);
  }
 
}
 
void createMap(Thread t, T firstValue) {
  t.threadLocals = new ThreadLocalMap(this, firstValue);
}
?
1
2
3
4
5
6
7
8
static class Entry extends WeakReference<ThreadLocal> {
      Object value;
 
      Entry(ThreadLocal var1, Object var2) {
        super(var1);
        this.value = var2;
      }
    }

ThreadLocalMap中存的是内部类Entry的数组,Entry是继承WeakReference实现,WeakReference的好处是保存对象引用,而又不干扰该对象被GC回收,线程执行完回收threadLocals变量时不会受到Entry封装的变量的干扰。

而且ThreadLocalMap中的key是ThreadLocal,所以一个ThreadLocal对象只能在一个Thread对象中保存一个ThreadLocal的value。

综上,很多人说ThreadLocal的实现是ThreadLocalMap中存Thread对象为key,变量为value的map结构,其实是错误的。

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

原文链接:http://blog.csdn.net/jamesjxin/article/details/45173201