并发编程（9）threadLocal的用法

       本章我们将讨论ThreadLocal的使用，主要分以下几个章节：

.1)ThreadLocal是什么？

当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。

它并不是一个Thread，而是threadlocalvariable(线程局部变量，也叫线程本地变量)。

.2)ThreadLocal的使用

啥也不说，先看个例子

创建一个Person对象

public class Person {
	
	private int age;
	
	private String name;

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
}

ThreadLocal处理：

public class PersonManager {

	private static ThreadLocal<Person> personContor = new ThreadLocal<Person>() {
		@Override
		protected Person initialValue() {
			Person p = new Person();
			p.setAge(19);
			p.setName("xgj");
			return p;
		}
	};
	
	private static Person getPerson(){
		return personContor.get();
	}
	
	@SuppressWarnings("unused")
	private void setPerson(Person p){
		personContor.set(p);
	}
	
	public static void main(String[] args) throws InterruptedException {
		Thread p1=new Thread(){

			@Override
			public void run() {
				Person p=PersonManager.getPerson();
				p.setAge(20);
				System.out.println("Person["+p.getAge()+","+p.getName()+"]");
			}
			
		};
		Thread p2=new Thread(){

			@Override
			public void run() {
				Person p=PersonManager.getPerson();
				p.setAge(21);
				System.out.println("Person["+p.getAge()+","+p.getName()+"]");
			}
			
		};
		Thread p3=new Thread(){

			@Override
			public void run() {
				Person p=PersonManager.getPerson();
				System.out.println("Person["+p.getAge()+","+p.getName()+"]");
			}
			
		};
		
		System.out.println(PersonManager.getPerson().getAge());
		p1.start();
		p2.start();
		p3.start();
		p1.join();
		p2.join();
		p3.join();
		System.out.println(PersonManager.getPerson().getAge());
	}

}

执行结果：

19
Person[20,xgj]
Person[21,xgj]
Person[19,xgj]
19

从结果我们可以看出，Main函数在线程p1,p2,p3执行前后Person对象的age值不变，p1,p2,p3获取Person值后修改了age的值，但是3个线程之间互不影响，操作的都是当前线程绑定的person对象。

那么ThreadLocal的原理具体是什么呢？

我们先来看看ThreadLocal的源码提供的几个方法

.1)set(T value)

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

从这个方法中，首先获取一个和当前线程相关的ThreadLocalMap，然后将变量的值设置到这个ThreadLocalMap对象中，当然如果获取到的ThreadLocalMap对象为空，就通过createMap方法创建。我们再来看看ThreadLocalMap这个对象，ThreadLocalMap是ThreadLocal类的一个静态内部类，它实现了键值对的设置和获取，我们可以发现，map.set(this,value),这里的this指向的就是ThreadLocal对象，而值就是你所设置的对象了。我们来看一下getMap和createMap方法的实现

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

ThreadLocal.ThreadLocalMap threadLocals = null;

而createMap实现为：

void createMap(Thread t, T firstValue) {
        t.threadLocals = new ThreadLocalMap(this, firstValue);
    }

我们还注意到ThreadLocalMap代码中有弱引用，如下：

 static class Entry extends WeakReference<ThreadLocal> {
            /** The value associated with this ThreadLocal. */
            Object value;

            Entry(ThreadLocal k, Object v) {
                super(k);
                value = v;
            }
        }

大家请注意，之所以用的是弱引用，就是为了在ThreadLocal失去强引用的时候，TreadLocal对应的Entry能够在下次gc时被回收，回收后的空间能够得到复用，在一定的程度下能够避免内存泄露。

.2)T get()

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

get方法通过当前线程获取到ThreadLocalMap，如果ThreadLocalMap不为空，就根据ThreadLocal key从ThreadLocalMap中获取value值，如果ThreadLocalMap不存在，则调用初始化方法setInitialValue(),我们来看一下setInitialValue()方法，

 private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

在此方法中基本上跟set(T value)方法相呼应，请注意这行代码 T value =initialValue(); 这里调用了一个方法 initialValue()，我们下面来分析一下。

.3)initialValue()

来看一下源码实现，

protected T initialValue() {
        return null;
    }

本方法返回null，说明该方法应该由ThreadLocal子类重写,也就是有ThreadLocal实现类实现T的赋值。

       通过上面几个方法的分析，我们基本上了解了ThreadLocal的工作原理，每个线程都拥有一个ThreadLocalMap对象，其中ThreadLocal对象为key，value为线程共享对象的副本，这样没有线程访问的都是本线程的变量副本，从而实现了线程间的访问隔离。

.4)remove()

 public void remove() {
         ThreadLocalMap m = getMap(Thread.currentThread());
         if (m != null)
             m.remove(this);
     }

将当前线程局部变量的值删除，目的是为了减少内存的使用，需要注意的是，当线程结束后，对应线程的局部变量会被垃圾自动回收，所以显示调用该方法进行线程局部变量并不是必须的操作，但是能加快内存回收速度。