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为我们解决多线程编程提供了一种非常好的思路