并发编程（九）锁优化及ThreadLocal实现原理
目录
- 锁优化的思想
- ThreadLocal及其源码分析
锁优化的思想
- 减少锁持有时间
- 像比如在调用某个方法时其中只有一小部分是需要同步的，那么大可不必将整个方法上锁，而是对需要同步的这一小块代码加上同步锁，以此来降低锁持有的时间，该优化还会提高自旋锁的成功率。
- 减小锁的颗粒度
- 将一个大对象拆成小对象，增加并行度降低锁的竞争，比如jdk。1.7的concurrentHashMap中就是采用分段锁的方式将一个大对象分成若干个segment，每个线程只会对segment进行加锁访问，每个segment之间互不干扰。并且减小锁的颗粒度时还会让偏向锁，轻量级锁的成功率提高。
- 锁分离
- 将锁以功能来进行区分，就像之前提到的ReadWriteLock,它就将读写进行了分离，使读读不互斥以此增加并行度提高整体的性能。
- 锁粗化
- 在此之前我们提出了对锁的优化可以减少锁持有时间，但是如果对同一个锁不停的请求、同步和释放的话反而会降低系统的性能，所以可以将两个同步代码进行合并，但前提是中间代码不会占用太多的时间，否则也是不妥的。
- 锁消除
- 在即时编译器时，如果发现不可能被共享的对象，则可以消除这些对象的锁操作，（这些锁可能不是你自己加的锁对象，而是在一些不必要使用的场景使用了一些jdk提供的线程安全类）。
- 但是锁消除需要编译器在server模式下运行并开启逃逸分析和锁消除：
ThreadLocal及其源码分析
- ThreadLocal出现的原因，因为我们知道关于并发的出现是因为多个线程需要访问同一个临界区，而如果说线程都访问自己的变量，线程之间就不会存在竞争也不用在进行加锁来防止程序错误，所以就引出了ThreadLocal。
- ThreadLocal的应用：
public class ThreadLocalVariableHolder implements Runnable{ private static ThreadLocal<Integer> value=new ThreadLocal<Integer>(){ private Random rand=new Random(2); //对ThreadLocal的值进行初始化 protected synchronized Integer initialValue(){ return rand.nextInt(10000); } }; //对ThreadLocal的值做自增操作。 public void increment(){ value.set(value.get()+1); } @Override public void run() { //判断线程是否中断 while (!Thread.currentThread().isInterrupted()){ increment(); System.out.println(Thread.currentThread().getName()+":"+value.get()); } } public static void main(String[] args) { ExecutorService exec= Executors.newCachedThreadPool(); for (int i = 0; i < 3; i++) { exec.execute(new ThreadLocalVariableHolder()); } try { TimeUnit.MICROSECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } exec.shutdownNow(); } }
可以看到每个线程的变量值都不同。部分打印结果： pool-1-thread-1:6109 pool-1-thread-3:4041 pool-1-thread-3:4042 pool-1-thread-3:4043 pool-1-thread-2:1373 pool-1-thread-3:4044 pool-1-thread-1:6110 pool-1-thread-3:4045 pool-1-thread-2:1374 pool-1-thread-3:4046 - 源码解析：
-
静态内部类ThreadLocalMap
- 我们这里讲到ThreadLocal，其底层操作都是基于ThreadLocalMap来加以实现，该ThreadLocalMap的对象是线程的一个本地变量，该ThreadLocalMap是专门用于处理线程本地变量进行构建的。
- 首先我们先查看ThreadLocalMap的一个成员变量
- INITIAL_CAPACITY：map的默认初始化大小为16
- size：记录当前数组的大小
- table：为当前Map对象的基础，也就是该Map对象是一个数组+Entry的一个结构
- threshold：下一次扩容的阈值
- 我们在看到table成员变量其实是ThreadLocalMap的一个结构，那我们再看一看Entry内部的结构
我们看到Entry是继承了个弱引用，并将key标注为一个弱引用的对象，也就是在下一次GC的时候就会被回收掉，那如果这样虽然key被回收了但是Value不会被回收难道不会出现问题？那为什么会继承弱引用呢，因为如果一个线程一直没有销毁，那就一直没有办法回收，会严重的占用内存空间。（比如线程池，线程在使用的使用完本地线程变量后，线程不会关闭这样会造成无谓的损耗。） - 初始化：
回到ThreadLocalMap类，知道了其具体结构后我们先去看到关于map中存值是怎么样进行的，进入到构造函数中进行查看ThreadLocalMap(ThreadLocal<?> firstKey, Object firstValue) { //对table变量进行初始化，并设定数据大小为INITIAL_CAPACITY，也就是16 table = new Entry[INITIAL_CAPACITY]; //这里计算索引的方式就跟jdk1.8中hashmap在扩容时计算索引位置是一样的 int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1); //然后进行赋值 table[i] = new Entry(firstKey, firstValue); size = 1; //设置下一次扩容的阈值 setThreshold(INITIAL_CAPACITY); } /** * 初始化完毕后我们看到还调用了setThreshold方法， * 它其实就是计算下一次扩容的阈值，我们根据setThreshold * 方法内部可以看出，其负载因子为0.75。 */ private void setThreshold(int len) { threshold = len * 2 / 3; } - 存值：
/** * 将当前ThreadLocal对象作为键，将键值存入到ThreadLocalMap中 */ private void set(ThreadLocal<?> key, Object value) { //拿到当前的数组对象 Entry[] tab = table; int len = tab.length; //计算当前entry的索引位置 int i = key.threadLocalHashCode & (len-1); //从当前索引位置开始遍历如果获取的entry对象直到获取到的entry为null停止 for (Entry e = tab[i]; e != null;e = tab[i= nextIndex(i, len)]) { //这个是从entry对象中获取键值 ThreadLocal<?> k = e.get(); //如果获取到的键与当前的键是相等的则将值进行替换就可以了 if (k == key) { e.value = value; return; } /** * 这里是如果获取的key为null，为什么为null？ * 还记得之前提到的Entry继承了一个弱引用吗？ * 如果发生了GC就会将key变为null，但是其value * 不会为null，元素也不会为null，这样ThreadLocalMap * 就可以针对此类entry对象进行清理 */ if (k == null) { replaceStaleEntry(key, value, i); return; } } //如果获取数组元素为null则将当前数组索赋值。 tab[i] = new Entry(key, value); //将当前map大小加1 int sz = ++size; /** * 从当前元素位置的下一位置开始清理无效元素，如果没有发生无效元素的清理说明对数清理方式没有找到无效元素 且在当前数组实际长度大于阈值的情况下需要对数组进行全面清理，如果 */ if (!cleanSomeSlots(i, sz) && sz >= threshold) rehash(); } /** * 判断当前的索引加1是否大于数组长度，如果大于则返回数组第一位元素下标值否则返回索引加1 */ private static int nextIndex(int i, int len) { return ((i + 1 < len) ? i + 1 : 0); } /** * 判断当前的索引减1是否大于等于0，如果成立返回当前索引减1，否则返回数组的最后一位元素下标值。 */ private static int prevIndex(int i, int len) { return ((i - 1 >= 0) ? i - 1 : len - 1); } /** * 将无效元素进行清理并将键值存入到Map中 */ private void replaceStaleEntry(ThreadLocal<?> key, Object value, int staleSlot) { Entry[] tab = table; int len = tab.length; Entry e; //拿到当前无效元素的索引 int slotToExpunge = staleSlot; //往前遍历，查找最前面的一个无效元素 for (int i = prevIndex(staleSlot, len);(e = tab[i]) != null;i = prevIndex(i, len)) if (e.get() == null) slotToExpunge = i; //从当前无效元素往后遍历 for (int i = nextIndex(staleSlot, len); (e = tab[i]) != null; i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); //找到了key相等的元素，将其与无效元素进行交换，并把无效元素的值更新有需要存入的值 if (k == key) { e.value = value; tab[i] = tab[staleSlot]; tab[staleSlot] = e; //如果之前的往前扫描中没有找到无效元素，则从 //当前交换后的元素位置开始作为开始清理的位置 if (slotToExpunge == staleSlot) slotToExpunge = i; // 从slotToExpunge开始做一次连续段的清理，再做一次启发式清理 cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); return; } //如果当前遍历到节点也是无效元素，且向前扫描时没有其他无效元素， //则更新slotToExpunge为当前元素位置 if (k == null && slotToExpunge == staleSlot) slotToExpunge = i; } //走到这里说明数组中不存在该key的元素，则将当前无效元素更新为新的元素。 tab[staleSlot].value = null; tab[staleSlot] = new Entry(key, value); //再当前无效元素之前存在有无效元素，则从slotToExpunge开始清理。 if (slotToExpunge != staleSlot) cleanSomeSlots(expungeStaleEntry(slotToExpunge), len); } /** * 清理当前索引位置的无效元素，并且找到下一个元素如果无效也做清理，否则重新排位。 */ private int expungeStaleEntry(int staleSlot) { Entry[] tab = table; int len = tab.length; //清理当前无效元素，并将数组实际长度减一 tab[staleSlot].value = null; tab[staleSlot] = null; size--; Entry e; int i; //从该无效元素索引往后遍历 for (i = nextIndex(staleSlot, len); (e = tab[i]) != null;i = nextIndex(i, len)) { ThreadLocal<?> k = e.get(); //如果下一个元素也是无效元素，也做清理操作 if (k == null) { e.value = null; tab[i] = null; size--; } else { /** * 否则获取当前元素本来索引位置，如果本来位置与当前位置不相等 * 则先将当前元素置空，在从本来索引位置开始往下寻找一直到元素为null， * 则将该元素赋值为当前的entry。这样的操作相当于rehash操作 */ int h = k.threadLocalHashCode & (len - 1); if (h != i) { tab[i] = null; while (tab[h] != null) h = nextIndex(h, len); tab[h] = e; } } } return i; } /** * 从当前索引位置的下一元素开始对无效元素进行清理，循环在n/2次数后结束 * 其采用对数数量扫描的方式，因为相对每次的全数组扫描的话太过于消耗资源， * 而如果不进行清理的话又会导致资源的浪费，所以采用这种适中的方式对数组中的无效元素进行清理 */ private boolean cleanSomeSlots(int i, int n) { boolean removed = false; Entry[] tab = table; int len = tab.length; //从当前索引位置的下一元素开始检查，如果是无效元素则直接做清理 do { i = nextIndex(i, len); Entry e = tab[i]; if (e != null && e.get() == null) { n = len; removed = true; i = expungeStaleEntry(i); } } while ( (n >>>= 1) != 0); return removed; } /** * 对ThreadLocalMap 中的无效元素进行清理，之后用最低的阈值 * 预防因为磁滞现象的扩容失败，如果等式成立则进行扩容 */ private void rehash() { // 清理掉数组中所有的无效元素 expungeStaleEntries(); // 就是避免因为size数值的滞后所以用最低一个阈值来做判断是否应该扩容。 if (size >= threshold - threshold / 4) resize(); } /** * 清除所有的无效元素 */ private void expungeStaleEntries() { Entry[] tab = table; int len = tab.length; //直接从头开始清理数组中的无效元素 for (int j = 0; j < len; j++) { Entry e = tab[j]; if (e != null && e.get() == null) expungeStaleEntry(j); } } /** * 数组扩容 */ private void resize() { //可以看出其扩容后是原来的两倍 Entry[] oldTab = table; int oldLen = oldTab.length; int newLen = oldLen * 2; Entry[] newTab = new Entry[newLen]; int count = 0; //这里其实就跟hashMap有些相似了通过公式hashcode&(2^n^-1) //来获取其在新数组中的索引在将其直接进行复制就完成了 for (int j = 0; j < oldLen; ++j) { Entry e = oldTab[j]; if (e != null) { ThreadLocal<?> k = e.get(); if (k == null) { e.value = null; } else { int h = k.threadLocalHashCode & (newLen - 1); while (newTab[h] != null) h = nextIndex(h, newLen); newTab[h] = e; count++; } } } //最后重新设置阈值、数组实际大小、以及新数组引用 setThreshold(newLen); size = count; table = newTab; } - 取值
/** * 根据对应的键获取其Entry对象 */ private Entry getEntry(ThreadLocal<?> key) { //首先通过key值获取元素在数组中的大概索引位置。 int i = key.threadLocalHashCode & (table.length - 1); Entry e = table[i]; //如果当前索引取的元素，键不为null且其key值与需要获取key相等则直接返回这个元素 if (e != null && e.get() == key) return e; else return getEntryAfterMiss(key, i, e); } /** * 从当前索引位置开始往下遍历，如果key相等则直接返回， * key为null则对该无效元素清理，一直到获取出对应的元素或者遍历到为null的元素为止 */ private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) { Entry[] tab = table; int len = tab.length; while (e != null) { ThreadLocal<?> k = e.get(); if (k == key) return e; //key值为null直接对元素进行清理 if (k == null) expungeStaleEntry(i); //否则获取下一元素 else i = nextIndex(i, len); e = tab[i]; } return null; }
- 我们这里讲到ThreadLocal，其底层操作都是基于ThreadLocalMap来加以实现，该ThreadLocalMap的对象是线程的一个本地变量，该ThreadLocalMap是专门用于处理线程本地变量进行构建的。
-
set方法：
public void set(T value) { //获取当前线程 Thread t = Thread.currentThread(); //获取一个ThreadLocalMap对象 ThreadLocalMap map = getMap(t); /** * 如果这个map不为null则以当前ThreadLocal对象为键和值放入到这个map中， * 否则就创建一个ThreadLocalMap对象 */ if (map != null) map.set(this, value); else createMap(t, value); }进入到getMap方法中
ThreadLocalMap getMap(Thread t) { return t.threadLocals; }
我们看到获取的map其实是线程的一个变量，所以就说明ThreadLocal本身就可以说是一个线程的一个变量。
而createMap方法当然就是创建一个ThreadLoclMap对象并将该对象赋值给当前线程的threadLocals变量。
拿到这个map对象之后就会将键-值存入到ThreadLocalMap 中了 -
get方法
public T get() { //获取当前线程 Thread t = Thread.currentThread(); //从线程本地变量中获取ThreadLocalMap对象 ThreadLocalMap map = getMap(t); if (map != null) { //调用ThreadLocalMap的getEntry方法获取到对应的Entry对象 ThreadLocalMap.Entry e = map.getEntry(this); //如果不为null返回value if (e != null) { @SuppressWarnings("unchecked") T result = (T)e.value; return result; } } //否则就会 return setInitialValue(); } /** * 获取线程本地变量中的值 */ private T setInitialValue() { //获取当前类型的初始化值 T value = initialValue(); //获取当前线程 Thread t = Thread.currentThread(); //拿到ThreadLocalMap对象 ThreadLocalMap map = getMap(t); //如果不为null，则将为当前线程本地变量赋上初值 if (map != null) map.set(this, value); else //否则创建map createMap(t, value); //最后返回初值 return value; }
-