8鎖現象

原創 halla001 2020-07-05 14:35

1

標準訪問，先打印郵件還是先發送短信

   解釋 ：這個是不能確定的，線程的調度與cpu有關，所以不能確定。但是在代碼中添加了sleep().是爲了讓A線程一定在B線程之前執行，這只是爲了更好的解釋鎖。

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        //TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停4秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}



    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }



標準訪問，請問先打印郵件還是短信(線程調度，不一定) 郵件
 一個對象裏面如果有多個synchronized方法，某一個時刻內，只要有一個線程去調用其中的一個synchronized方法了，
其他的線程都只能等待，換句話說，某一個時刻內，只能有唯一一個線程去訪問這些synchronized方法

 

2 

在郵件方法暫停3秒鐘，請問先打印郵件還是短信  答案： 郵件

解釋：鎖的對象是當前對象this，被鎖定後，其他的線程都不能進入到當前對象的其它synchronized方法

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停4秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }


//注意，在發郵件代碼中，讓其暫停3秒是爲了驗證，看其他線程能否訪問當前被synchronize鎖定的對象

在郵件方法暫停4秒鐘，請問先打印郵件還是短信   郵件
鎖的對象是當前對象this，被鎖定後，其他的線程都不能進入到當前對象的其它synchronized方法

 

3 

新增普通的sayHello方法，請問先打印郵件還是sayHello   答案：sayHello（因爲先打印郵件，在裏面等待了3秒。）

解釋：加一個普通方法和同步鎖無關

    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停4秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }

    public synchronized void sayHello() throws Exception{
        System.out.println("Hello");
    }



    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone.sayHello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }

 

4

兩部手機，請問先打印郵件還是短信 答案：短信。（只是因爲打印郵件等待了3秒）

解釋：換成兩個對象後，不是同一把鎖了，情況立刻變化

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停4秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();

        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone2.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }

 

5

兩個靜態同步方法，同一部手機，請問先打印郵件還是短信 答案 ：郵件

解釋 ：

static 鎖的是全局鎖

//Phone.java ---> Phone.class Class.forName() static 鎖的是Class（字節碼文件），但是不影響實例對象，

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停3秒鐘
        System.out.println("發郵件");
    }

    public static synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}



    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }
/*

 * 5 兩個靜態同步方法，同一部手機，請問先打印郵件還是短信 郵件
 *           static 鎖的是全局鎖
 *           //Phone.java ---> Phone.class    Class.forName() static 鎖的是Class
 *           synchronized實現同步的基礎：Java中的每一個對象都可以作爲鎖
 *                具體表現爲以下3中形式。
 *                    對於普通不同方法，鎖的是當前實例對象。
 *                    對於同步方法塊，鎖是Synchronized括號裏面配置的對象this
 *                    對於靜態同步方法，鎖是當前類的Class對象（模板  不管多少個對象，都是來源於這個鎖 ）
 */

 

6 

兩個靜態同步方法，兩部手機看，請問先打印郵件還是短信  答案：郵件

解釋：和第五點幾乎一樣。

因爲第一步手機對象，已經鎖住字節碼，第二個對象必須等着。所以還是第一個手機對象先。。

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停3秒鐘
        System.out.println("發郵件");
    }

    public static synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone2.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }

 

7 

一個靜態同步方法，一個普通同步方法，同一部手機，先打印郵件還是短信(普通同步方法)      答案: 短信
當一個線程視圖訪問同步代碼塊時，它首先必須得到鎖，推出或拋出異常時必須釋放鎖。
也就是說如果一個實例對象的非靜態同步方法獲取鎖後，該實例對象的其他非靜態同步方法必須等待獲取鎖的方法後才能獲取鎖，
可是別的實例對象的非靜態同步方法因爲跟該實例對象的非靜態同步方法用的時不同的鎖，

所有的靜態同步方法用的也是一把鎖-類對象本身
這兩把鎖時兩個不同的對象，所以靜態同步方法與非靜態同步方法之間時不會有靜態條件的
但是一旦一個靜態同步方法獲取鎖後，其他的靜態同步方法都必須等待該方法釋放鎖後才能獲取鎖
還是不同的實例對象的靜態同步方法之間，只要他們同一個類的實例對象

通俗的說法：

static鎖的是大門（字節碼文件），普通synchronize鎖的是大門裏面的一扇門，它的關閉不影響大門，也與大門無關（鎖對象）

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停3秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }
}


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }

 

8

一個靜態同步方法，一個普通同步方法，兩部手機，請問先打印郵件還是短信  答案：短信

一個鎖類對象，一個鎖對象，互不影響。

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的寫法
        //Thread.sleep(4000);//暫停3秒鐘
        System.out.println("發郵件");
    }

    public synchronized void sendMessage() throws Exception{
        System.out.println("發短信");
    }


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        Phone phone2 = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//這是故意讓A在B前面執行

        new Thread( ()->{
            try {
                phone2.sendMessage();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();
    }

 

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

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

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

JUC只線程之間協作

這個是在學習工作中的一些總結，若有不對之處歡迎大家指出。侵刪！ 需要源碼聯繫QQ:1352057131 得之在俄頃，積之在平日。   目錄 控制併發流程 控制併發流程工具類概覽 CountDownLatch 作用 流程 主要方法 示例1

努力爬行的小蜗牛 2020-06-30 21:14:43