常用API

同步

上面已經介紹了比較常用的api，現在我們可以了解一下在多線程中占據著重要地位的鎖了。

為什麽會出現線程不安全

在上一篇文章中有提到在現在操作系統中進程是作為資源分配的基本單位，而線程是作為調度的基本單位，一般而言，線程自己不擁有系統資源，但它可以訪問其隸屬進程的資源，即一個進程的代碼段、數據段及所擁有的系統資源，如已打開的文件、I/O設備等，可以供該進程中的所有線程所共享，一旦有多個線程在操作同樣的資源就可能造成線程安全的問題。

在我們熟悉的Java中存在著局部變量和類變量，其中局部變量是存放在棧幀中的，隨著方法調用而產生，方法結束就被釋放掉，而棧幀是獨屬於當前線程的，所以不會有線程安全的問題。而類變量是被存放在堆內存中，可以被所有線程共享，所以也會存在線程安全的問題。

synchronized

在Java中我們見得最多的同步的方法應該就是使用synchronized關鍵字了。實際上synchronized就是一個互斥鎖，當一個線程運行到使用了synchronized的代碼段時，首先檢查當前資源是否已經被其他線程所占用，如果已經被占用，那麽該線程則阻塞在這裏，直到擁有資源的線程釋放鎖，其他線程才可以繼續申請資源。

實現簡單理解

public static void test(){
    synchronized (SyncDemo.class){
    }
}

//編譯後的代碼
  public static void test();
    Code:
       0: ldc           #3                  //將一個常量加載到棧中這裏既是class com/learn/set/mutilthread/sync/SyncDemo
       2: dup               //復制棧頂元素(SyncDemo.class)
       3: astore_0          //將棧頂元素存儲到局部變量表
       4: monitorenter      //以字節碼對象(SyncDemo.class)為鎖開始同步操作
       5: aload_0           //將局部變量表slot_0入棧(SyncDemo.class)
       6: monitorexit       //退出同步
       7: goto          15  //到這裏程序跳轉到return語句正常結束，下面代碼是異常路徑
      10: astore_1
      11: aload_0
      12: monitorexit
      13: aload_1
      14: athrow
      15: return

到這裏就差不多了，詳細的原理後面再談，這裏主要是談談synchronized的使用。

synchronized的使用

在Java語言中，synchronized關鍵字可以用來修飾方法以及代碼塊：

修飾方法

    //修飾普通方法
    public synchronized void say(){
        
    }
    //修飾靜態方法
    public synchronized static void fun(){
        
    }

修飾代碼塊

    public void fun1(){
        //使用當前對象為鎖
        synchronized (this){
            //statement
        }
    }

    public void fun2(){
        //使用當前類字節碼對象為鎖
        synchronized (SyncDemo.class){
            //statement
        }
    }

synchronized在不同場景下的區別

實體類：

public class User {
    private static int age = 20;

    public synchronized void say(String user) throws InterruptedException {
//        synchronized (User.class){
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        //當前線程休眠，判斷別的線程是否還能調用
        Thread.sleep(1000);
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
//        }
    }

    public synchronized void say1(String user) throws InterruptedException {
//        synchronized (User.class){
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        Thread.sleep(1000);
        age = 15;
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
//        }
    }
}

測試類：

public class SyncTest{
    private static User user1 = new User();
    private static User user2 = new User();

    private static class Sync1 extends Thread{
        @Override
        public void run() {
            try {
                user1.say("user1");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private static class Sync2 extends Thread{
        @Override
        public void run() {
            try {
                user2.say("user2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Sync1 sync1 = new Sync1();
        Sync2 sync2 = new Sync2();
        sync1.start();
        sync2.start();
    }
}
運行結果：
第一次運行：
20:Thread-1:user2
20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
第二次運行：
20:Thread-1:user2
20:Thread-0:user1
20:Thread-1:user2
20:Thread-0:user1

運行結果表示在普通方法上加synchronized關鍵字實際上是鎖的當前對象，所以不同線程操作不同對象結果可能出現不一致。修改實體類User的say(...)方法為靜態方法：

public synchronized void say(String user) throws InterruptedException {
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
        Thread.sleep(1000);
        System.out.println(age + ":" + Thread.currentThread().getName() + ":" + user);
    }

運行結果始終按照順序來：

20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
20:Thread-1:user2

說明在靜態(類)方法上加synchronized關鍵字實際上是鎖的當前類的字節碼對象，因為在JVM中任何類的字節碼對象都只有一個，所以只要對該字節碼對象加鎖那麽任何對該類的操作也都是同步的。

在最初類的基礎上修改類Sync2，使得兩個線程操作統一對象：

private static class Sync2 extends Thread{
        @Override
        public void run() {
            try {
                user1.say("user2");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

運行結果始終按照順序來：

20:Thread-0:user1
20:Thread-0:user1
20:Thread-1:user2
20:Thread-1:user2

同理可測試在使用synchronized修飾代碼塊的作用，可得結果使用this對象實際是鎖當前對象，與synchronized修飾普通方法類似，使用User.class字節碼對象實際是鎖User類的字節碼對象，與synchronized修飾靜態方法類似。需要說明的事鎖代碼塊實際上並不是必須使用當前類的this對象和字節碼對象，而可以是任意的對象。而實際效果和使用當前類的對象一致。

Java多線程之二(Synchronized)