ThreadLocal 学习

ThreadLocal很容易让人望文生义，想当然地认为是一个“本地线程”。如果你真的这么认为，那就错了！其实，它就是一个容器，用于存放线程的局部变量，当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。从线程的角度看，目标变量就象是线程的本地变量，这也是类名中“Local”所要表达的意思。

ThreadLocal的接口方法 

ThreadLocal类接口很简单，只有4个方法，我们先来了解一下：

void set(T value)

设置当前线程的线程局部变量的值。

public T get()

该方法返回当前线程所对应的线程局部变量。

public void remove()

将当前线程局部变量的值删除，目的是为了减少内存的占用，该方法是JDK 5.0新增的方法。

protected T initialValue()

返回该线程局部变量的初始值，该方法是一个protected的方法，显然是为了让子类覆盖而设计的。这个方法是一个延迟调用方法，在线程第1次调用get()或set(Object)时才执行，并且仅执行1次。ThreadLocal中的缺省实现直接返回一个null。

Thread线程中成员变量是基本数据类型

public class IntegerThread extends Thread {
    //
    private int number;

    //
    @Override
    public void run() {
        super.run();
        for(int i=0;i<3;i++){
            System.out.println(getName()+"=>"+ ++number);
        }
    }
}

class Test {

    public static void main(String[] args) {
        new IntegerThread().start();
        new IntegerThread().start();
        new IntegerThread().start();
    }
}

输出：
Thread-0=>0
Thread-0=>1
Thread-0=>2
Thread-1=>0
Thread-1=>1
Thread-1=>2
Thread-2=>0
Thread-2=>1
Thread-2=>2

我们看到输出结果，每个线程都是自己是变量，没有任何问题，对吧。下面看一下多个线程共享同一个线程的引用变量 

public interface Sequence {
    public int getSequence();
}

public class SequenceNumber implements Sequence {
    //
    private int number;

    //
    @Override
    public int getSequence() {
        return ++number;
    }
}

public class SequenceThread extends Thread {
    //
    private Sequence sequecne;

    //
    public SequenceThread(Sequence sequence){
        this.sequecne = sequence;
    }

    //
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(getName()+"=>"+sequecne.getSequence());
        }
    }
}

class Test {

    public static void main(String[] args) {
        Sequence sequence = new SequenceNumber();
        new SequenceThread(sequence).start();
        new SequenceThread(sequence).start();
        new SequenceThread(sequence).start();
    }
}

输出：
Thread-0=>1
Thread-0=>2
Thread-0=>3
Thread-1=>4
Thread-1=>5
Thread-1=>6
Thread-2=>7
Thread-2=>8
Thread-2=>9

从上面我们可以看出，所有的线程共享同一个Sequence，那么这里是有问题的。下面看一下我使用了ThreadLocal后会发生什么。

public interface Sequence {
    public int getSequence();
}

public class SequenceNumber implements Sequence {
    //
    private ThreadLocal<Integer> number = new ThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    //
    @Override
    public int getSequence() {
        number.set(number.get()+1);
        return number.get();
    }
}


public class SequenceThread extends Thread {
    //
    private Sequence sequecne;

    //
    public SequenceThread(Sequence sequence){
        this.sequecne = sequence;
    }

    //
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(getName()+"=>"+sequecne.getSequence());
        }
    }
}

class Test {

    public static void main(String[] args) {
        Sequence sequence = new SequenceNumber();
        new SequenceThread(sequence).start();
        new SequenceThread(sequence).start();
        new SequenceThread(sequence).start();
    }
}
输出：
Thread-0=>1
Thread-0=>2
Thread-0=>3
Thread-1=>1
Thread-1=>2
Thread-1=>3
Thread-2=>1
Thread-2=>2
Thread-2=>3

你看，有点神奇吧，number这样的成员引用类型的变量，又成了线程局部变量了。那么，ThreadLocal是如何做到的嘞？我听说是用一个map做到的，那么我们自己也写一个ThreadLocal，看一下效果吧。

public class MyThreadLocal<T> {
    //
    private Map<Thread,T> map = Collections.synchronizedMap(new HashMap<Thread, T>());


    //
    protected T initialValue(){
        return null;
    }

    //
    public T get(){
        Thread thread = Thread.currentThread();
        T value = map.get(thread);
        if(value==null && !map.containsKey(thread)){
            value = initialValue();
            map.put(thread,value);
        }
        return  value;
    }

    //
    public void set(T value){
        map.put(Thread.currentThread(),value);
    }

    //
    public void remove(){
        map.remove(Thread.currentThread());
    }
}


public class SequenceNumber implements Sequence {
    //
    private MyThreadLocal<Integer> number = new MyThreadLocal<Integer>(){
        @Override
        protected Integer initialValue() {
            return 0;
        }
    };

    //
    @Override
    public int getSequence() {
        number.set(number.get()+1);
        return number.get();
    }
}


class Test {

    public static void main(String[] args) {
        new SequenceThread().start();
        new SequenceThread().start();
        new SequenceThread().start();

    }
}
输出：
Thread-0=>1
Thread-0=>2
Thread-0=>3
Thread-1=>1
Thread-1=>2
Thread-1=>3
Thread-2=>1
Thread-2=>2
Thread-2=>3

我们看到，自己写的这个MyThreadLocal也可以达到相同的效果。这说明，MyThreadLocal实现版本显得比较幼稚，但它和JDK所提供的ThreadLocal类在实现思路上是相近的。通过以上的代码，我们应该可以看出，ThreadLocal没有什么难的，只要花一点儿心想看一下，写一写，就可以掌握。