Java多线程-线程封闭

线程封闭：当并发访问/修改共享的数据时，通常需要使用同步来避免线程安全性问题，一种简单的方式就是使当前共享数据只能在当前线程内访问，这样就不需要同步。

实现线程封闭的方法主要有两种：

1.栈封闭：众所周知方法内的局部变量为当前线程私有，不回因为并发而出现问题，所以如果在可能的情况下尽可能使用局部变量。

2ThreadLocal封闭：ThreadLocal是Java为解决多线程提供的一种解决方案，其内部其实维护了一个ThreadLocalMap，key为线程名，value为我们要维护的变量

下面我们看一下ThreadLocal中关于set(T)的源码：

public void set(T paramT)
{
Thread localThread = Thread.currentThread();
ThreadLocalMap localThreadLocalMap = getMap(localThread);
if (localThreadLocalMap != null)
localThreadLocalMap.set(this, paramT);
else
createMap(localThread, paramT);
}

用过集合类的同学是不是感觉一目了然，再看一下ThreadLocalMap的set实现：

private void set(ThreadLocal paramThreadLocal, Object paramObject)
    {
      Entry[] arrayOfEntry = this.table;
      int i = arrayOfEntry.length;
      int j = paramThreadLocal.threadLocalHashCode & i - 1;

      for (Entry localEntry = arrayOfEntry[j]; 
        localEntry != null; 
        localEntry = arrayOfEntry[(j = nextIndex(j, i))]) {
        ThreadLocal localThreadLocal = (ThreadLocal)localEntry.get();

        if (localThreadLocal == paramThreadLocal) {
          localEntry.value = paramObject;
          return;
        }

        if (localThreadLocal == null) {
          replaceStaleEntry(paramThreadLocal, paramObject, j);
          return;
        }
      }

      arrayOfEntry[j] = new Entry(paramThreadLocal, paramObject);
      int k = ++this.size;
      if ((!cleanSomeSlots(j, k)) && (k >= this.threshold))
        rehash();
    }

下面我们来看看ThreadLocal是如何处理对线程的引用，如果一直保持着对线程的引用，导致线程对象不能被GC，很可能会内存溢出的

static class Entry extends WeakReference<ThreadLocal>
{
Object value;

Entry(ThreadLocal paramThreadLocal, Object paramObject)
{
super();
this.value = paramObject;
}
}

当线程对象只被弱引用依赖时，那么GC会立刻回收这个对象，这就是弱引用的好处！他可以在你对对象结构和拓扑不是很清晰的情况下，帮助你合理的释放对象，造成不必要的内存泄漏

下面来看一个例子：

package test;

public class ThreadLocalTest {
private static class ThreadTest implements Runnable {
private final Person person;

public ThreadTest(Person person) {
this.person = person;
}

public void run() {
for (int i = 0; i < 10; i++) {
person.setName(person.getName()+i);
System.out.println("当前线程："+Thread.currentThread().getName()+" Person's name:" + person.getName());
}
}
}

public static void main(String[] args) {
Person person = new Person();
Thread t1 = new Thread(new ThreadTest(person));
Thread t2 = new Thread(new ThreadTest(person));
t1.start();
t2.start();
}
}

class Person {
private final ThreadLocal<String> name = new ThreadLocal<String>(){
@Override
protected String initialValue() {
return "张三";
}
};
public String getName() {
return name.get();
}

public void setName(String nam) {
name.set(nam);
}
}

再看看ThreadLocal的get方法，什么时候会调用initialValue

public T get()
{
Thread localThread = Thread.currentThread();
ThreadLocalMap localThreadLocalMap = getMap(localThread);
if (localThreadLocalMap != null) {
ThreadLocal.ThreadLocalMap.Entry localEntry = localThreadLocalMap.getEntry(this);
if (localEntry != null)
return localEntry.value;
}
return setInitialValue();
}

可以看出ThreadLocal为我们解决多线程编程提供了一种非常好的思路