Java线程：深刻ThreadLocal

Java线程：深刻ThreadLocal

 

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

 

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

 

下面就作个例子：

 

1、标准例子

 

定义了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的对象属性。

 

2、不用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的属性。

 

3、本身实现个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的功能。

 

4、透过现象看本质

 

其实从程序角度看，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}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>:MyThreadLocal{tl=com.lavasoft.test2.MyThreadLocal$1@1de3f2d}
>>>>>: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-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-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-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中去使用。