类ThreadLocal的使用

        变量值的共享可以使用public static变量的形式，所有的线程都使用同一个public static 变量。如果想实现每一个线程都有自己的共享变量该如何解决呢？JDK中提供的类ThreadLocal正是为了解决这样的问题。

        类ThreadLocal主要解决的就是每个线程绑定自己的值，可以将ThreadLocal类比喻成全局存放数据的盒子，盒子中可以存储每个线程的私有数据。

1. ThreadLocal 的 get()方法 和 set() 方法        

public class ThreadF1 {

    public static ThreadLocal threadLocal = new ThreadLocal();

    @Test
    public void test1() {
        if (threadLocal.get() == null) {
            System.out.println("从未放过值");
            threadLocal.set("我的值");
        }
        System.out.println(threadLocal.get());
        System.out.println(threadLocal.get());
    }
}

执行结果：

从未放过值
我的值
我的值

结果分析：
    从运行结果可以看出，第一次调用 threadLocal 对象的 get() 方法时返回的值是 null，
通过调用 set()方法赋值后顺利取出至并打印到控制台上。类 ThreadLocal 解决的是变量在不
同线程间的隔离性，也就是不同线程拥有自己的值，不同线程中的值是可以放入 ThreadLocal 类
中进行保存的。

2. 验证线程变量的隔离性

public class ThreadF1 {
    @Test
    public void test2() {
        ThreadF1A threadF1A = new ThreadF1A();
        threadF1A.start();
        ThreadF1B threadF1B = new ThreadF1B();
        threadF1B.start();
        try {
            for (int i=0; i<100; i++) {
                Values.threadLocal.set("Main_" + i);
                System.out.println("Main get Value=" + Values.threadLocal.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Values {
    public static ThreadLocal threadLocal = new ThreadLocal();
}

class ThreadF1A extends Thread {
    @Override
    public void run() {
        try {
            for (int i=0; i<100; i++) {
                Values.threadLocal.set("ThreadF1A_" + i);
                System.out.println("ThreadF1A get Value=" + Values.threadLocal.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadF1B extends Thread {
    @Override
    public void run() {
        try {
            for (int i=0; i<100; i++) {
                Values.threadLocal.set("ThreadF1B_" + i);
                System.out.println("ThreadF1B get Value=" + Values.threadLocal.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行结果：
    从运行结果可以看出，虽然 Main、ThreadF1A、ThreadF1B 
三个线程都向 t1 对象中 set() 数据值，但每个线程还是能取出自
己的数据。

3. 解决get() 返回 null 问题，设定 ThreadLocal 默认值

public class ThreadF2 {
    private static ThreadLocalExt threadLocalExt = new ThreadLocalExt();

    @Test
    public void test1() {
        if (threadLocalExt.get() == null) {
            System.out.println("ThreadLocal没有值");
            threadLocalExt.set("我的值");
        }
        System.out.println(threadLocalExt.get());
    }
}

class ThreadLocalExt extends ThreadLocal {
    @Override
    protected Object initialValue() {
        return "我是默认值，第一次get不再为null";
    }
}

执行结果：
我是默认值，第一次get不再为null

4. 值继承

        使用 InheritableThreadLocal 类可以让子线程从父线程中取得值

public class ThreadF4 {
    @Test
    public void test() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println("[" + currentThreadName + "] init value:[" + ValTools.threadLocalExt.get() + "]");
        System.out.println("[" + currentThreadName + "] set value:[" + currentThreadName + "]");
        ValTools.threadLocalExt.set(currentThreadName);
        ThreadF4A threadF4A = new ThreadF4A();
        threadF4A.setName("ThreadF4A");
        threadF4A.start();
        while (Thread.activeCount() > 0) {}
    }
}

class InheritableThreadLocalExt extends InheritableThreadLocal {
    @Override
    protected Object initialValue() {
        return "我是可继承的ThreadLocal,可以让子线程从父线程中取得到值";
    }
}

class ValTools {
    public static InheritableThreadLocalExt threadLocalExt = new InheritableThreadLocalExt();
}

class ThreadF4A extends Thread {
    @Override
    public void run() {
        for (int i=0; i<5; i++) {
            String threadName = Thread.currentThread().getName();
            System.out.println("[" + threadName + "] value:[" + ValTools.threadLocalExt.get() + "]");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果：
[main] init value:[我是可继承的ThreadLocal,可以让子线程从父线程中取得到值]
[main] set value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]

        结果分析：

                从执行结果分析 ThreadF4A 线程取得到父线程设定的 ThreadLocal的值 “main”。

5. 值继承再修改

        值得注意的是，当使用 InheritableThreadLocal 类需要注意一点的是，如果子线程在取得值的同时，主线程将 InheritableThreadLocal 中的值进行更改，那么子线程取到的值还是旧值。

public class ThreadF4 {

@Test
    public void test1() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println("[" + currentThreadName + "] init value:[" + ValTools.threadLocalExt.get() + "]");
        System.out.println("[" + currentThreadName + "] set value:[" + currentThreadName + "]");
        ValTools.threadLocalExt.set(currentThreadName);
        try {
            Thread.sleep(1000);
            ThreadF4A threadF4A = new ThreadF4A();
            threadF4A.setName("ThreadF4A");
            threadF4A.start();
            Thread.sleep(2000);
            System.out.println("[" + currentThreadName + "] value:[Main_Go]");
            ValTools.threadLocalExt.set("Main_Go");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        while (Thread.activeCount() > 1) {}
    }
}

class InheritableThreadLocalExt extends InheritableThreadLocal {
    @Override
    protected Object initialValue() {
        return "我是可继承的ThreadLocal,可以让子线程从父线程中取得到值";
    }
}

class ValTools {
    public static InheritableThreadLocalExt threadLocalExt = new InheritableThreadLocalExt();
}

class ThreadF4A extends Thread {
    @Override
    public void run() {
        for (int i=0; i<5; i++) {
            String threadName = Thread.currentThread().getName();
            System.out.println("[" + threadName + "] value:[" + ValTools.threadLocalExt.get() + "]");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果：
[main] init value:[我是可继承的ThreadLocal,可以让子线程从父线程中取得到值]
[main] set value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]
[main] value:[Main_Go]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]
[ThreadF4A] value:[main]

        结果分析：

                从执行结果可以看出，ThreadF4A线程 在继承了 Main线程 的ThreadLocal的值后，Main线程对 InheritableThreadLocal 的值发生了改变后，ThreadF4A 线程取到的值还是原来的旧值。