本文内容基于jdk1.8版本
变量值的共享可以使用public static变量的形式，所有的线程都使用同一个public static变量。
如果想实现每一个线程都有自己的共享变量，则可以用JDK中提供的类ThreadLocal.
ThreadLocal类就像一个全局存放数据的盒子，盒子中可以存储每个线程的私有数据。

ThreadLocal解决的是同一个线程内的资源共享问题，而synchronized 解决的是多个线程间的资源共享问题

对于多线程资源共享的问题，synchronized同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

测试隔离性例子:

新建项目test1，新建类LocalData:

package test1;
public class LocalData {
    public static ThreadLocal t1 = new ThreadLocal();
}

新建类ThreadA和ThreadB：

package test1;
public class ThreadA extends Thread{
    public void run(){
        try{
            for(int i = 0; i < 100; i++){
                LocalData.t1.set("ThreadA" + (i + 1));
                System.out.println("ThreadA get Value="+ LocalData.t1.get());
                Thread.sleep(200);
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

package test1;
public class ThreadB extends Thread {
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                LocalData.t1.set("ThreadB" + (i + 1));
                System.out.println("ThreadB get Value=" + LocalData.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

新建main入口类Run

package test1;
public class Run {
    public static void main(String[] args) {
        try {
            ThreadA a = new ThreadA();
            ThreadB b = new ThreadB();
            a.start();
            b.start();
            for (int i = 0; i < 100; i++) {
                LocalData.t1.set("Main" + (i + 1));
                System.out.println("Main get Value=" + LocalData.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

image.png

要设置get的默认值，覆写initialValue方法：

import java.time.Instant;
public class ThreadLocalExt extends ThreadLocal {
    @Override
    protected Object initialValue(){
        return Instant.now().getNano();
    }
}

类InheritableThreadLocal

类InheritableThreadLocal可以在子线程中取得父线程继承下来的值。
值继承例子：
新建项目test2，新建InheritableThreadLocalExt类

package test2;
import java.time.Instant;
public class InheritableThreadLocalExt extends InheritableThreadLocal {
    @Override
    protected Object initialValue(){
        return Instant.now().getNano();
    }
    @Override
    protected Object childValue(Object parentValue){
        return parentValue + " 子线程新加内容，i'm child value";
    }
}

新建ThreadA类：

package test2;
public class ThreadA extends Thread {
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Thread线程中取值=" + LocalData2.t1.get());
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

新建LocalData2类：

package test2;
public class LocalData2 {
    public static InheritableThreadLocalExt t1 = new InheritableThreadLocalExt();
}

新main入口类：

package test2;
public class Run {
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Main 线程中取值=" + LocalData2.t1.get());
                Thread.sleep(100);
            }
            Thread.sleep(5000);
            ThreadA a = new ThreadA();
            a.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

image.png

源码解析：

ThreadLocal类set和get方法：

 public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
 }

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null) {
                @SuppressWarnings("unchecked")
                T result = (T)e.value;
                return result;
            }
        }
        return setInitialValue();
    }

每个线程中都有一个独立的ThreadLocalMap副本，它所存储的值，只能被当前线程读取和修改。ThreadLocal类通过操作每一个线程特有的ThreadLocalMap副本，从而实现了变量访问在不同线程中的隔离。因为每个线程的变量都是自己特有的，完全不会有并发错误。