摘要：基本使用同步代碼塊同步代碼塊延時秒，方便后面測試作用代碼塊時，方法中的，是指調用該方法的對象。那么這個時候使用關鍵字就需要注意了推薦使用同步代碼塊，同步的代碼塊中傳入外部定義的一個變量。

計算機單線程在執行任務時，是嚴格按照程序的代碼邏輯，按照順序執行的。因此單位時間內能執行的任務數量有限。為了能在相同的時間內能執行更多的任務，就必須采用多線程的方式來執行（注意：多線程模式無法減少單次任務的執行時間）。但是引入了多線程之后，又帶來了線程安全的問題。而為了解決線程安全的問題，又引入了鎖的概念。java中常用的鎖有synchronized和lock兩種，本文我們來分析synchronized的具體用法和使用注意事項。

同步代碼塊

/**
 * 同步代碼塊
 * @throws Exception
 */
public void synchronizedCode() {
    try {
        synchronized (this) {
            System.out.println(getCurrentTime() + ":I am synchronized Code");
            Thread.sleep(5000);//延時5秒，方便后面測試
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

作用代碼塊時，synchronized方法中的this，是指調用該方法的對象。需要主要的是，synchronized作用代碼塊時，只會鎖住這一小塊代碼。代碼塊的上下部分的其他代碼在所有的線程仍然是能同時訪問的。同時需要注意的是每個對象有用不同的鎖。即不會阻塞不同對象的調用。

同步方法

/**
  * 同步方法
  */
public synchronized void synchronizedMethod() {
    try {
        System.out.println(getCurrentTime() + ":I am synchronized method");
        Thread.sleep(5000);//延時5秒，方便后面測試
    } catch (Exception e) {
        e.printStackTrace();
    }
}

synchronized作用在方法上，其實是缺省了this關鍵字，實際上是synchronized(this)。this是指調用該方法的對象。此鎖也不會阻塞不同對象之間的調用。

同步靜態方法

/**
* 同步靜態方法
*/
public synchronized static void synchronizedStaticMethod() {
    try {
        System.out.println(getCurrentTime() + ":I am synchronized static method");
        Thread.sleep(5000);//延時5秒，方便后面測試
    } catch (Exception e) {
        e.printStackTrace();
    }
}

使用方式和作用普通方式相同，唯一需要注意的地方是此鎖所有對象共用，即不同對象之間會阻塞調用。

簡單說明一下：有一個線程池，在執行多任務時使用。每個同步方法或者代碼塊中都有一個休眠5秒的動作，利用打印時間加休眠來看線程之間是否有阻塞效果。然后有一個1秒打印一次時間的方法。

public class Synchronized {
    //打印時間時格式化
    public static final String timeFormat = "HH:mm:ss";
    //執行多任務的線程池
    public static final ExecutorService executor = Executors.newFixedThreadPool(4);

    /**
     * 同步代碼塊
     * @throws Exception
     */
    public void synchronizedCode() {
        try {
            synchronized (this) {
                System.out.println(getCurrentTime() + ":I am synchronized Code");
                Thread.sleep(5000);//延時5秒，方便后面測試
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 同步方法
     */
    public synchronized void synchronizedMethod() {
        try {
            System.out.println(getCurrentTime() + ":I am synchronized method");
            Thread.sleep(5000);//延時5秒，方便后面測試
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 同步靜態方法
     */
    public synchronized static void synchronizedStaticMethod() {
        try {
            System.out.println(getCurrentTime() + ":I am synchronized static method");
            Thread.sleep(5000);//延時5秒，方便后面測試
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 循環打印時間
     */
    public static void printNumber() {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                while (true) {
                    try {
                        printOnceASecond();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        });
    }

    /**
     * 一秒打印一次時間
     *
     * @throws Exception
     */
    public static void printOnceASecond() throws Exception {
        System.out.println(getCurrentTime());
        Thread.sleep(1000);
    }

    /**
     * 獲取當前時間
     *
     * @return
     */
    public static String getCurrentTime() {
        return LocalDateTime.now().format(DateTimeFormatter.ofPattern(timeFormat));
    }
}

OK，接下來我們就來測試下鎖的互斥性以及使用注意事項（都是多線程的情況下）。

同一個對象同步代碼塊

public static void main(String[] args) throws Exception {
    printNumber();//控制臺循環打印時間
    Synchronized es = new Synchronized();
    executor.execute(() -> es.synchronizedCode());
    executor.execute(() -> es.synchronizedCode());
}

execute

20:34:41:I am synchronized Code
20:34:41
20:34:42
20:34:43
20:34:44
20:34:45
20:34:46:I am synchronized Code

同步代碼塊中休眠5秒，導致另外一個線程阻塞5秒后再執行。說明代同步碼塊會阻塞同一個對象的不同線程之間的調用（同步方法和同步靜態方法也會阻塞同一個對象的不同線程之間的調用，此處省略測試代碼）

不同對象同步代碼塊

public static void main(String[] args) throws Exception {
    printNumber();//控制臺循環打印時間
    Synchronized es = new Synchronized();
    Synchronized es1 = new Synchronized();
    executor.execute(() -> es.synchronizedCode());
    executor.execute(() -> es1.synchronizedCode());
}

execute

20:44:34:I am synchronized Code
20:44:34:I am synchronized Code

由結果可以看出，不同對象之間代碼塊鎖互不影響（多線程也一樣）。原因是因為代碼塊中synchronized (this)

鎖的是當前調用對象，不同對象之間不是同一把鎖，因此互不影響（同步方法原理也是如此，省略測試代碼）。

同一對象同步代碼塊和方法

public static void main(String[] args) throws Exception {
    printNumber();//控制臺循環打印時間
    Synchronized es = new Synchronized();
    executor.execute(() -> es.synchronizedCode());
    executor.execute(() -> es.synchronizedMethod());
}

execute

20:51:27:I am synchronized method
20:51:27
20:51:28
20:51:29
20:51:30
20:51:31
20:51:32:I am synchronized Code

因為同步代碼塊和同步方法，都是鎖當前調用對象，因此執行后打印上述結果應該在意料之中。基于這樣的特性，實際開發在使用spring的時候就需要注意了，我們的bean交給spring容器管理之后，默認都是單例的。那么這個時候使用synchronized關鍵字就需要注意了（推薦使用同步代碼塊，同步的代碼塊中傳入外部定義的一個變量）。

不同對象靜態同步方法

public static void main(String[] args) throws Exception {
    printNumber();//控制臺循環打印時間
    Synchronized es = new Synchronized();
    Synchronized es1 = new Synchronized();
    executor.execute(() -> es.synchronizedStaticMethod());
    executor.execute(() -> es1.synchronizedStaticMethod());
}

execute

21:05:39:I am synchronized static method
21:05:40
21:05:41
21:05:42
21:05:43
21:05:44:I am synchronized static method

由上述結果可以看出來，靜態同步方法會阻塞所有的對象。原因是所有的靜態同步方法都是占用的同一把鎖。

相同對象同步方法和靜態同步方法

public static void main(String[] args) throws Exception {
    printNumber();//控制臺循環打印時間
    Synchronized es = new Synchronized();
    executor.execute(() -> es.synchronizedMethod());
    executor.execute(() -> es.synchronizedStaticMethod());
}

execute

21:11:03:I am synchronized static method
21:11:03:I am synchronized method

由此結果可以看出，同步方法和靜態同步方法之間不會造成阻塞的現象。因為他們鎖的對象不一樣。同步方法占用的鎖是調用對象，靜態同步方法鎖的是編譯后的class對象（類鎖）。

同一個對象，同步方法、同步代碼塊之間互斥，同時和自己也互斥。靜態同步方法只和自己互斥

不同對象之間，同步方法、同步代碼塊不會互斥。靜態同步方法會互斥

synchronized在占用鎖時，必須精確到某一個具體的對象