ThreadLocal原理及源码解析（一步一步点进去，不要背了，学思想）

public class AtomicTest {

	int i=0;
	public void incr(){
		i+=10;
		System.out.println(i);
	}
	
	public static void main(String[] args) throws InterruptedException {
		AtomicTest test=new AtomicTest();
		Thread[] threads=new Thread[5];
		for (int j = 0; j < 5; j++) {
			threads[j] =new Thread(() -> {
				test.incr();
			});
			threads[j].start();
		}
		for (int j = 0; j < 5; j++) {
		threads[j].join();
		}
	}
}

public class ThreadLocalTest {
	ThreadLocal<Integer> integerThreadLocal=new ThreadLocal<Integer>() {
		public Integer initialValue() {
			return 10;
		}
	};
	ThreadLocal<Integer> integerThreadLocal1=new ThreadLocal<Integer>() {
		public Integer initialValue() {
			return 20;
		}
	};
	public void incr() {
		int value = integerThreadLocal.get().intValue();
		integerThreadLocal.set(value += 10);
		int value1= integerThreadLocal1.get().intValue();
		integerThreadLocal1.set(value1 += 10);
		System.out.println(integerThreadLocal.get());
		System.out.println(integerThreadLocal1.get());
	}
	public static void main(String[] args) {
		ThreadLocalTest test=new ThreadLocalTest();
		Thread[] threads=new Thread[5];
		for (int j = 0; j < 2; j++) {
			threads[j] =new Thread(() -> {
			test.incr();
		});
	}

    public T get() {
    	//获取当前线程
        Thread t = Thread.currentThread();
        //去根据Thread拿ThreadLocalMap，我们发现Thread类下会有个数据对象叫做ThreadLocalMap
        //1.1 线程第一次进来，map肯定是null
        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;
            }
        }
        //1.2进入初始化方法
        return setInitialValue();
    }

static class ThreadLocalMap {
	/**
	* The entries in this hash map extend WeakReference,using
	* its main ref field as the key (which is always a
	* ThreadLocal object). Note that null keys (i.e.entry.get()==null) mean that the key is no longer referenced，
	* so the entry can be expunged from table. 
	* Such entries are referred to
	* as "stale entries" in the code that follows.
	*/
	static class Entry extends WeakReference<ThreadLocal<?>> {
	/** The value associated with this ThreadLocal. */
		Object value;
		Entry(ThreadLocal<?> k, Object v) {
			super(k);
			value = v;
		}
	}
//..........其他信息省略..................
}

public static void main(String[] args) {
	Object obj=new Object();//这样定义就是一个强引用
	Object obj2=obj;//也是一个强引用
	obj=null;
	System.gc();
	//会不会被垃圾回收？
	System.out.println(obj2);
}

Object obj=new Object();
SoftReference wrf=new SoftReference(obj);
obj=null;
System.out.println("未发生GC之前"+wrf.get());
System.gc();
System.out.println("内存充足，发生GC之后"+wrf.get());

Object obj=new Object();
WeakReference wrf=new WeakReference(obj);
obj=null;
System.out.println("未发生GC之前"+wrf.get());
System.gc();
System.out.println("内存充足，发生GC之后"+wrf.get());

private T setInitialValue() {
	//调用initialValue方法，默认为null，可以重写。重写设置初始值
	T value = initialValue();
	//获取当前线程
	Thread t = Thread.currentThread();
	//根据线程获取线程的ThreadLocalMap
	ThreadLocalMap map = getMap(t);
	//第一次初始化，为null
	if (map != null)
		map.set(this, value);
	else
		//走到创建Map逻辑 1.2.1
		createMap(t, value);
	return value;
}

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

ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue){
	//初始化Entry数组
	table = new Entry[INITIAL_CAPACITY];
	//根据线程的hashcode取模得到我应该放入数据的哪个下标位置
	int i = firstKey.threadLocalHashCode &(INITIAL_CAPACITY - 1);
	//在计算出的下标位置，放入entry,key为ThreadLocal对象，value为初始化的值
	table[i] = new Entry(firstKey, firstValue);
	size = 1;
	//设置ThreadLocalMap的threshold值，16*2/3=10
	setThreshold(INITIAL_CAPACITY);
}

public void set(T value) {
	//获取当前线程
	Thread t = Thread.currentThread();
	//获取线程的Map,这个时候，我们上面get的时候已经初始化，已经有值
	ThreadLocalMap map = getMap(t);
	//get如果在map之前执行，肯定不为null
	if (map != null)
	//进入set方法 
		map.set(this, value);
	else
		createMap(t, value);
}

private void set(ThreadLocal<?> key, Object value) {
	// We don't use a fast path as with get() because it is at least as common to use set() to create new entries as it is to replace existing ones, in which case, a fast path would fail more often than not.
	//将原有的table赋值给tab
	Entry[] tab = table;
	//得到tabl的大小
	int len = tab.length;
	//根据key的hashCode 取模数组，得到数据的下标，同一个key的时候，hashcode一样，所以
	//根据key找到的下标已经有entry对象并且已经赋值了初始化的值
	int i = key.threadLocalHashCode & (len-1);
	//在同一个key的get.set之后，e不为null,进入for循环
	for (Entry e = tab[i];
		e != null;
		e = tab[i = nextIndex(i, len)]) {
			//得到entry的key
			ThreadLocal<?> k = e.get();
			//因为get set传入的threadlocal对象是一个，满足条件
			if (k == key) {
				//将entry对象的value更改为新的value，返回
				e.value = value;
				return;
			}
			if (k == null) {
				replaceStaleEntry(key, value, i);
				return;
			}
		}
		tab[i] = new Entry(key, value);
		int sz = ++size;
		if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
	}

public void remove() {
	//根据当前线程获取ThreadLocalMap
	ThreadLocalMap m = getMap(Thread.currentThread());
	//如果ThreadLocalMap!=null
	if (m != null)
		//移除
		m.remove(this);
}

private void remove(ThreadLocal<?> key) {
	Entry[] tab = table;
	int len = tab.length;
	//根据key得到在数组中的下标位置
	int i = key.threadLocalHashCode & (len-1);
	for (Entry e = tab[i];
		e != null;
		e = tab[i = nextIndex(i, len)]) {
		//如果下标位置Entry的key为当前对象，进行整理清楚
		if (e.get() == key) {
			//解除Entry对key的弱引用
			e.clear();
			//对下标进行清除，并且对table进行整理
			expungeStaleEntry(i);
			return;
		}
	}
}

private void set(ThreadLocal<?> key, Object value) {
	// We don't use a fast path as with get() because it is at least as common to use set() to create new entries as
// it is to replace existing ones, in which case, a fast path would fail more often than not.
	Entry[] tab = table;
	int len = tab.length;
	int i = key.threadLocalHashCode & (len-1);
	for (Entry e = tab[i];
		e != null;
		e = tab[i = nextIndex(i, len)]) {
			ThreadLocal<?> k = e.get();
			if (k == key) {
				e.value = value;
				return;
			}
			if (k == null) {
			replaceStaleEntry(key, value, i);
			return;
		}
	}
	tab[i] = new Entry(key, value);
	int sz = ++size;
	//没有进行清理并且size大于等于我的扩容界限,调用rehash
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
}

private void rehash() {
	expungeStaleEntries();
	// Use lower threshold for doubling to avoid hysteresis
	//当容量大于等于四分之三时，进入resize方法
	if (size >= threshold - threshold / 4)
		resize();
}

private void resize() {
	Entry[] oldTab = table;
	int oldLen = oldTab.length;
	//扩容容量为原容量的2倍
	int newLen = oldLen * 2;
	//初始化数组长度
	Entry[] newTab = new Entry[newLen];
	int count = 0;
	//循环遍历老的容量大小
	for (int j = 0; j < oldLen; ++j) {
		//遍历Enrty
		Entry e = oldTab[j];
		//如果Entry不为null
		if (e != null) {
			//获取Entry的key
			ThreadLocal<?> k = e.get();
			//如果key为null,无效数据，把value设置为空，让value能gc回收
			if (k == null) {
				e.value = null; // Help the GC
			} else {
				//不为空，得到k的新的下标地址
				int h = k.threadLocalHashCode & (newLen - 1);
				//如果！=null.代表发生hash冲突
				while (newTab[h] != null)
					//线性探测下一个
					h = nextIndex(h, newLen);
				//赋值给为空的entry位置
				newTab[h] = e;
				count++;
			}
		}
	}
	//设置下一次的扩容值
	setThreshold(newLen);
	size = count;
	table = newTab;
}

private void set(ThreadLocal<?> key, Object value) {
	// We don't use a fast path as with get() because it is at
	// least as common to use set() to create new entries as
	// it is to replace existing ones, in which case, a fast
	// path would fail more often than not.
	Entry[] tab = table;
	int len = tab.length;
	//这里可能发送hash冲突，假如threadLocal1跟threadLocal 2个对象的hash值相同，下标都是5
	int i = key.threadLocalHashCode & (len-1);
	//通过i去拿数据的Entry,我们拿到的是ThreadLocal的，因为
	ThreadLocal占据了5这个位置
	for (Entry e = tab[i];
		e != null;
		e = tab[i = nextIndex(i, len)]) {
		//得到的是ThreadLocal对象
		ThreadLocal<?> k = e.get();
		//ThreadLocal !=ThreadLocal1
		if (k == key) {
			e.value = value;
			return;
		}
		//第一个循环 k也不等于null
		//第二轮循环，
		if (k == null) {
			replaceStaleEntry(key, value, i);
			return;
		}
		//3个条件都不满足，进入下一个循环
		//i= nextIndex(i, len) 去找下一个小标的位置，直到找到下一个key为空的为止，这个场景我们等下过
		//或者遍历完到一个null的位置，就不在循序
	}
	//找到一个为null的位置（肯定有，因为有扩容机制）
	tab[i] = new Entry(key, value);
	int sz = ++size;
	//清理后，如果超过我的扩容界限 扩容界限为三分之二，进行扩容
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
}

public T get() {
	Thread t = Thread.currentThread();
	ThreadLocalMap map = getMap(t);
	if (map != null) {
	//根据threadLocal对象 去map中获取Entry，如果冲突了我们看下怎么拿
		ThreadLocalMap.Entry e = map.getEntry(this);
		if (e != null) {
			T result = (T)e.value;
			return result;
		}
	}
	return setInitialValue();
}

private Entry getEntry(ThreadLocal<?> key) {
	//根据key的hash下标值去取值
	int i = key.threadLocalHashCode & (table.length - 1);
	Entry e = table[i];
	//如果取到的enrty不为null 并且对象也是我需要的对象，直接返回
	if (e != null && e.get() == key)
		return e;
	else
		//如果不是我想要的对象，进入getEntryAfterMiss
		return getEntryAfterMiss(key, i, e);
}

//key：我需要get的对象 i 根据key计算出来的下标 e 下标中的当前值
private Entry getEntryAfterMiss(ThreadLocal<?> key, int i,Entry e) {
	Entry[] tab = table;
	int len = tab.length;
	//如果e!=null。进入逻辑，如果e为null，说明ThreadLocal没有设置value，直接返回空
	while (e != null) {
		//得到当前位置的Entry对象
		ThreadLocal<?> k = e.get();
		//如果当前位置的Entry跟传进来的一致，直接返回
		if (k == key)
			return e;
		if (k == null)
			//如果对象的key被GC回收，进入整理逻辑，把当前位置设置为null 并且进行整理，rehash
			expungeStaleEntry(i);
		else
			//去下一个线性找
			i = nextIndex(i, len);
			//把e设置为下一个Enrty对象
		e = tab[i];
	}
	return null;
}

private void set(ThreadLocal<?> key, Object value) {
	// We don't use a fast path as with get() because it is at least as common to use set() to create new entries as
	// it is to replace existing ones, in which case, a fast path would fail more often than not.
	Entry[] tab = table;
	int len = tab.length;
	int i = key.threadLocalHashCode & (len-1);
	for (Entry e = tab[i];e != null;e = tab[i = nextIndex(i, len)]) {
			ThreadLocal<?> k = e.get();
			if (k == key) {
				e.value = value;
				return;
			}
		//因为Key被回收，所以key为null，会进入replaceStaleEntry方法
		if (k == null) {
			replaceStaleEntry(key, value, i);//这里这里
			return;
		}
	}
	//找到key为null的，不会走下面逻辑
	tab[i] = new Entry(key, value);
	int sz = ++size;
	if (!cleanSomeSlots(i, sz) && sz >= threshold)
		rehash();
}

//key为我需要获取值的ThreadLocal对象，value为需要set的值 i为key被回收的数组下标
//根据举例的场景：key为ThreadLocal1对象 value=10 i=5
private void replaceStaleEntry(ThreadLocal<?> key, Object value,int staleSlot) {
	Entry[] tab = table;
	int len = tab.length;
	Entry e;
	// Back up to check for prior stale entry in current run.
	// We clean out whole runs at a time to avoid continual
	// incremental rehashing due to garbage collector freeing
	// up refs in bunches (i.e., whenever the collector runs).
	//slotToExpunge为5
	int slotToExpunge = staleSlot;
	//向数组前面轮询找 找到一个null的entry为止 假如下标为4的entry为null,跳出循环
	for (int i = prevIndex(staleSlot, len);
	(e = tab[i]) != null;
	i = prevIndex(i, len))
	//假如下标为4的不是null,并且是被GC回收的，那么slotToExpunge赋值为向前找，找到最靠近null的被GC回收的Entry
	if (e.get() == null)slotToExpunge = i;
	// Find either the key or trailing null slot of run,whichever
	// occurs first
	//向后循环，找到entry为null为止
	for (int i = nextIndex(staleSlot, len);
		(e = tab[i]) != null;
		i = nextIndex(i, len)) {
		ThreadLocal<?> k = e.get();
		// If we find key, then we need to swap it
		// with the stale entry to maintain hash table order.
		// The newly stale slot, or any other stale slot
		// encountered above it, can then be sent to expungeStaleEntry
		// to remove or rehash all of the other entries in run.
		//假如向后找到了key跟我传入的一样的entry
		if (k == key) {
			//如果一样，替换value
			e.value = value;
			//假如下标为7的跟我传入的key是一样的
			tab[i] = tab[staleSlot];
			//在下标为5的位置放入7下的entry
			tab[staleSlot] = e;
			// Start expunge at preceding stale entry if it exists
			//如果slotToExpunge=slotToExpunge，则向前遍历没有找到key被回收的Entry
		if (slotToExpunge == staleSlot)
			//将slotToExpunge改成7
			slotToExpunge = i;
			//执行cleanSomeSlots方法
			cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);//expungeStaleEntry方法
			//返回
			return;
		}
		// If we didn't find stale entry on backward scan, the
		// first stale entry seen while scanning for key is the
		// first still present in the run.
		//如果循环到后面的也是被GC回收的，并且向前遍历没有找到key被回收的Entry
		if (k == null && slotToExpunge == staleSlot)
		//slotToExpunge设置为 key被GC回收的Entry的下标位置
			slotToExpunge = i;
	}
	// If key not found, put new entry in stale slot
	//回收的entry的value设置为null (利于value对象回收)
	tab[staleSlot].value = null;
	//在回收的下标位置，新建对象赋值
	tab[staleSlot] = new Entry(key, value);

	// If there are any other stale entries in run, expunge them
	//slotToExpunge!=staleSlot,需要向前或者向后有找到需要清理的Entry,执行cleanSomeSlots
	if (slotToExpunge != staleSlot)
		cleanSomeSlots(expungeStaleEntry(slotToExpunge),len);//expungeStaleEntry方法
}

private int expungeStaleEntry(int staleSlot) {
	Entry[] tab = table;
	int len = tab.length;
	// expunge entry at staleSlot
	//将传进来的下标位置的Entry value设置为null value就可以被GC回收了
	//将传进来的下标位置的Entry设置为null 清理空间
	tab[staleSlot].value = null;
	tab[staleSlot] = null;
	size--; //数组里的size-1
	// Rehash until we encounter null
	Entry e;
	int i;
	//根据传进来的位置向后遍历，遍历到null为止
	for (i = nextIndex(staleSlot, len);
		(e = tab[i]) != null;
		i = nextIndex(i, len)) {
		ThreadLocal<?> k = e.get();
		//如果entry对象的key被GC回收，清空entry
		if (k == null) {
			e.value = null;
			tab[i] = null;
			size--;
		} else {
			//如果entry的对象没有被GC回收
			//重新去计算下这个位置下的key的hash
			int h = k.threadLocalHashCode & (len - 1);
			//如果占的位置不是它hash的位置
			if (h != i) {
				//把现在的位置设置为null
				tab[i] = null;
				// Unlike Knuth 6.4 Algorithm R, we must scan until
				// null because multiple entries could have been stale.
				//看该有的位置是不是空的，如果不是，去找寻下一个null的（开放寻址解决hash冲突）
				while (tab[h] != null)
					h = nextIndex(h, len);
					//放到该有的位置去
					tab[h] = e;
			}
		}
	}
	//返回i的值 传进来的下标的 后面的最接近null的entry
	return i;
}

//i 传入下标 n为传进来的数组的长度
private boolean cleanSomeSlots(int i, int n) {
	boolean removed = false;
	Entry[] tab = table;
	int len = tab.length;
	do {
		//根据传进来的下标去找下标后一个
		i = nextIndex(i, len);
		//得到该下标的enrty
		Entry e = tab[i];
		//如果下标的enrty 的key被GC回收了
		if (e != null && e.get() == null) {
			//n改为table的长度
			n = len;
			removed = true;
			//拿到i去清除与重新rehash后面的，直到找到null为止
			i = expungeStaleEntry(i);
		}
	} while ( (n >>>= 1) != 0); //不用遍历n次，只遍历n/2次，达到时间与空间的平衡
		return removed; //如果有清除，设置为true
}