ThreadLocal

　//ThreadLocal类提供的方法
1 public T get() {} 　　　　　　　　　　//get()方法是用来获取ThreadLocal在当前线程中保存的变量副本
public void set(T value) {}　　　　 //set()用来设置当前线程中变量的副本
public void remove() {}　　　　　　  //remove()用来移除当前线程中变量的副本
protected T initialValue() {}　　　 //initialValue()是一个protected方法,一般是用来在使用时进行重写的，它是一个延迟加载方法

 

get方法的实现：

　　

 　　第一句是取得当前线程，然后通过getMap(t)方法获取到一个map，map的类型为ThreadLocalMap。然后接着下面获取到<key,value>键值对，注意这里获取键值对传进去的是  this，而不是当前线程t。

　　如果获取成功，则返回value值。

　　如果map为空，则调用setInitialValue方法返回value。

分析：

　　首先看一下getMap方法中做了什么：

　　

　　在getMap中，是调用当期线程t，返回当前线程t中的一个成员变量threadLocals。

　　取Thread类中取看一下成员变量threadLocals是什么：

　　

　　实际上就是一个ThreadLocalMap，这个类型是ThreadLocal类的一个内部类，继续取看ThreadLocalMap的实现：

　　

　　可以看到ThreadLocalMap的Entry继承了WeakReference，并且使用ThreadLocal作为键值。然后再继续看setInitialValue方法的具体实现：

　　如果map不为空，就设置键值对，为空，再创建Map，看一下createMap的实现：

　　

总结：

　　首先，在每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。

　　初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。

　　然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。

 

1）实际的通过ThreadLocal创建的副本是存储在每个线程自己的threadLocals中的；

2）为何threadLocals的类型ThreadLocalMap的键值为ThreadLocal对象，因为每个线程中可有多个threadLocal变量，就像上面代码中的longLocal和stringLocal；

3）在进行get之前，必须先set，否则会报空指针异常；

　 如果想在get之前不需要调用set就能正常访问的话，必须重写initialValue()方法。

 

 

简单示例：

public class Test {
    
    public static ThreadLocal<String> t1 = new ThreadLocal<>();
    
    /**
     *    测试
     *        第一个打印的是未设置值
     *        第二个第三个分别获取的是   我的值     (也就证明了当没有向ThreadLocal中添加数据的时候，获取的是null)
     */
    public static void main(String[] args) {
        if(t1.get() == null) {
            System.out.println("未设置值");
            t1.set("我的值");
        }
        System.out.println(t1.get());
        System.out.println(t1.get());
    }
}

 

测试线程变量的隔离性：

/**
 *    工具类,定义公共的静态的ThreadLocal对象
 */
public class Tools {
    
    public static ThreadLocal<String> t1 = new ThreadLocal<>();

}

/**
 *    线程A,当前线程运行时会设置值并获取值
 */
public class ThreadA extends Thread {
    
    @Override
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                Tools.t1.set("ThreadA" + (i+1));
                System.out.println("ThreadA get Value = " + Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 *    线程B,当前线程运行时会设置值并获取值
 */
public class ThreadB extends Thread {
    
    @Override
    public void run() {
        try {
            for (int i = 0; i < 100; i++) {
                Tools.t1.set("ThreadB" + (i+1));
                System.out.println("ThreadB get Value = " + Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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++) {
                Tools.t1.set("Main" + (i+1));
                System.out.println("Main get Value=" + Tools.t1.get());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

　　

再次测试线程变量的隔离性：

import java.util.Date;

/**
 *    工具类,定义公共的静态的ThreadLocal对象
 */
public class Tools {
    
    public static ThreadLocal<Date> t1 = new ThreadLocal<>();

}

import java.util.Date;

/**
 *    线程A,当前线程运行时会先判断是否设置过值，如果没有设置，则设置一个值
 *    如果设置过了，则直接获取值
 */
public class ThreadA extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 20; i++) {
                if(Tools.t1.get() == null) {
                    Tools.t1.set(new Date());
                }
                System.out.println("ThreadA get Value = " + Tools.t1.get().getTime());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

import java.util.Date;

/**
 *    线程B,当前线程运行时会先判断是否设置过值，如果没有设置，则设置一个值
 *    如果设置过了，则直接获取值
 */
public class ThreadB extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 20; i++) {
                if(Tools.t1.get() == null) {
                    Tools.t1.set(new Date());
                }
                System.out.println("ThreadB get Value = " + Tools.t1.get().getTime());
                Thread.sleep(200);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    /**
     *    再次测试线程变量的隔离性，每个线程获取的值都为自己设置的值
     */
    public static void main(String[] args) {
        try {
            ThreadA a = new ThreadA();
            a.start();
            Thread.sleep(1000);
            ThreadB b = new ThreadB();
            b.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

ThreadLocal设置默认值,避免第一次获取值为null：

/**
 *    设置ThreadLocal中第一次默认值
 */
public class ThreadLocalExt extends ThreadLocal<String> {
    @Override
    protected String initialValue() {
        return "我是ThreadLocal的默认值";
    }
}

public class Run {

    public static ThreadLocalExt t1 = new ThreadLocalExt();
    /**
     *    测试设置ThreadLocal默认值
     */
    public static void main(String[] args) {
        
        if(t1.get() == null) {
            System.out.println("未设置值");
            t1.set("我的值");
        }
        System.out.println(t1.get());
        System.out.println(t1.get());
    }
}

运行结果如下：

　　

父子线程分别获取自己的值：

import java.util.Date;

/**
 *    设置ThreadLocal中第一次默认值
 */
public class ThreadLocalExt extends ThreadLocal<Date> {
    
    @Override
    protected Date initialValue() {
        return new Date();
    }
}

/**
 *    工具类,定义公共的静态的ThreadLocal对象
 */
public class Tools {
    
    public static ThreadLocalExt t1 = new ThreadLocalExt();

}

/**
 *    线程A
 */
public class ThreadA extends Thread {
    
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) { 
                System.out.println("ThreadA线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    /**
     *    从输出结果看出,父线程和子线程分别获取自己的值
     *        当main线程运行时获取的是线程当时new的Date
     *        当ThreadA运行时获取的就是ThreadA线程当时new的Date
     */
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Main线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
            Thread.sleep(5000);
            ThreadA a = new ThreadA();
            a.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

　　

继承InheritableThreadLocal类,实现子线程从父线程中获取值：

import java.util.Date;

/**
 *    实现InheritableThreadLocal类,实现从父线程获取值
 */
public class InheritableThreadLocalExt extends InheritableThreadLocal<Date> {
    
    @Override
    protected Date initialValue() {
        return new Date();
    }
}

/**
 *    工具类,定义公共的静态的ThreadLocal对象
 */
public class Tools {
    
    public static InheritableThreadLocalExt t1 = new InheritableThreadLocalExt();

}

/**
 *    线程A
 */
public class ThreadA extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) { 
                System.out.println("ThreadA线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    /**
     *    测试InheritableThreadLocalExt，从父线程中取值
     *        从输出结果可以看出,main线程运行时获取了默认的new Date()
     *        当子线程ThreadA在运行时，则获取的时同一个Date对象
     */
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Main线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
            Thread.sleep(5000);
            ThreadA a = new ThreadA();
            a.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：

　　

继承InheritableThreadLocal类,重写childValue()方法,修改子线程获取的默认值：

import java.util.Date;

/**
 *    继承InheritableThreadLocal类,实现childValue()方法,修改子线程获取的默认值
 */
public class InheritableThreadLocalExt extends InheritableThreadLocal<Object> {
    
    @Override
    protected Object initialValue() {
        return new Date().getTime();
    }
    
    @Override
    protected Object childValue(Object parentValue) {
        return parentValue + "我是子线程加的值";
    }
}

/**
 *    工具类,定义公共的静态的ThreadLocal对象
 */
public class Tools {
    
    public static InheritableThreadLocalExt t1 = new InheritableThreadLocalExt();

}

/**
 *    线程A
 */
public class ThreadA extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) { 
                System.out.println("ThreadA线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Run {
    /**
     * 通过继承InheritableThreadLocal实现子线程从父线程中获取值
     *         此时如果需要修改子线程的值,则通过重写childValue方法来设置子线程的值
     * 
     *         注：如果子线程在取得值的同时，主线程将InheritableThreadLocal中的值进行更改，
     *               那么子线程取得的值还是旧的值
     */
    public static void main(String[] args) {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("Main线程中取值为：" + Tools.t1.get());
                Thread.sleep(100);
            }
            Thread.sleep(5000);
            ThreadA a = new ThreadA();
            a.start();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

运行结果如下：