多線程8鎖問題

原創 入坑程序汪 2020-05-17 06:49

多線程8鎖問題

在多線程環境中，訪問資源類的順序到底是如何？
最近，在網絡上看到一道題目，通過多線程的8種鎖情況瞭解訪問資源類的順序。

  1. 標準訪問，先打印郵件方法還是短信方法？
class Phone{
    public synchronized void sendEmail(){
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        //睡眠4毫秒
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

運行結果：

synchronized關鍵字鎖的不是當前方法，而是該方法所在的整個資源類，也就是說，同一時間下，只能有一個線程進入當前的資源類訪問同步方法，所以運行結果跟方法調用的順序相同。


  1. 郵件方法暫停4秒，先打印郵件方法還是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}

運行結果：

第二鎖的原理跟第一鎖相同，只不過是在發郵件方法中線程睡眠了4秒，當線程A訪問發郵件方法睡眠時，線程B無法進入該資源類，所以運行結果還是相同。


  1. 新增一個普通方法hello，先打印郵件方法還是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public void hello(){
        System.out.println("----hello----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.hello();
        }, "B").start();
    }
}

運行結果：

新增的hello方法並沒有被synchronized關鍵字修飾，不是同步方法，所以在線程A訪問發郵件方法時，線程B可以訪問到hello方法，而線程A需要睡眠4秒，所以運行結果是hello先。


  1. 兩個資源類，先打印郵件方法還是短信方法？
class Phone {
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

運行結果：

第四鎖中創建了兩個資源類，main方法中訪問的是兩個不同資源類的方法，相互並不干擾，而發郵件的方法睡眠4秒，所以發短信的方法會先打印。

  1. 兩個靜態同步方法，同一個資源類，先打印郵件方法還是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public static synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

運行結果：

這題涉及到static靜態，鎖的不再是這個資源類對象，鎖的是這個對象在類加載器中的類模板（.class），但由於還是同一個資源類，所以的順序原理還是跟第一鎖差不多。

  1. 兩個靜態同步方法，兩個資源類，先打印郵件方法還是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public static synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

運行結果：

第六鎖變換成兩個資源類，但由於static鎖的是整個類的類模板（.class），所以不論實例化多少個資源類訪問的結果還是相同的。

  1. 一個同步方法，一個靜態同步方法，一個資源類，先打印郵件方法還是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone.sendSMS();
        }, "B").start();
    }
}

運行結果：

第七鎖，一個靜態同步方法，一個普通同步方法，一個鎖的是整個類模板，一個鎖的是當前對象，兩者相互不衝突，所以發短信先顯示，發郵件的需要睡眠4秒才顯示。

  1. 一個同步方法，一個靜態同步方法，兩個資源類，先打印郵件方法還是短信方法？
class Phone {
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("----sendEmail----");
    }
    public synchronized void sendSMS(){
        System.out.println("----sendSMS----");
    }
}
public class lock8 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();
        TimeUnit.MILLISECONDS.sleep(4);
        new Thread(() -> {
            phone2.sendSMS();
        }, "B").start();
    }
}

運行結果：

第八鎖與第七鎖的原理類似。

總結

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

  • 對於普通同步方法，鎖的是當前實例對象
  • 對於靜態同步方法，鎖的是當前類的Class對象
  • 對於同步方法快，鎖的是synchronized括號裏配置的對象
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

LeetCode（1195）：交替打印字符串 Fizz Buzz Multithreaded（JUC）

2020.7.7 LeetCode 從零單刷個人筆記整理（持續更新） github：https://github.com/ChopinXBP/LeetCode-Babel 傳送門：交替打印字符串 Write a program

NJU_ChopinXBP 2020-07-08 06:56:30

JUC練習代碼-力扣多線程1116題目：打印零與奇偶數，解題詳解

題目描述 假設有這麼一個類： class ZeroEvenOdd { public ZeroEvenOdd(int n) { … } // 構造函數 public void zero(printNumber) { … }

老张聊天 2020-07-05 21:03:00

JUC練習代碼-力扣多線程1195題目：交替打印字符串，解題詳解

題目描述 編寫一個可以從 1 到 n 輸出代表這個數字的字符串的程序，但是： 如果這個數字可以被 3 整除，輸出 “fizz”。 如果這個數字可以被 5 整除，輸出 “buzz”。 如果這個數字可以同時被 3 和 5 整除，輸出

老张聊天 2020-07-05 21:03:00

JUC練習代碼-力扣多線程1126題目：哲學家進餐，解題詳解

想起來上學的時候好像就挺經典的一道算法題，一直沒有自己試過去解決。剛好力扣上有這道題，於是試試看。 題目描述就簡單說了。5個哲學家5只筷子，要保證每個哲學家都能喫上飯。。 哲學家從 0 到 4 按 順時針 編號。請實現函數 voi

老张聊天 2020-07-05 21:03:00

8鎖現象

1 標準訪問，先打印郵件還是先發送短信    解釋 ：這個是不能確定的，線程的調度與cpu有關，所以不能確定。但是在代碼中添加了sleep().是爲了讓A線程一定在B線程之前執行，這只是爲了更好的解釋鎖。 class Phone//Ph

halla001 2020-07-05 14:35:24

JUC之集合類不安全

package com.alisa.juc.collect; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util

Alisa_zmx 2020-07-04 03:14:53

JUC之Lock接口

1.synchronized與Lock的區別 （1）synchronized是java內置關鍵字，在jvm層面，Lock是個java類 （2）synchronized無法判斷是否獲取鎖的狀態，Lock可以判斷是否獲取到鎖 （3）s

Alisa_zmx 2020-07-04 03:14:53

JUC筆記1

JUC 線程的概念、啓動方式、常用方法 synchronized(Object) 不能用String常量 Integer Long 線程同步 synchronized 鎖的是對象不是代碼 (開頭兩個字節) 普通方法鎖的

huangsonglie 2020-07-03 12:07:25

JUC-線程池源碼簡析

一、線程池介紹 Java5開始，在util下提供了一個包，叫做JUC（java.util.concurrent），裏面提供了關於多線程、併發的一些工具包。例如鎖、多線程等工具都在這個包中。 我們知道一個線程的創建、銷燬過程是會消耗系統性能

Ftsom 2020-07-02 22:48:17

JUC-AQS框架解析

一、簡介 當我們談到併發的時候，就會想到java中juc包下的一系列的併發工具，例如Lock、CountDownLatch、CyclicBarrier以及Semphore等，當你使用這些併發工具的時候，就必需深刻理解AQS，因爲AQS是j

Ftsom 2020-07-02 22:48:17

JUC-volatile關鍵字作用

一、前言 本文意在講解java中volatile關鍵字的作用以及原理，因爲該關鍵字可以說是JMM模型封裝底層原語而提供出來的API，他的實現涉及到cpu的指令以及線程內存與主存間的交互過程，因此本文會從cpu到緩存內存，再到線程以及JMM

Ftsom 2020-07-02 22:48:17

Java併發輔助類

序言 由於最近項目上遇到了高併發問題，而自己對高併發，多線程這裏的知識點相對薄弱，尤其是基礎，所以想系統的學習一下，以後可能會出一系列的JUC文章及總結 ，同時也爲企業級的高併發項目做好準備。 本文是JUC文章的第五篇，如想看以往

Zz罗伯特 2020-07-02 20:42:32

ScheduledThreadPoolExecutor JDK定時任務線程池

https://www.jianshu.com/p/18f4c95aca24 流程： 1 提交任務的時候，任務被包裝成ScheduledFutureTask對象加入延遲隊列並啓動一個woker線程。 2 用戶提交的任務加入延遲隊列時，會按

csdn_9527666 2020-07-02 11:50:52

JUC學習總結

JUC相關基本概念 進程與線程 進程：進程是程序的一次執行過程，是系統運行程序的基本單位，系統運行一個程序後關閉，就是一個進程從開始到運行到死亡的全部過程。 線程：線程的粒度比進程更小，一個進程的執行過程會產生多個線程。所有線程會共享進程

隆中手心的水 2020-07-02 07:18:13

一些Java併發編程的問題記錄

1.Synchronized的實現原理        同步代碼塊使用monitorenter和monitorexit兩個指令實現，可以把執行monitorenter指令理解爲加鎖，執行monitorexit理解爲釋放鎖。 每個對象維護着一

锋少的博客 2020-06-30 23:09:04