Android訊息機制-ThreadLocal原理解析：資料存取

說起Android訊息機制,老生常談的問題,Handler ,Looper,MessageQueue,Message這幾個都是離不開的話題,不同的類承載不同的功能,首先還是簡單的總結下各自的功能:

Handler:傳送和處理訊息
MessageQueue:訊息佇列,採用單連結串列結構儲存資料
Looper:呼叫loop()輪詢訊息
Message:需要傳送的內容,訊息

---

畫一張流程圖顯示:

當然上邊只是簡單的分析了下 Handler一個傳送和處理的一個流程,只是讓大家溫故下,下面正式的開始介紹這個ThreadLocal 重量級角色:

ThreadLocal 介紹:(針對JDK 1.7闡述)

定義:早在JDK 1.2的版本中就提供java.lang.ThreadLocal，ThreadLocal為解決多執行緒程式的併發問題提供了一種新的思路。使用這個工具類可以很簡潔地編寫出優美的多執行緒程式,百度百科一下就知道,當然這只是定義,先上一段程式碼瞧瞧:

private ThreadLocal<Boolean> booleanThreadLocal = new ThreadLocal<>();..

button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                booleanThreadLocal.set(true);
                booleanThreadLocal.set(false);
                Log.i(TAG, "run: ThreadName-------->"+Thread.currentThread().getName()+booleanThreadLocal.get());
                new Thread("Thread1"){
                    @Override
                    public void run() {
                        booleanThreadLocal.set(true);
                        Log.i(TAG, "run: Thread1+ThreadName-------->"+Thread.currentThread().getName()+booleanThreadLocal.get());
                    }
                }.start();
                new Thread("Thread2"){
                    @Override
                    public void run() {
                        Log.i(TAG, "run: Thread2+ThreadName-------->"+Thread.currentThread().getName()+booleanThreadLocal.get());
                    }
                }.start();
            }
        });

程式碼很簡單就是給一個button設定一個點選監聽事件,然後通過獲取ThreadLocal的get方法分別獲取裡面值:我們來看列印值(介面過於簡單,就不在展示):

11-24 06:35:23.683 13691-13691/com.example.administrator.dbhelp I/MainActivity: run: ThreadName-------->main---->false
11-24 06:35:23.693 13691-13785/com.example.administrator.dbhelp I/MainActivity: run: Thread2+ThreadName-------->Thread2---->null
11-24 06:35:23.694 13691-13784/com.example.administrator.dbhelp I/MainActivity: run: Thread1+ThreadName-------->Thread1---->true

我在不同的執行緒採用相同的物件呼叫他們的get方法,但是他們列印的值卻是不一樣,很奇妙吧,這也就是他的奇妙之處.
首先簡答的介紹為什麼會產生這種效果,方便後邊更好的看程式碼,ThreadLocal 內部維護了一個針對每一個執行緒的陣列Entry[],它的初始容量是16,我們在設定value的時候將當前的value值封裝Entry類裡面,在然後再根據當前的ThreadLocal的索引去查中對應的Entry值,最終根據Entry物件取出value值,很明顯每個執行緒的陣列是不相同,所以就可以取出不同的Entry,這麼說肯定還是不是特別明白,沒關係這個只是開胃菜,提前有個瞭解有印象就行;上程式碼一看就明瞭:

set:

 public void set(T value) {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
    }

邏輯很簡單,建立當前的執行緒根據當前的執行緒獲取ThreadLocalMap 例項物件,這個ThreadLocalMap 是個什麼了看這個跟HashMap 很相似啊,可別只看表面,這個可是沒有一點親戚關係,這點可別誤解了,接著看得到當前執行緒的map 第一次獲取肯定是空:
我們看下getMap做了什麼:

Thread 屬性;
ThreadLocal.ThreadLocalMap threadLocals = null;

ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

找到這個變數第一次肯定是空, createMap(t, value);接著看

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

變數賦值操作,看下ThreadLocalMap的構造:

  private static final int INITIAL_CAPACITY = 16;
 table = new Entry[INITIAL_CAPACITY];
            int i = firstKey.threadLocalHashCode & (INITIAL_CAPACITY - 1);
            table[i] = new Entry(firstKey, firstValue);
            size = 1;
            setThreshold(INITIAL_CAPACITY);

很簡單的吧,首先構造一個陣列也就是我上邊提到的Entry陣列初始容量16,然後通過按位運算得到一個變數i值,構造一個Entry物件將ThreadLocal和Value放進去,將設定進去的值包裝成一個物件存進陣列裡邊,獲取的時候在通過陣列的index取出當前的物件,這樣一分析是不是有種明白的感覺別急,接著看構造;

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

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

這個實體繼承WeakReference(就是我們常說的弱引用) v就是我們設定進去的value,現在整體的流程是不是很清楚了,然後我們在腦補一下,值是這樣設定就去了,那麼我獲取的時候是不是隻要得到map也就是ThreadLocal.ThreadLocalMap threadLocals這個變數,再根據這個變數得到當前執行緒的的陣列,在通過陣列的index是不是就可以得到當前的物件,再根據的物件取出value,思路是沒有錯,我們看下原始碼是不是這個樣子了

get:

 public T get() {
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null) {
            ThreadLocalMap.Entry e = map.getEntry(this);
            if (e != null)
                return (T)e.value;
        }
        return setInitialValue();
    }

是不是一模一樣了,其實它的原始碼還是比較簡單的,當然還有更高階的用法下邊在上程式碼:

 private ThreadLocal<Boolean> booleanThreadLocal = new ThreadLocal<Boolean>(){
        @Override
        protected Boolean initialValue() {
            return true;
        }
    };

 button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Log.i(TAG, "onClick: booleanThreadLocal------->"+booleanThreadLocal.get());

            }
        });

11-24 08:02:02.332 26018-26018/com.example.administrator.dbhelp I/MainActivity: onClick: booleanThreadLocal------->true

重寫initialValue值返回true,這次我沒有設定值,確返回true,是不是和get方法有關,當我們我們設定值的時候當前的執行緒的map為null,這時 return setInitialValue();看下方法 :

 private T setInitialValue() {
        T value = initialValue();
        Thread t = Thread.currentThread();
        ThreadLocalMap map = getMap(t);
        if (map != null)
            map.set(this, value);
        else
            createMap(t, value);
        return value;
    }

是不是一樣的簡單,邏輯很清楚,我們直接重寫了initialValue(),所以返回的value值就是我們重寫方法的返回值;到此原始碼也就分析完畢了,這時我們再回過頭來看下Handler訊息機制,Handler通過Looper.loop()方法輪詢訊息,我們一般寫Handler的時候都是在主執行緒建立的,在程式啟動的時候也就是載入ActivityThread類的時候系統已經幫我們自動的建立了主執行緒的Looper,通過上邊的圖也可知,可是如果我想在子執行緒建立Handler了,子執行緒是不是也需要自己的Looper;是不是自己也需要啟動Looper.loop來迴圈訊息,這時候ThreadLocal這個類就來了,ThreadLocal為當前的每一個執行緒儲存一個Looper,每一個Looper也有唯一的一個訊息佇列MessageQueue,所以在子執行緒new Handler()的時候需要我們手動的去獲取當前執行緒的Looper,主動的呼叫Looper.prepare();

 public static void prepare() {
        prepare(true);
    }

--------------------------------------------
 private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

-------------------------------------------
  private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

獲取當前執行緒的Looper和MessageQueue

new Thread(new Runnable() {

                  private  Handler handler;

                  @Override
                  public void run() {
                          Looper.prepare();
                      handler = new Handler(){
                          @Override
                          public void handleMessage(Message msg) {
                                          Log.i(TAG, "handleMessage: "+Thread.currentThread().getName()+"workThread執行緒收到訊息了-->");
                          }
                      };
         handler.sendEmptyMessage(0x10000);
                        Looper.loop();

                  }
              }).start();
----------------------------------------
或者來個暴力點的既然主執行緒已經有了Looper了就用他已經建立的好的
new Thread(new Runnable() {

                  private  Handler handler;

                  @Override
                  public void run() {
                      handler = new Handler(Looper.getMainLooper()){
                          @Override
                          public void handleMessage(Message msg) {
                        Log.i(TAG, "handleMessage: "+Thread.currentThread().getName()+"main執行緒收到訊息了-->");
                          }
                      };
         handler.sendEmptyMessage(0x10000);

                  }
              }).start();

上邊兩個方法都可以使Handler 在子執行緒去處理,但是接受訊息的結果當然也是不一樣的,上邊的採用的子執行緒Looper,下邊是main執行緒Looper;

總結:

其實在開發中用的ThreadLocal的地方極少,但是ThreadLocal也是不可忽視的一個重要點,在面試的時候你能把ThreadLocal和Looper結合起來一起講,也許就是加分項,再者ThreadLocal在某些特殊的場景的,通過它可以實現一個看起來比較複雜的功能,當某些資料以執行緒為作用域並且不同執行緒要獲取不同資料的時候,就可以用到ThreadLocal;