2. 程式人生 > >Java併發：ThreadLocal詳解

Java併發：ThreadLocal詳解

阿新 • • 發佈：2019-02-05

前言

ThreadLocal的作用是提供執行緒內的區域性變數，這種變數在多執行緒環境下訪問時能夠保證各個執行緒裡變數的獨立性。ThreadLocal無論在專案開發還是面試中都會經常碰到，本文就ThreadLocal的使用、主要方法原始碼詳解、記憶體洩漏問題展開討論。

1.基本使用

package com.joonwhee.imp.threadLocal;

/**
 * demo
 * @author joonwhee
 * @date 2018年2月24日
 */
public class ThreadLocalDemo {

    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();
    public static ThreadLocal<User> threadLocalUser = new ThreadLocal<User>();

	public static void main(String args[]) {
		threadLocal.set(100);	// 儲存值
		System.out.println(threadLocal.get());	// 獲取值
		
		User user = new User();
		user.setName("JoonWhee");
		user.setAge(25);
		threadLocalUser.set(user);	// 儲存值
		System.out.println(threadLocalUser.get());	// 獲取值
	}
	
	static class User{
		String name;
		Integer age;

		public String getName() {
			return name;
		}

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

		public Integer getAge() {
			return age;
		}

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

		@Override
		public String toString() {
			return "User [name=" + name + ", age=" + age + "]";
		}
		
	}
}

輸出結果：

100
User [name=JoonWhee, age=25]

2.ThreadLocal的定義

這個類提供了執行緒區域性變數。這個類能使執行緒中的某個值與儲存值的物件關聯起來，例如：“threadLocal.set(5)”，會將“threadLocal”和“5”作為鍵值對儲存在該執行緒的threadLocals裡。ThreadLocal提供了get與set等訪問介面或方法，這些方法為每個使用該變數的執行緒都存有一份獨立的副本（即每個執行緒的threadLocals屬性），因此get總是返回由當前執行執行緒在呼叫set時設定的最新值。

只要執行緒處於活動狀態並且Threadocal例項可以訪問，每個執行緒就擁有對其執行緒區域性變數副本的隱式引用；在一個執行緒消失之後，執行緒本地例項的所有副本都會被垃圾收集（除非存在對這些副本的其他引用）。

// hash code
private final int threadLocalHashCode = nextHashCode();

// AtomicInteger型別，從0開始
private static AtomicInteger nextHashCode =
    new AtomicInteger();

// hash code每次增加1640531527 
private static final int HASH_INCREMENT = 0x61c88647;

// 下一個hash code
private static int nextHashCode() {
    return nextHashCode.getAndAdd(HASH_INCREMENT);
}
從上面的定義可以知道，ThreadLocal的hashcode（threadLocalHashCode）是從0開始，每新建一個ThreadLocal，對應的hashcode就加0x61c88647。

3.ThreadLocalMap的定義

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

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

ThreadLocalMap是一個自定義雜湊對映，僅用於維護執行緒本地變數值。ThreadLocalMap是ThreadLocal的內部類，主要有一個Entry陣列，Entry的key為ThreadLocal，value為ThreadLocal對應的值。每個執行緒都有一個ThreadLocalMap型別的threadLocals變數。

4.set()方法

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t); // 獲取當前執行緒的ThreadLocalMap
    // 當前執行緒的ThreadLocalMap不為空則呼叫set方法, this為呼叫該方法的ThreadLocal物件
    if (map != null) 
        map.set(this, value);
    // map為空則呼叫createMap方法建立一個新的ThreadLocalMap, 並新建一個Entry放入該
    // ThreadLocalMap, 呼叫set方法的ThreadLocal和傳入的value作為該Entry的key和value
    else
        createMap(t, value);    
}

ThreadLocalMap getMap(Thread t) {
    return t.threadLocals;	// 返回執行緒t的threadLocals屬性
}
  1. 先拿到當前執行緒，再使用getMap方法拿到當前執行緒的threadLocals變數
  2. 如果threadLocals不為空，則將當前ThreadLocal作為key，傳入的值作為value，呼叫set方法（見下文程式碼塊1詳解）插入threadLocals。
  3. 如果threadLocals為空則呼叫建立一個ThreadLocalMap，並新建一個Entry放入該ThreadLocalMap, 呼叫set方法的ThreadLocal和傳入的value作為該Entry的key和value

注意此處的threadLocals變數是一個ThreadLocalMap，是Thread的一個區域性變數，因此它只與當前執行緒繫結。

程式碼塊1：set方法

private void set(ThreadLocal<?> key, Object value) {
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);  // 計算出索引的位置

    // 從索引位置開始遍歷,由於不是連結串列結構,因此通過nextIndex方法來尋找下一個索引位置  
    for (Entry e = tab[i];
         e != null;	// 當遍歷到的Entry為空時結束遍歷
         e = tab[i = nextIndex(i, len)]) {  
        ThreadLocal<?> k = e.get(); // 拿到Entry的key，也就是ThreadLocal  

        // 該Entry的key和傳入的key相等, 則用傳入的value替換掉原來的value  
        if (k == key) {
            e.value = value;
            return;
        }

        // 該Entry的key為空, 則代表該Entry需要被清空, 
        // 呼叫replaceStaleEntry方法  
        if (k == null) {
        	// 該方法會繼續尋找傳入key的安放位置, 並清理掉key為空的Entry  
            replaceStaleEntry(key, value, i);
            return;
        }
    }

    // 尋找到一個空位置,　則放置在該位置上
    tab[i] = new Entry(key, value);
    int sz = ++size;
    // cleanSomeSlots是用來清理掉key為空的Entry,如果此方法返回true,則代表至少清理
    // 了1個元素, 則此次set必然不需要擴容, 如果此方法返回false則判斷sz是否大於閾值
    if (!cleanSomeSlots(i, sz) && sz >= threshold)
        rehash();   // 擴容
}
  1. 通過傳入的key的hashCode計算出索引的位置
  2. 從索引位置開始遍歷，由於不是連結串列結構，因此通過nextIndex方法來尋找下一個索引位置
  3. 如果找到某個Entry的key和傳入的key相同，則用傳入的value替換掉該Entry的value。
  4. 如果遍歷到某個Entry的key為空，則呼叫replaceStaleEntry方法（見下文程式碼塊2詳解）
  5. 如果通過nextIndex尋找到一個空位置（代表沒有找到key相同的），則將元素放在該位置上
  6. 呼叫cleanSomeSlots方法清理key為null的Entry，並判斷是否需要擴容，如果需要則呼叫rehash方法進行擴容（見下文rehash方法詳解）。

程式碼塊2：replaceStaleEntry方法

private void replaceStaleEntry(ThreadLocal<?> key, Object value,
                               int staleSlot) {
    Entry[] tab = table;
    int len = tab.length;
    Entry e;

    int slotToExpunge = staleSlot;	// 清除元素的開始位置（記錄索引位置最前面的）
    // 向前遍歷，直到遇到Entry為空
    for (int i = prevIndex(staleSlot, len); 
         (e = tab[i]) != null;
         i = prevIndex(i, len))
        if (e.get() == null)
            slotToExpunge = i;	// 記錄最後一個key為null的索引位置

    // Find either the key or trailing null slot of run, whichever
    // occurs first
    for (int i = nextIndex(staleSlot, len); // 向後遍歷，直到遇到Entry為空
         (e = tab[i]) != null;
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get();

        // 該Entry的key和傳入的key相等, 則將傳入的value替換掉該Entry的value
        if (k == key) {
            e.value = value;

            // 將i位置和staleSlot位置的元素對換（staleSlot位置較前，是要清除的元素）
            tab[i] = tab[staleSlot];	
            tab[staleSlot] = e;

            // 如果相等, 則代表上面的向前尋找key為null的遍歷沒有找到，
            // 即staleSlot位置前面的元素沒有需要清除的，此時將slotToExpunge設定為i, 
            // 因為原staleSlot的元素已經被放到i位置了，這時位置i前面的元素都不需要清除
            if (slotToExpunge == staleSlot) 
                slotToExpunge = i;
            // 從slotToExpunge位置開始清除key為空的Entry
            cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
            return;
        }

        // 如果第一次遍歷到key為null的元素，並且上面的向前尋找key為null的遍歷沒有找到，
        // 則將slotToExpunge設定為當前的位置
        if (k == null && slotToExpunge == staleSlot)
            slotToExpunge = i;
    }

    // 如果key沒有找到，則新建一個Entry，放在staleSlot位置
    tab[staleSlot].value = null;
    tab[staleSlot] = new Entry(key, value);

    // 如果slotToExpunge!=staleSlot，代表除了staleSlot位置還有其他位置的元素需要清除
    // 需要清除的定義：key為null的Entry，呼叫cleanSomeSlots方法清除key為null的Entry
    if (slotToExpunge != staleSlot)
        cleanSomeSlots(expungeStaleEntry(slotToExpunge), len);
}
  1. slotToExpunge始終記錄著需要清除的元素的最前面的位置（即slotToExpunge前面的元素是不需要清除的）
  2. 從位置staleSlot向前遍歷，直到遇到Entry為空，用staleSlot記錄最後一個key為null的索引位置（也就是遍歷過位置最前的key為null的位置）
  3. 從位置staleSlot向後遍歷，直到遇到Entry為空，如果遍歷到key和入參key相同的，則將入參的value替換掉該Entry的value，並將i位置和staleSlot位置的元素對換（staleSlot位置較前，是要清除的元素），遍歷的時候判斷slotToExpunge的值是否需要調整，最後呼叫expungeStaleEntry方法（見下文expungeStaleEntry方法詳解）和cleanSomeSlots方法（見下文程式碼塊3詳解）清除key為null的元素。
  4. 如果key沒有找到，則使用入參的key和value新建一個Entry，放在staleSlot位置
  5. 判斷是否還有其他位置的元素key為null，如果有則呼叫expungeStaleEntry方法和cleanSomeSlots方法清除key為null的元素

程式碼塊3：cleanSomeSlots方法

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) {	// 遍歷到key為null的元素
            n = len;	// 重置n的值
            removed = true;	// 標誌有移除元素
            i = expungeStaleEntry(i);	// 移除i位置及之後的key為null的元素
        }
    } while ( (n >>>= 1) != 0);
    return removed;
}

從 i 開始，清除key為空的Entry，遍歷次數由當前的table長度決定，當遍歷到一個key為null的元素時，呼叫expungeStaleEntry清除，並將遍歷次數重置。至於為什麼使用table長度來決定遍歷次數，官方給出的解釋是這個方法簡單、快速，並且效果不錯。

5.get()方法

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
    	//呼叫getEntry方法, 通過呼叫get()方法的ThreadLocal獲取對應的Entry
        ThreadLocalMap.Entry e = map.getEntry(this);    
        if (e != null) {    //Entry不為空則代表找到目標Entry, 返回該Entry的value值     
            @SuppressWarnings("unchecked")
            T result = (T)e.value;
            return result;
        }
    }
    return setInitialValue();   //該執行緒的ThreadLocalMap為空則初始化一個
}
  1. 跟set方法差不多，先拿到當前的執行緒，再使用getMap方法拿到當前執行緒的threadLocals變數
  2. 如果threadLocals不為空，則將呼叫get方法的ThreadLocal作為key，呼叫getEntry方法（見下文程式碼塊5詳解）找到對應的Entry。
  3. 如果threadLocals為空或者找不到目標Entry，則呼叫setInitialValue方法（見下文程式碼塊4詳解）進行初始化。

程式碼塊4：setInitialValue方法

private T setInitialValue() {
    T value = initialValue();	// 預設null，需要使用者自己重寫該方法，
    Thread t = Thread.currentThread();	// 當前執行緒
    ThreadLocalMap map = getMap(t);	// 拿到當前執行緒的threadLocals
    // threadLocals不為空則將當前的ThreadLocal作為key，null作為value，插入到ThreadLocalMap
    if (map != null)	
        map.set(this, value);
    // threadLocals為空則呼叫建立一個ThreadLocalMap，並新建一個Entry放入該ThreadLocalMap, 
    // 呼叫set方法的ThreadLocal和value作為該Entry的key和value
    else
        createMap(t, value);
    return value;
}
  1. 如果是threadLocals為空，建立一個新的ThreadLocalMap，並將當前的ThreadLocal作為key，null作為value，插入到新建立的ThreadLocalMap，並返回null。
  2. 如果threadLocals不為空，則將當前的ThreadLocal作為key，null作為value，插入到threadLocals。
  3. 注意上面的 initialValue()方法為protected，如果希望執行緒區域性變數具有非null的初始值，則必須對ThreadLocal進行子類化，並重寫此方法。

程式碼塊5：getEntry方法

private Entry getEntry(ThreadLocal<?> key) {
	//根據hash code計算出索引位置 
    int i = key.threadLocalHashCode & (table.length - 1);    
    Entry e = table[i];
    // 如果該Entry的key和傳入的key相等, 則為目標Entry, 直接返回
    if (e != null && e.get() == key)    
        return e;
    // 否則，e不是目標Entry, 則從e之後繼續尋找目標Entry
    else
        return getEntryAfterMiss(key, i, e);
}
  1. 根據hash code計算出索引位置 
  2. 如果該索引位置Entry的key和傳入的key相等，則為目標Entry，直接返回
  3. 否則，e不是目標Entry，呼叫getEntryAfterMiss方法（見下文程式碼塊6詳解）繼續遍歷。

程式碼塊6：getEntryAfterMiss方法

private Entry getEntryAfterMiss(ThreadLocal<?> key, int i, Entry e) {
    Entry[] tab = table;
    int len = tab.length;

    while (e != null) {
        ThreadLocal<?> k = e.get();
        // 找到目標Entry，直接返回
        if (k == key)  
            return e;
        // 呼叫expungeStaleEntry清除key為null的元素
        if (k == null)
            expungeStaleEntry(i);
        else
            i = nextIndex(i, len);  // 下一個索引位置
        e = tab[i]; // 下一個遍歷的Entry
    }
    return null;    // 找不到, 返回空
}
從元素e開始向後遍歷，如果找到目標Entry元素直接返回；如果遇到key為null的元素，呼叫expungeStaleEntry方法（見下文expungeStaleEntry方法詳解）進行清除；否則，遍歷到Entry為null時，結束遍歷，返回null。

6.remove()方法

public void remove() {
	// 獲取當前執行緒的ThreadLocalMap 
	ThreadLocalMap m = getMap(Thread.currentThread()); 
	if (m != null)
		m.remove(this);    // 呼叫此方法的ThreadLocal作為入參，呼叫remove方法  
 }

private void remove(ThreadLocal<?> key) {
    Entry[] tab = table;
    int len = tab.length;
    // 根據hashCode計算出當前ThreadLocal的索引位置
    int i = key.threadLocalHashCode & (len-1);  
    // 從位置i開始遍歷，直到Entry為null
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {   // 如果找到key相同的
            e.clear(); 	// 則呼叫clear方法, 該方法會把key的引用清空
            expungeStaleEntry(i);//呼叫expungeStaleEntry方法清除key為null的Entry
            return;
        }
    }
}

方法很簡單，拿到當前執行緒的threadLocals屬性，如果不為空，則將key為當前ThreadLocal的鍵值對移除，並且會呼叫expungeStaleEntry方法清除key為空的Entry。

7.expungeStaleEntry方法

// 從staleSlot開始, 清除key為空的Entry, 並將不為空的元素放到合適的位置，最後返回Entry為空的位置
private int expungeStaleEntry(int staleSlot) {  
    Entry[] tab = table;
    int len = tab.length;

    // expunge entry at staleSlot
    tab[staleSlot].value = null;    // 將tab上staleSlot位置的物件清空
    tab[staleSlot] = null;
    size--;

    // Rehash until we encounter null
    Entry e;
    int i;
    for (i = nextIndex(staleSlot, len); // 遍歷下一個元素, 即(i+1)%len位置的元素
         (e = tab[i]) != null;	// 遍歷到Entry為空時, 跳出迴圈並返回索引位置
         i = nextIndex(i, len)) {
        ThreadLocal<?> k = e.get(); 
        if (k == null) {    // 當前遍歷Entry的key為空, 則將該位置的物件清空
            e.value = null;
            tab[i] = null;
            size--;
        } else {    // 當前遍歷Entry的key不為空
            int h = k.threadLocalHashCode & (len - 1);  // 重新計算該Entry的索引位置
            if (h != i) {   // 如果索引位置不為當前索引位置i
                tab[i] = null;  // 則將i位置物件清空, 替當前Entry尋找正確的位置

                // 如果h位置不為null，則向後尋找當前Entry的位置
                while (tab[h] != null)
                    h = nextIndex(h, len);
                tab[h] = e;
            }
        }
    }
    return i;   
}

原始碼解讀：從staleSlot開始，清除key為null的Entry，並將不為空的元素放到合適的位置，最後遍歷到Entry為空的元素時，跳出迴圈返回當前索引位置。

PS：set、get、remove方法，在遍歷的時候如果遇到key為null的情況，都會呼叫expungeStaleEntry方法來清除key為null的Entry。

8.rehash方法

private void rehash() {
    expungeStaleEntries();  // 呼叫expungeStaleEntries方法清理key為空的Entry

    // 如果清理後size超過閾值的3/4, 則進行擴容
    if (size >= threshold - threshold / 4)  
        resize();
}

/**
 * Double the capacity of the table.
 */
private void resize() {
    Entry[] oldTab = table;
    int oldLen = oldTab.length;
    int newLen = oldLen * 2;	// 新表長度為老表2倍
    Entry[] newTab = new Entry[newLen];	// 建立新表
    int count = 0;

    for (int j = 0; j < oldLen; ++j) {	// 遍歷所有元素
        Entry e = oldTab[j];	// 拿到對應位置的Entry
        if (e != null) {
            ThreadLocal<?> k = e.get();
            if (k == null) {	// 如果key為null，將value清空
                e.value = null; // Help the GC
            } else {
            	// 通過hash code計算新表的索引位置
                int h = k.threadLocalHashCode & (newLen - 1);
                // 如果新表的該位置已經有元素，則呼叫nextIndex方法直到尋找到空位置
                while (newTab[h] != null)
                    h = nextIndex(h, newLen);
                newTab[h] = e;	// 將元素放在對應位置
                count++;
            }
        }
    }

    setThreshold(newLen);	// 設定新表擴容的閾值
    size = count;	// 更新size
    table = newTab;	// table指向新表
}
  1. 呼叫expungeStaleEntries方法（該方法和expungeStaleEntry類似，只是把搜尋範圍擴大到整個表）清理key為空的Entry
  2. 如果清理後size超過閾值的3/4，則進行擴容。
  3. 新表長度為老表2倍，建立新表。
  4. 遍歷老表所有元素，如果key為null，將value清空；否則通過hash code計算新表的索引位置h，如果h已經有元素，則呼叫nextIndex方法直到尋找到空位置，將元素放在新表的對應位置。
  5. 設定新表擴容的閾值、更新size、table指向新表。

9.功能測試

package com.joonwhee.imp.threadLocal;

import java.util.concurrent.TimeUnit;

/**
 * ThreadLocal測試
 * 
 * @author JoonWhee
 * @Date 2017年12月2日
 */
public class TestThreadLocal {

    public static ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>();

    public static void main(String args[]) throws InterruptedException {
        Thread threadOne = new ThreadOne(); // 執行緒1
        Thread threadTo = new ThreadTo(); // 執行緒2
        threadTo.start(); // 執行緒2開始執行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待執行緒2執行完畢
        threadOne.start(); // 執行緒1開始執行
        TimeUnit.MILLISECONDS.sleep(100); // 睡眠, 以等待執行緒1執行完畢
        // 此時執行緒1和執行緒2都已經設定過值, 此處輸出為空, 說明子執行緒與父執行緒之間也是互不影響的
        System.out.println("main: " + threadLocal.get());

    }

    /**
     * 執行緒1
     * @author joonwhee
     * @date 2018年2月24日
     */
    private static class ThreadOne extends Thread {
        @Override
        public void run() {
            // 此時執行緒2已經呼叫過set(456), 此處輸出為空, 說明執行緒之間是互不影響的
            System.out.println("ThreadOne: " + threadLocal.get());
            threadLocal.set(123);
            System.out.println("ThreadOne: " + threadLocal.get());
        }
    }

    /**
     * 執行緒2
     * @author joonwhee
     * @date 2018年2月24日
     */
    private static class ThreadTo extends Thread {
        @Override
        public void run() {
            threadLocal.set(456); // 設定當前ThreadLocal的值為456
            System.out.println("ThreadTo: " + threadLocal.get());
        }
    }

}

輸出結果：

ThreadTo: 456

ThreadOne: null

ThreadOne: 123

main: null

從輸出結果可以看出，執行緒1、執行緒2和主執行緒之間是彼此互不影響的。

10.記憶體洩漏問題：

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

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

從上面原始碼可以看出，ThreadLocalMap使用ThreadLocal的弱引用作為Entry的key，如果一個ThreadLocal沒有外部強引用來引用它，下一次系統GC時，這個ThreadLocal必然會被回收，這樣一來，ThreadLocalMap中就會出現key為null的Entry，就沒有辦法訪問這些key為null的Entry的value。

我們上面介紹的get、set、remove等方法中，都會對key為null的Entry進行清除（expungeStaleEntry方法，將Entry的value清空，等下一次垃圾回收時，這些Entry將會被徹底回收）。

但是如果當前執行緒一直在執行，並且一直不執行get、set、remove方法，這些key為null的Entry的value就會一直存在一條強引用練：Thread Ref -> Thread -> ThreadLocalMap -> Entry -> value，導致這些key為null的Entry的value永遠無法回收，造成記憶體洩漏。

如何避免記憶體洩漏？

為了避免這種情況，我們可以在使用完ThreadLocal後，手動呼叫remove方法，以避免出現記憶體洩漏。

總結：

  1. 每個執行緒都有一個ThreadLocalMap 型別的 threadLocals 屬性。
  2. ThreadLocalMap 類相當於一個Map，key 是 ThreadLocal 本身，value 就是我們的值。
  3. 當我們通過 threadLocal.set(new Integer(123)); ，我們就會在這個執行緒中的 threadLocals 屬性中放入一個鍵值對，key 是 這個 threadLocal.set(new Integer(123))的threadlocal，value 就是值new Integer(123)。
  4. 當我們通過 threadlocal.get() 方法的時候，首先會根據這個執行緒得到這個執行緒的 threadLocals 屬性，然後由於這個屬性放的是鍵值對，我們就可以根據鍵 threadlocal 拿到值。 注意，這時候這個鍵 threadlocal 和 我們 set 方法的時候的那個鍵 threadlocal 是一樣的，所以我們能夠拿到相同的值。
  5. ThreadLocalMap 的get/set/remove方法跟HashMap的內部實現都基本一樣，通過 "key.threadLocalHashCode & (table.length - 1)" 運算式計算得到我們想要找的索引位置，如果該索引位置的鍵值對不是我們要找的，則通過nextIndex方法計算下一個索引位置，直到找到目標鍵值對或者為空。
  6. hash衝突：在HashMap中相同索引位置的元素以連結串列形式儲存在同一個索引位置；而在ThreadLocalMap中，沒有使用連結串列的資料結構，而是將（當前的索引位置+1）對length取模的結果作為相同索引元素的位置：原始碼中的nextIndex方法，可以表達成如下公式：如果i為當前索引位置，則下一個索引位置 = (i + 1 < len) ? i + 1 : 0。

—————END—————

相關推薦

Java併發：ThreadLocal詳解

前言ThreadLocal的作用是提供執行緒內的區域性變數，這種變數在多執行緒環境下訪問時能夠保證各個執行緒裡變數的獨立性。ThreadLocal無論在專案開發還是面試中都會經常碰到，本文就ThreadLocal的使用、主要方法原始碼詳解、記憶體洩漏問題展開討論。1.基本使用

【搞定Java併發程式設計】第6篇：ThreadLocal詳解

上一篇：synchronized關鍵字：https://blog.csdn.net/pcwl1206/article/details/84849400 目  錄： 1、ThreadLocal是什麼？ 2、ThreadLocal使用示例 3、ThreadLocal原始碼分析

Java併發工具類詳解

在JDK的併發包裡提供了幾個非常有用的併發工具類。CountDownLatch、CyclicBarrier和Semaphore工具類提供了一種併發流程控制的手段，Exchanger工具類則提供了線上程間交換資料的一種手段。本章會配合一些應用場景來介紹如何使用這些工具類。 等待多執行緒完成的Cou

併發：FutureTask詳解。

FutureTask介面和實現Future介面的FutureTask類，代表非同步計算的結果。 FutureTask簡介 FutureTask除了實現Future介面外，還實現了Runnable介面。因此，FutureTask可以交給Executor執行也可以由當呼叫執行緒直接執行（Futu

併發：ScheduledThreadPoolExecutor詳解。

ScheduledThreadPoolExecutor繼承自ThreadPoolExecutor。他主要用來給定的延遲之後執行任務，或者定期執行任務。ScheduledThreadPoolExecutor的功能與Timer類似，但ScheduledThreadPoolExecutor功能更強大、更靈

併發：ThreadPoolExecutor詳解。

Executor框架最核心的類是ThreadPoolExecutor，他是執行緒池的實現類，主要由下列4個元件構成。 corePool：核心執行緒池的大小。 maximumPool：最大執行緒池的大小。 BlockingQueue：用來暫時儲存任務的工作佇列。 Regje

Java 併發程式設計之詳解工具類 CountDownLatch

CountDownLatch是一個在java1.5被引入同步工具類，它允許一個或多個執行緒一直等待，直到其他執行緒的操作執行完後再執行。countdownlatch在Java開發中應用場景及其廣泛，同時也是面試中的高頻考點。每一個Java程式設計師都應該熟練掌握，在本篇文章中，我將會從以下幾方面對其

Java併發之Semaphore詳解

        一、入題        Semaphore是一種基於計數的訊號量。它可以設定一個閾值，基於此，多個執行緒競爭獲取許可訊號，做完自己的申請後歸還，超過閾值後，執行緒申請許可訊號將會被阻塞。Semaphore可以用來構建一些物件池，資源池之類的，比如資料庫連線池，

Java併發程式設計（詳解wait(), notify(),sleep（））

        上一篇部落格，重點講解了java中鎖的機制，省的在多執行緒之間出現混亂的局面，其實主要能夠理解鑰匙即可。如果要保證方法之間能夠獨立完全的執行，因此就必須所有的方法都共用一把鑰匙。然後小

Java併發之AQS詳解

一、概述 　　談到併發，不得不談ReentrantLock；而談到ReentrantLock，不得不談AbstractQueuedSynchronizer（AQS）！ 　　類如其名，抽象的佇列式的同步器，AQS定義了一套多執行緒訪問共享資源的同步器框架，許多同步類實現都依賴於它，如常用的Reentrant

Java併發程式設計--Volatile詳解

摘要      Volatile是Java提供的一種弱同步機制，當一個變數被宣告成volatile型別後編譯器不會將該變數的操作與其他記憶體操作進行重排序。在某些場景下使用volatile代替鎖可以減少程式碼量和使程式碼更易閱讀。 Volatile特性   1.可見性：當一條執行緒對volatile

Java併發——Executor框架詳解（Executor框架結構與框架成員）

一、什麼是Executor框架？我們知道執行緒池就是執行緒的集合，執行緒池集中管理執行緒，以實現執行緒的重用，降低資源消耗，提高響應速度等。執行緒用於執行非同步任務，單個的執行緒既是工作單元也是執行機制，從JDK1.5開始，為了把工作單元與執行機制分離開，Executor框架

Java中的ThreadLocal詳解

一、ThreadLocal簡介 　　多執行緒訪問同一個共享變數的時候容易出現併發問題，特別是多個執行緒對一個變數進行寫入的時候，為了保證執行緒安全，一般使用者在訪問共享變數的時候需要進行額外的同步措施才能保證執行緒安全性。ThreadLocal是除了加鎖這種同步方式之外的一種保證一種規避多執行緒訪問出現執行

Java併發之CompletionService詳解

CompletionService是什麼？ 它是JUC包中的一個介面類，預設實現類只有一個ExecutorCompletionService。   CompletionService幹什麼的？ 它將非同步任務的生成和執行結果的處理進行了解耦，用來執行Callable的任務（實際也是通過Executo

Java 併發程式設計： ThreadPoolExecutor 詳解

1.  使用執行緒池能解決兩方面的問題      a) 減少執行緒呼叫開銷，提升效能；      b) 通過限制執行緒數量達到限制程式資源佔用的目的； 2.  執行緒建立的規則   &nbs

java併發：AQS獨佔鎖原始碼詳解

說明： AQS是併發包的基石。它有兩種模式：獨佔模式和共享模式。本篇只說獨佔模式。 什麼是獨佔模式？就相當於lock的鎖只有一把，一條執行緒佔用，其他執行緒就得處於BLOCK或者WAIT狀態。 在AQS裡，獲取的方法就是： Acquire（） public final vo

Java併發（十二）：CAS Unsafe Atomic 說一說Java的Unsafe類 說一說Java的Unsafe類 Java中Unsafe類詳解 Unsafe與CAS

一、Unsafe Java無法直接訪問底層作業系統，而是通過本地（native）方法來訪問。不過儘管如此，JVM還是開了一個後門，JDK中有一個類Unsafe，它提供了硬體級別的原子操作。 這個類儘管裡面的方法都是public的，但是並沒有辦法使用它們，JDK API文件也沒有提供任何關於這個類的方法的解

Java 併發：Lock 框架詳解

　摘要：　我們已經知道，synchronized 是java的關鍵字，是Java的內建特性，在JVM層面實現了對臨界資源的同步互斥訪問，但 synchronized 粒度有些大，在處理實際問題時存在諸多侷限性，比如響應中斷等。Lock 提供

[轉]Java 併發：Lock 框架詳解

摘要： 　　我們已經知道，synchronized 是java的關鍵字，是Java的內建特性，在JVM層面實現了對臨界資源的同步互斥訪問，但 synchronized 粒度有些大，在處理實際問題時存在諸多侷限性，比如響應中斷等。Lock 提供了比 sy

【搞定Java併發程式設計】第9篇：CAS詳解

上一篇：volatile關鍵字詳解：https://blog.csdn.net/pcwl1206/article/details/84881395 目  錄： 一、CAS基本概念 1.1、CAS的定義 1.2、CAS的3個運算元  二、Java如何實現原子操作