java分析碰撞的原理,Java ThreadLocal原理分析

大家或多或少听说过ThreadLocal这个词,我们创建的对象默认是所有线程可以访问的,多线程并发修改对象时就会可能出现数据不一致的问题,使用ThreadLocal创建的对象只能被当前线程访问，每个线程保存一个对象的副本,在多线程操作时是线程安全的。

ThreadLocal用法简介

比如有这样一个类:

1

2

3

4

5

6

7public class Counter{

private int count;

public Counter(int cnt){

this.count = cnt;

}

//省略setter()和getter()方法

}

我们希望多线程访问Counter对象时，各个线程各自保留一份count计数,那可以这么写:

1

2

3ThreadLocal threadLocal = new ThreadLocal<>();

threadLocal.set(new Counter(0));

Counter counter = threadLocal.get();

如果你不想每次调用的时候都去初始化,那可以重写ThreadLocal的initValue()方法给ThreadLocal设置一个对象的初始值,如下所示:

1

2

3

4

5

6ThreadLocal threadLocal = new ThreadLocal() {

@Override

protected Counter initialValue(){

return new Counter(0);

}

};

这样每次调用threadLocal.get()的时候，会去判断当前线程是否存在Counter对象,如果不存在则调用initValue()方法初始化。

ThreadLocal实现原理

我们先来看一下ThreadLocal的get()方法，如下所示:

1

2

3

4

5

6

7

8

9

10

11

12

13public 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();

}

调用get()方法时先获取到当前线程,然后通过线程获取每个线程绑定的ThreadLocalMap对象,map中的key就是ThreadLocal对象,Value就是实际我们要访问的对象，上面的例子中是Counter对象,如果Entry为空,那就调用setInitialValue()方法设置初始值。

ThreadLocalMap实现原理

从前面可以看出每个线程内部有个ThreadLocalMap,从java.lang.Thread类的源码也可以看到Thread类有个ThreadLocal.ThreadLocalMap threadLocals属性,接下来我们来分析下它的实现原理:

ThreadLocalMap和WeakHashMap实现有点类似，也是利用了WeakReference来和GC建立关联,因为ThreadLocal对象被线程对象引用，如果一个线程的生命周期比较长,那可能会出现内存泄露的问题，ThreadLocalMap借助弱引用巧妙的解决了这个问题，源码如下所示:

1

2

3

4

5

6

7

8

9

10

11static class ThreadLocalMap{

static class Entry extends WeakReference>{

/** The value associated with this ThreadLocal. */

Object value;

//这里的Entry并不是一个链表,如果出现hash碰撞,会放到数组的下一个位置

Entry(ThreadLocal> k, Object v) {

super(k);

value = v;

}

}

}

从源码可以看到ThreadLocalMap的Entry继承自WeakReference,Entry中的key是一个弱引用，也就是说线程类持有了ThreadLocal对象的一个弱引用,当ThreadLocal对象没有其他强引用关联时,在GC时会把ThreadLocal对象回收掉，但是这里仅仅回收ThreadLocal对象,Entry对象和Value并没有回收,ThreadLocalMap里就可能存在很多Key为null的Entry,所以需要在调用map.getEntry()时对key为null的对象进行处理,源码如下:

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

28private Entry getEntry(ThreadLocal> key){

int i = key.threadLocalHashCode & (table.length - 1);

Entry e = table[i];

if (e != null && e.get() == key)

return e;

else

//当前位置没有找到,可能Hash碰撞了

return getEntryAfterMiss(key, i, e);

}

private Entry getEntryAfterMiss(ThreadLocal> key, int i, Entry e){

Entry[] tab = table;

int len = tab.length;

while (e != null) {

ThreadLocal> k = e.get();

if (k == key)

//找到了直接返回

return e;

if (k == null)

//检测到有个ThreadLocal对象被回收了,这个时候去清理后面所有Key为null的Entry

expungeStaleEntry(i);

else

i = nextIndex(i, len);

e = tab[i];

}

return null;

}

从源码中可以看到ThreadLocalMap清理掉key为Null的Entry的时机是根据ThreadLocal对象的hashCode去获取entry时发生了hash碰撞,并且下一个entry的key为null时才去清理,因为ThreadLocalMap的Entry和普通Map的不太一样，一般的Map是一个链表数组，而它的数组每个元素就是一个Entry，如果出现Hash碰撞了就放到数组的下一个位置,因此如果get的时候发现没有碰撞可以认为当前Map中的元素还不多，一旦检测到碰撞了并且下一个entry的key被回收了,就调用expungeStaleEntry()来释放ThreadLocal为null的那些entry,避免了内存泄露。

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

34private int expungeStaleEntry(int staleSlot){

Entry[] tab = table;

int len = tab.length;

// expunge entry at staleSlot

tab[staleSlot].value = null;

tab[staleSlot] = null;

size--;

// Rehash until we encounter null

Entry e;

int i;

for (i = nextIndex(staleSlot, len);

(e = tab[i]) != null;

i = nextIndex(i, len)) {

ThreadLocal> k = e.get();

if (k == null) {

//清理key为null的entry

e.value = null;

tab[i] = null;

size--;

} else {

int h = k.threadLocalHashCode & (len - 1);

//hashCode发生了变化,重新放置entry

if (h != i) {

tab[i] = null;

while (tab[h] != null)

h = nextIndex(h, len);

tab[h] = e;

}

}

}

return i;

}

总结

ThreadLocal可以保证每个线程拥有一个变量的副本，实现了线程隔离,主要利用了每个Thread有个ThreadLocalMap,ThreadLocalMap保存了该线程拥有的所有ThreadLocal对象，并利用弱引用机制避免了Map无线增大导致内存泄露的问题。