背景

在工作中經常會遇到需要做執行緒同步處理的場景，但由於一直對執行緒同步是一知半解，沒有很系統的去了解過，於是最近終於踩到了由於synchronized同步應用不當導致app頻繁ANR無響應的坑了，下面就這次踩坑來對synchronized執行緒同步來做一個較全面的瞭解，以此說明細節也加深印象。

app發生ANR的產生場景

我們先直接看發生anr的示意函式：

//Tab.java

/**
 * 該方法在主執行緒中呼叫，並且使用了synchronized同步關鍵字，且處理的邏輯較多。
 */
public synchronized boolean goBackOrForward(OffsetToPosInfo info) {
    //...
 

    //處理頁面向前和回退時，一些狀態的維護和線場的儲存等
    //...
}

/**
 * 該方法主要工作是在特有的子執行緒中生成截圖Bitmap,以便Tab工作管理員中展示時獲取。
 */
void updateCaptureFromBlob(byte[] blob) {
    Bitmap capture = mCapture;

    synchronized (Tab.this) { //注意同步程式碼塊
        Options ops = new Options();
        ops.inMutable = true;
        ops.inPreferredConfig = Bitmap.Config.RGB_565;

        //此處為耗時操作
 

        Bitmap bitmap = BitmapFactory.decodeByteArray(blob, 0,
                        blob.length, ops);

        //... 其他邏輯 
    }
}

分析原因並重現問題：
分析anr的trace檔案堆疊資訊時發現當時一直阻塞在函式goBackOrForward()處且沒有更多的堆疊資訊，但有如下提示：awaiting to lock <0x08308eb5> held by thread 54。結合函式一看便知是當前執行緒（主執行緒）在等待其他執行緒（子執行緒）對synchronized鎖的釋放，於是順著找到了tid=54的子執行緒，並檢視堆疊資訊於是找到了該執行緒正在執行函式updateCaptureFromBlob()的同步程式碼塊，阻塞在BitmapFactory.decodeByteArray()處。

總結原因為：主執行緒的ui操作依賴子執行緒耗時函式中的synchronized同步鎖，最終發生了ANR無響應。

synchronized關鍵字的相關概念

注意：此處均為網上查詢的資料，以備後續查詢。

1、內建鎖
synchronized關鍵字涉及到鎖的概念，需要了解一些相關鎖的知識。

java的內建鎖：每個java物件都可以用做一個實現同步的鎖，這些鎖成為內建鎖。執行緒進入同步程式碼塊或方法的時候會自動獲得該鎖，在退出同步程式碼塊或方法時會釋放該鎖。獲得內建鎖的唯一途徑就是進入這個鎖的保護的同步程式碼塊或方法。

java內建鎖是一個互斥鎖，這就是意味著最多隻有一個執行緒能夠獲得該鎖，當執行緒A嘗試去獲得執行緒B持有的內建鎖時，執行緒A必須等待或者阻塞，直到執行緒B釋放這個鎖，如果B執行緒不釋放這個鎖，那麼A執行緒將永遠等待下去。

**java的物件鎖和類鎖：**java的物件鎖和類鎖在鎖的概念上基本上和內建鎖是一致的，但是，兩個鎖實際是有很大的區別的，物件鎖是用於物件例項方法，或者一個物件例項上的，類鎖是用於類的靜態方法或者一個類的class物件上的。

2、synchronized關鍵字的基本介紹

synchronized可以修飾方法，也可以修飾一個程式碼塊。

物件鎖的使用：

    /**
     * synchronized修飾方法名的物件鎖
     */
    private synchronized void test1() {
        //do something...
    }


    /**
     * synchronized修飾程式碼塊的物件鎖
     */
    private void test2() {
        //do something1...

        synchronized (this) {
            //do something2...
        }

        //do something3...
    }

類鎖的使用：

    /**
     * synchronized修飾方法名的類鎖（靜態方法）
     */
    private synchronized static void test3() {
        //do something...
    }


    /**
     * synchronized修飾程式碼塊的類鎖（非靜態方法）
     */
    private static void test4() {
        //do something1...

        synchronized (MainActivity.class) {
            //do something2...
        }

        //do something3...
    }

3、物件鎖和類鎖修飾的方法之間執行緒同步的測試

對於在物件鎖相互之間和類鎖相互之間進行執行緒同步我們很好理解，但是對於在物件鎖和類鎖之間進行執行緒同步時，會是什麼樣的結果，表示不能確定，於是寫demo驗證了一下：

    public class Test {

        /**
         * 使用synchronized修飾程式碼塊來實現物件鎖
         */
        public void test1() {
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);

                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {
                    }
                }
            }
        }

        /**
         * 使用synchronized修飾靜態方法來實現類鎖
         */
        public synchronized static void test2() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);

                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                }
            }
        }


    public static void main(String arg[]){

        final Test test = new Test();
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                test.test1();
            }
        }, "test1");

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                test.test2();
            }
        }, "test2");

        thread1.start();
        thread2.start();
    }

    }


輸出結果：
test1: 0
test2: 0
test1: 1
test2: 1
test1: 2
test2: 2
test1: 3
test2: 3
test1: 4
test2: 4 

結果表明，執行緒1和執行緒2在交替執行。物件鎖和類鎖的修飾的函式間進行執行緒同步時並不能達到我們預期的同步要求。這證明了類鎖和物件鎖是兩個不一樣的鎖，控制著不同的區域，它們互不干擾。執行緒獲得物件鎖的同時，也可以獲得該類鎖。

synchronized修飾程式碼塊的用處

既然有了synchronized修飾方法，為什麼還需要synchronized來修飾程式碼塊呢？java這樣如此設計肯定是為了避免或解決什麼問題。
1、便於降低同步程式碼的粒度，以此來提高效能。舉例：

        public synchronized void test3() {

            /**
             * 需要同步處理的關鍵程式碼
             */
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }

            /**
             * 這裡特別耗時，但不要求同步處理
             */
            for (int i = 0; i < 1000000; i++) {
                //...do something
            }
        }

        public void test4() {
            /**
             * 需要同步處理的關鍵程式碼
             */
            synchronized (this) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }

            /**
             * 這裡特別耗時，但不要求同步處理
             */
            for (int i = 0; i < 1000000; i++) {
                //...do something
            }
        }

方法test4()的效率明顯高於方法test3()，因為test4的同步粒度更小，需要等待的時間更短。

2、便於實現區域性功能的同步。舉例：

        private final Object mLock = new Object();

        public synchronized void test5() {
            for (int i = 0; i < 5; i++) {
                System.out.println(Thread.currentThread().getName() + ": " + i);
            }
        }

        public void test6() {
            synchronized (mLock) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }

        public void test7() {
            synchronized (mLock) {
                for (int i = 0; i < 5; i++) {
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }

方法test6()和test7()線上程間同步處理被阻塞時，函式test5()仍然可以進去。這是因為使用了不同的所物件，這對於僅僅實現類的區域性同步時有著更高的處理效率。

總結

回到最開始的ANR的例子這裡由於兩個方法goBackOrForward()和updateCaptureFromBlob同時使用了同一個同步物件鎖所致，解決辦法是使子執行緒處理函式updateCaptureFromBlob()使用一個區域性鎖來解耦主執行緒對其的依賴。如下所示：

private final Object mCaptureLock = new Object();

void updateCaptureFromBlob(byte[] blob) {
    Bitmap capture = mCapture;

    synchronized (mCaptureLock) { //使用一個僅處理該邏輯的才使用的一個物件鎖

        Options ops = new Options();
        ops.inMutable = true;
        ops.inPreferredConfig = Bitmap.Config.RGB_565;

        //此處為耗時操作
        Bitmap bitmap = BitmapFactory.decodeByteArray(blob, 0,
                        blob.length, ops);

        //... 其他邏輯 
    }
}