多線程之8鎖問題

Phone 有兩個方法：發送郵件和發送短信，每個方法都打印一句話，現在通過不同的方式對方法進行操作，回答出打印的先后順序（建議先自己看代碼認真思考，然后再看答案，文章結尾會對每個問題進行分析）

問題

1、標准訪問，兩線程中間睡眠 2 毫秒，先打印郵件還是短信？

class Phone {
    public synchronized void sendEmail() {
        System.out.println("send email");
    }
    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock01 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

查看答案

send email
send sms

2、在 sendEmail() 方法中睡眠 4 秒，先打印郵件還是短信？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }
    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock02 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

查看答案

send email
send sms

3、添加普通的 hello() 方法，先打印郵件還是 hello？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }
    public void hello() {
        System.out.println("hello");
    }
}
public class Lock03 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.hello(), "B").start();
    }
}

查看答案

hello
send email

4、2 個手機，先打印郵件還是短信？

class Phone {
    public synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock04 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

查看答案

send sms
send email

5、2個靜態同步方法，1部手機，先打印郵件還是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public static synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock05 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

查看答案

send email
send sms

6、2個靜態同步方法，2部手機，先打印郵件還是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public static synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock06 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

查看答案

send email
send sms

7、1個靜態同步方法，1個普通同步方法，1部手機，先打印郵件還是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock07 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> phone.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone.sendSms(), "B").start();
    }
}

查看答案

send sms
send email

8、1個靜態同步方法，1個普通同步方法，2部手機，先打印郵件還是短信？

class Phone {
    public static synchronized void sendEmail() {
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("send email");
    }

    public synchronized void sendSms() {
        System.out.println("send sms");
    }
}

public class Lock08 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> phone1.sendEmail(), "A").start();
        Thread.sleep(200);
        new Thread(() -> phone2.sendSms(), "B").start();
    }
}

查看答案

send sms
send email

分析

🎨 問題一

當一個對象里有多個同步（synchronized）方法，有一個線程訪問了其中一個同步方法，其它線程只能等待其訪問完成后才能訪問，因為此時鎖的是當前對象 this，其它的線程都不能進入到當前對象的其它的同步方法。

如果沒有添加 Thread.sleep(200); 則打印的順序是不一定的，因為線程的調度和操作系統有關。 添加 Thread.sleep(200); 則保證了線程 A 比 B 先執行。

🎨 問題二

由於線程 A 先執行，會先調用 sendEmail() 方法，Phone 實例就會被鎖住，線程 B 只能等待 A 執行完在執行。

🎨 問題三

hello() 方法並不是同步方法，因此不受鎖的影響。

🎨 問題四

現在有兩個實例，前面我們說過，synchronized 鎖的是 this，所以會產生兩把鎖，它們之間互不干擾，誰先執行完誰就先打印。

🎨 問題五、問題六

synchronized 實現同步的基礎：Java 中的每一個對象都可以作為鎖，具體表現為以下三種形式：

• 對於普通同步方法，鎖的是當前實例對象 this
• 對於靜態同步方法，鎖的是當前類的 Class 對象
• 對於同步方法塊，鎖是Synchonized括號里配置的對象

所以，無論是 1 個對象還是 2 個對象，靜態同步方法鎖的都是 Class，只能按照線程執行的順序打印。

🎨 問題七、問題八

這兩種情況都是 1 個靜態同步方法，1 個非靜態同步方法，它們的鎖都不是同一個對象，因此相互不受影響

總結

1、當一個線程試圖訪問同步代碼塊時，它首先必須得到鎖，退出或拋出異常時必須釋放鎖。

2、Java 中的每一個對象都可以作為鎖；普通同步方法鎖 this，靜態同步方法鎖 Class，同步方法塊鎖括號；

3、只要鎖的對象不是同一個，就直接按照線程執行的快慢來決定；鎖的對象是同一個，就按照線程進入的先后順序決定。

只要掌握了鎖的對象是什么，無論是 8 鎖還是 100 鎖都不在話下！