Java线程：深入ThreadLocal-白红宇

ThreadLocal与线程成员变量还有区别，ThreadLocal该类提供了线程局部变量。这个局部变量与一般的成员变量不一样，ThreadLocal的变量在被多个线程使用时候，每个线程只能拿到该变量的一个副本，这是Java API中的描述，通过阅读API源码，发现并非副本，副本什么概念？克隆品? 或者是别的样子，太模糊。

准确的说，应该是ThreadLocal类型的变量内部的注册表（Map<Thread,T>）发生了变化，但ThreadLocal类型的变量本身的确是一个，这才是本质！

下面就做个例子：

一、标准例子

定义了MyThreadLocal类，创建它的一个对象tlt，分别给四个线程使用，结果四个线程tlt变量并没有出现共用现象，二是各用各的，这说明，四个线程使用的是tlt的副本（克隆品）。

/**

* 使用了ThreadLocal的类

* @author leizhimin 2010-1-5 10:35:27

public

class MyThreadLocal {

//定义了一个ThreadLocal变量，用来保存int或Integer数据

private ThreadLocal<Integer> tl =

new ThreadLocal<Integer>() {

@Override

protected Integer initialValue() {

return 0;

}

};

public Integer getNextNum() {

//将tl的值获取后加1，并更新设置t1的值

tl.set(tl.get() + 1);

return tl.get();

}

/**

* 测试线程

* @author leizhimin 2010-1-5 10:39:18

public

class TestThread

extends Thread {

private MyThreadLocal tlt =

new MyThreadLocal();

public TestThread(MyThreadLocal tlt) {

this.tlt = tlt;

}

@Override

public

void run() {

for (

int i = 0; i < 3; i++) {

System.out.println(Thread.currentThread().getName() +

"\t" + tlt.getNextNum());

}

/**

* ThreadLocal测试

* @author leizhimin 2010-1-5 10:43:48

public

class Test {

public

static

void main(String[] args) {

MyThreadLocal tlt =

new MyThreadLocal();

Thread t1 =

new TestThread(tlt);

Thread t2 =

new TestThread(tlt);

Thread t3 =

new TestThread(tlt);

Thread t4 =

new TestThread(tlt);

t1.start();

t2.start();

t3.start();

t4.start();

}

可以看出，三个线程各自独立编号，互不影响：

Thread-0 1

Thread-1 1

Thread-0 2

Thread-1 2

Thread-0 3

Thread-1 3

Thread-2 1

Thread-3 1

Thread-2 2

Thread-3 2

Thread-2 3

Thread-3 3

Process finished with exit code 0

tlt对象是一个，废话tl对象也是一个，因为组合关系是一对一的。但是tl对象内部的Map随着线程的增多，会创建很多Integer对象。只是Integer和int已经通用了。所以感觉不到Integer的对象属性。

二、不用ThreadLocal

假如不用ThreadLocal，只需要将MyThreadLocal类重新定义为：

/**

* 使用了ThreadLocal的类

* @author leizhimin 2010-1-5 10:35:27

public

class MyThreadLocal {

private Integer t1 = 0;

public Integer getNextNum(){

return t1=t1+1;

}

// //定义了一个ThreadLocal变量，用来保存int或Integer数据

// private ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {

// @Override

// protected Integer initialValue() {

// return 0;

// }

// };

// public Integer getNextNum() {

// //将tl的值获取后加1，并更新设置t1的值

// tl.set(tl.get() + 1);

// return tl.get();

// }

}

然后运行测试：

Thread-2 1

Thread-2 2

Thread-1 4

Thread-1 6

Thread-3 3

Thread-3 9

Thread-3 10

Thread-1 8

Thread-0 7

Thread-0 11

Thread-0 12

Thread-2 5

Process finished with exit code 0

从这里可以看出，四个线程共享了tlt变量，结果每个线程都直接修改tlt的属性。

三、自己实现个ThreadLocal

package com.lavasoft.test2;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

/**

* 使用了ThreadLocal的类

* @author leizhimin 2010-1-5 10:35:27

public

class MyThreadLocal {

//定义了一个ThreadLocal变量，用来保存int或Integer数据

private com.lavasoft.test2.ThreadLocal<Integer> tl =

new com.lavasoft.test2.ThreadLocal<Integer>() {

@Override

protected Integer initialValue() {

return 0;

}

};

public Integer getNextNum() {

//将tl的值获取后加1，并更新设置t1的值

tl.set(tl.get() + 1);

return tl.get();

}

class ThreadLocal<T> {

private Map<Thread, T> map = Collections.synchronizedMap(

new HashMap<Thread, T>());

public ThreadLocal() {

}

protected T initialValue() {

return

null;

}

public T get() {

Thread t = Thread.currentThread();

T obj = map.get(t);

if (obj ==

null && !map.containsKey(t)) {

obj = initialValue();

map.put(t, obj);

}

return obj;

}

public

void set(T value) {

map.put(Thread.currentThread(), value);

}

public

void remove() {

map.remove(Thread.currentThread());

}

运行测试：

Thread-0 1

Thread-0 2

Thread-0 3

Thread-2 1

Thread-2 2

Thread-3 1

Thread-2 3

Thread-3 2

Thread-1 1

Thread-3 3

Thread-1 2

Thread-1 3

Process finished with exit code 0

很意外，这个山寨版的ThreadLocal也同样运行很好，实现了JavaAPI中ThreadLocal的功能。

四、透过现象看本质

其实从程序角度看，tlt变量的确是一个，毫无疑问的。但是为什么打印出来的数字就互不影响呢？

是因为使用了Integer吗？-----不是。

原因是：protected T initialValue()和get()，因为每个线程在调用get()时候，发现Map中不存在就创建。调用它的时候，就创建了一个新变量，类型为T。每次都新建，当然各用个的互不影响了。

为了看清本质，将Integer换掉，重写部分类：

package com.lavasoft.test2;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

/**

* 使用了ThreadLocal的类

* @author leizhimin 2010-1-5 10:35:27

public

class MyThreadLocal {

//定义了一个ThreadLocal变量，用来保存int或Integer数据

// private ThreadLocal<Bean> tl = new ThreadLocal<Bean>() {

private com.lavasoft.test2.ThreadLocal<Bean> tl =

new com.lavasoft.test2.ThreadLocal<Bean>() {

@Override

protected Bean initialValue() {

return

new Bean();

}

};

@Override

public String toString() {

return

"MyThreadLocal{" +

"tl=" + tl +

'}';

}

public Bean getBean() {

return tl.get();

}

class ThreadLocal<T> {

private Map<Thread, T> map = Collections.synchronizedMap(

new HashMap<Thread, T>());

public ThreadLocal() {

}

protected T initialValue() {

return

null;

}

public T get() {

Thread t = Thread.currentThread();

T obj = map.get(t);

if (obj ==

null && !map.containsKey(t)) {

obj = initialValue();

map.put(t, obj);

}

return obj;

}

public

void set(T value) {

map.put(Thread.currentThread(), value);

}

public

void remove() {

map.remove(Thread.currentThread());

}

package com.lavasoft.test2;

/**

* 测试Bean

* @author leizhimin 2010-1-5 14:18:26

public

class Bean {

private String id =

"0";

private String name =

"none";

public Bean() {

}

public Bean(String id, String name) {

this.id = id;

this.name = name;

}

public String getId() {

return id;

}

public

void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public

void setName(String name) {

this.name = name;

}

public String showinfo() {

return

"Bean{" +

"id='" + id + '\'' +

", name='" + name + '\'' +

'}';

}

package com.lavasoft.test2;

/**

* 测试线程

* @author leizhimin 2010-1-5 10:39:18

public

class TestThread

extends Thread {

private MyThreadLocal tlt =

new MyThreadLocal();

public TestThread(MyThreadLocal tlt) {

this.tlt = tlt;

}

@Override

public

void run() {

System.out.println(

">>>>>:" + tlt);

for (

int i = 0; i < 3; i++) {

System.out.println(Thread.currentThread().getName() +

"\t" +tlt.getBean()+

"\t"+tlt.getBean().showinfo());

}

然后运行测试：

>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}

Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}

Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'}

Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'}

Thread-2 com.lavasoft.test2.Bean@fe64b9 Bean{id='0', name='none'}

Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}

Thread-3 com.lavasoft.test2.Bean@186db54 Bean{id='0', name='none'}

Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}

Thread-0 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}

Thread-1 com.lavasoft.test2.Bean@291aff Bean{id='0', name='none'}

Process finished with exit code 0

从打印结果很清楚的看到，MyThreadLocal的tlt对象的确是一个，tlt对象里的ThreadLocal的tl对象也是一个，但是，将t1t给每个线程用的时候，线程会重新创建Bean对象加入到ThreadLocal的Map中去使用。

本文转自 leizhimin 51CTO博客，原文链接：http://blog.51cto.com/lavasoft/258459，如需转载请自行联系原作者