Java并發編程之ThreadLocal類詳解

概括起來說，對于多線程資源共享的問題，同步機制采用了“以時間換空間”的方式，而ThreadLocal采用了“以空間換時間”的方式。前者僅提供一份變量，讓不同的線程排隊訪問，而后者為每一個線程都提供了一份變量，因此可以同時訪問而互不影響。

模擬ThreadLocal

     import java.util.Collections;
    import java.util.HashMap;
    import java.util.Map;

    public class SimpleThreadLocal<T> {
    private Map<Thread, T> valueMap = Collections
    .synchronizedMap(new HashMap<Thread, T>());

    public void set(T newValue) {
    valueMap.put(Thread.currentThread(), newValue); // ①鍵為線程對象，值為本線程的變量副本
    }

    public T get() {
    Thread currentThread = Thread.currentThread();
    T o = valueMap.get(currentThread); // ②返回本線程對應的變量
    if (o == null && !valueMap.containsKey(currentThread)) { // ③如果在Map中不存在，放到Map中保存起來。
    o = initialValue();
    valueMap.put(currentThread, o);
    }
    return o;
    }

    public void remove() {
    valueMap.remove(Thread.currentThread());
    }

    protected T initialValue() {
    return null;
    }
    }

     class Count {
    private SimpleThreadLocal<Integer> count = new SimpleThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
    return 0;
    }
    };

    public Integer increase() {
    count.set(count.get() + 1);
    return count.get();
    }

    }

    class TestThread implements Runnable {
    private Count count;

    public TestThread(Count count) {
    this.count = count;
    }

    @Override
    public void run() {
    // TODO Auto-generated method stub
    for (int i = 1; i <= 3; i++) {
    System.out.println(Thread.currentThread().getName() + "\t" + i
    + "th\t" + count.increase());
    }
    }
    }

    public class TestThreadLocal {
    public static void main(String[] args) {
    Count count = new Count();
    Thread t1 = new Thread(new TestThread(count));
    Thread t2 = new Thread(new TestThread(count));
    Thread t3 = new Thread(new TestThread(count));
    Thread t4 = new Thread(new TestThread(count));
    t1.start();
    t2.start();
    t3.start();
    t4.start();
    }
    }