1.概念

synchronized 是 Java 中的關鍵字，是利用鎖的機制來實現同步的。

鎖機制有如下兩種特性：

• 互斥性：即在同一時間只允許一個線程持有某個對象鎖，通過這種特性來實現多線程中的協調機制，這樣在同一時間只有一個線程對需同步的代碼塊(復合操作)進行訪問。互斥性我們也往往稱為操作的原子性。

• 可見性：必須確保在鎖被釋放之前，對共享變量所做的修改，對於隨後獲得該鎖的另一個線程是可見的（即在獲得鎖時應獲得最新共享變量的值），否則另一個線程可能是在本地緩存的某個副本上繼續操作從而引起不一致。

2.對象鎖和類鎖

• 對象鎖
  在 Java 中，每個對象都會有一個 monitor 對象，這個對象其實就是 Java 對象的鎖，通常會被稱為“內置鎖”或“對象鎖”。類的對象可以有多個，所以每個對象有其獨立的對象鎖，互不幹擾。

• 類鎖
  在 Java 中，針對每個類也有一個鎖，可以稱為“類鎖”，類鎖實際上是通過對象鎖實現的，即類的 Class 對象鎖。每個類只有一個 Class 對象，所以每個類只有一個類鎖。

3.synchronized 的用法

• 獲取對象鎖

//修飾非靜態方法
synchronized(this|object){
}

• 獲取類鎖

//修飾靜態方法，非靜態方法
synchronized(類.class){
}

4.synchronized 的作用

synchronized(this|object) {} 獲取到對象的鎖之後，這個對象中的其他需要對象鎖的地方線程不能進入，非同步方法無影響，例如：

public class ThreadTest {
    publicvoid test3() {
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + " test3 進入");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " test3 退出");
            } 
 
catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    publicstaticvoid test4() {
        synchronized (this) {
            try {
                System.out.println(Thread.currentThread().getName() + " test4 進入");
                Thread.sleep(3000);
                System.out.println(Thread.currentThread().getName() + " test4 退出");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Test {
    static volatile LinkedList<String> list = new LinkedList<>();

    public static void main(String[] args) throws SQLException {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(15, 20, 2000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

        final ThreadTest threadTest = new ThreadTest();
        for (int i = 0; i < 5; i++)
            poolExecutor.execute(
                    new Runnable() {
                        @Override
                        public void run() {
                            threadTest.test3();
                        }
                    });

        for (int i = 0; i < 5; i++)
            poolExecutor.execute(
                    new Runnable() {
                        @Override
                        public void run() {
                            threadTest.test4();
                        }
                    });
    }
}

pool-1-thread-1 test3 進入
pool-1-thread-1 test3 退出
pool-1-thread-10 test4 進入
pool-1-thread-10 test4 退出
pool-1-thread-9 test4 進入
pool-1-thread-9 test4 退出
pool-1-thread-8 test4 進入
pool-1-thread-8 test4 退出
pool-1-thread-7 test4 進入
pool-1-thread-7 test4 退出
pool-1-thread-6 test4 進入
pool-1-thread-6 test4 退出
pool-1-thread-5 test3 進入
pool-1-thread-5 test3 退出
pool-1-thread-4 test3 進入
pool-1-thread-4 test3 退出
pool-1-thread-2 test3 進入
pool-1-thread-2 test3 退出
pool-1-thread-3 test3 進入
pool-1-thread-3 test3 退出

當執行test3()方法時，synchronized (this)獲取到了此對象的鎖，test4()方法就必須等待test3()方法釋放對象鎖才能進入，在同一時刻只能有一個線程進入同一對象中需要對象鎖的方法中。

註意：下面這兩個效果是一樣的，synchronized修飾方法默認獲取的也是對象鎖

public synchronized void test3(){
...
}

public void test2() {
    synchronized (ThreadTest.class) {
          ...   
    }
}

同理可驗證類鎖，在同一時刻只能有一個線程進入類中需要類鎖的方法中。
因為對象鎖和類鎖是兩個不同的鎖，所以同一個類中的需要類鎖和需要對象鎖的方法之間是互不影響的。

synchronized(this) 與 synchronized(class) 理解