JUC并发编程学习（五）-8锁现象

最新推荐文章于 2022-06-13 16:12:35 发布
最新推荐文章于 2022-06-13 16:12:35 发布
阅读量370 收藏
点赞数
分类专栏： JUC并发编程 文章标签： 并发编程 多进程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36654629/article/details/105946267
版权

以下名词解释：
顺序执行：先调用的先执行；
随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰

将从以下8个方面介绍锁现象

1. 多个线程使用同一把锁-顺序执行

多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！

示例1、 标准访问，请问先打印邮件还是短信？

package com.juc.study.lock8;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 16:32
* @description:    TODO 示例1.标准访问，请问先打印邮件还是短信？
* @Version: 1.0
*/
public class Test1 {


    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();


        new Thread(() -> {
            phone.sendMsg();
        }, "B").start();


    }
}


class Phone {


    public synchronized void sendEmail() {
        System.out.println("发邮件");
    }


    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
}

在这里插入图片描述

2. 多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行

多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行,即使在某方法中设置了阻塞。

示例2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:02
* @description:    TODO 示例2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
* @Version: 1.0
*/
public class Test2 {


    public static void main(String[] args) {
        Phone2 phone=new Phone2();
        new Thread(() -> {
            phone.sendEmail();
        }, "A").start();


        new Thread(() -> {
            phone.sendMsg();
        }, "B").start();
    }
}
class Phone2 {


    public  synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }


    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
}

在这里插入图片描述

3. 多个线程有锁与没锁-随机执行

多个线程，有的线程有锁，有的线程没锁，两者之间不存在竞争同一把锁的情况，先后执行顺序是随机的。

这种情况犹如你跟你老婆下班回家，家里面的厕所是有锁的，卧室没有锁，俩人到家后，你老婆先上厕所（有锁），你可以一直等待你老婆出来，你再去厕所后，才进卧室，你也可以先进卧室，等你老婆出来后，你再进厕所。

示例3、新增一个普通方法发qq,请问先打印邮件还是接收QQ？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:02
* @description:    TODO 示例3、新增一个普通方法发qq,请问先打印邮件还是接收QQ？
* @Version: 1.0
*/
public class Test3 {


    public static void main(String[] args) {
        Phone3 phone=new Phone3();
        new Thread(() -> {
            phone.sendEmail();  //发邮件
        }, "A").start();


        new Thread(() -> {
            phone.sendMsg();    //发短信
        }, "B").start();


        new Thread(() -> {
            phone.sendQQ(); //发QQ
        }, "C").start();
    }
}


class Phone3 {


    //发邮件
    public  synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发邮件");
    }


    //发短信
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }


    //发QQ:  新增的方法没有被 synchronized 修饰，不是同步方法，所以不需要等待，其他线程用了一个把锁
    public void sendQQ(){
        System.out.println("发QQ");
    }
}

在这里插入图片描述

4.多个线程使用多把锁-随机执行

1、被 synchronized 修饰的方法，锁的对象是方法的调用者；
2、调用者不同，它们之间用的不是同一个锁，相互之间没有关系。

示例4、两部手机、请问先打印邮件还是短信？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:18
* @description:    TODO 示例4、两部手机、请问先打印邮件还是短信？
* @Version: 1.0
*/
public class Test4 {
    public static void main(String[] args) {
        Phone4 phoneOne=new Phone4();
        Phone4 phoneTwo=new Phone4();


        // 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
        new Thread(() -> {
            phoneOne.sendEmail();
        }, "A").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
          phoneTwo.sendMsg();
        }, "B").start();
    }
}


class Phone4 {

    /**
     *  @description:
     *  被 synchronized 修饰的方法，锁的对象是方法的调用者；
     *  调用者不同，它们之间用的不是同一个锁，相互之间没有关系。
     */
    //发邮件
    public  synchronized void sendEmail() {
        //善意延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发邮件");
    }


    //发短信
    public synchronized void sendMsg() {
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
}

在这里插入图片描述

5. Class锁：多个线程使用一个对象-顺序执行

被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
锁Class和锁对象的区别：
1、Class 锁 ，类模版，只有一个；
2、对象锁 ， 通过类模板可以new 多个对象。
如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁

示例5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:18
* @description:    TODO 示例4、两个静态同步方法，同一部手机，请问先打印邮件还是短信？*
* @Version: 1.0
*/
public class Test5 {
    public static void main(String[] args) {
        Phone5 phoneOne=new Phone5();


        new Thread(() -> {
            phoneOne.sendEmail();
        }, "A").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
          phoneOne.sendMsg();
        }, "B").start();
    }
}


class Phone5 {


    /**
     *  @description:
     *锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     *被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
     */
    //发邮件
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()+"发邮件");
    }


    //发短信
    public static synchronized void sendMsg() {
        System.out.println(Thread.currentThread().getName()+"发短信");
    }
}

6. Class锁：多个线程使用多个对象-顺序执行

被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。
Class锁是唯一的，所以多个对象使用的也是同一个Class锁。

示例6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.juc.study.lock8;
import java.util.concurrent.TimeUnit;
/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:18
* @description: 示例6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
* @Version: 1.0
*/
public class Test6 {
    public static void main(String[] args) {
        Phone6 phone1 = new Phone6();
        Phone6 phone2 = new Phone6();




        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
            phone2.sendMsg();
        }, "B").start();
    }
}


class Phone6 {


    /**
     * @description: 锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     * 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
     */
    //发邮件
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "发邮件");
    }


    //发短信
    public static synchronized void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "发短信");
    }
}

在这里插入图片描述

7. Class锁与对象锁：多个线程使用一个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

示例7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-15 17:18
* @description: 示例7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
* @Version: 1.0
*/
public class Test7 {
    public static void main(String[] args) {
        Phone7 phone1 = new Phone7();

        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        new Thread(() -> {
            phone1.sendMsg();
        }, "B").start();
    }
}


class Phone7 {




    //发邮件 ：class 锁
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "发邮件");
    }


    //发短信：对象锁
    public  synchronized void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "发短信");
    }
}

在这里插入图片描述

8. Class锁与对象锁：多个线程使用多个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；
只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

示例8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.juc.study.lock8;


import java.util.concurrent.TimeUnit;


/**
* @ClassName:
* @PackageName: com.juc.study.lock8
* @author: youjp
* @create: 2020-04-16 10:19
* @description:    示例8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？
*
* @Version: 1.0
*/
public class Test8 {




    public static void main(String[] args) {
        Phone8 phone1 = new Phone8();
        Phone8 phone2 = new Phone8();


        new Thread(() -> {
            phone1.sendEmail();
        }, "A").start();


        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }




        new Thread(() -> {
            phone2.sendMsg();
        }, "B").start();
    }
}
class Phone8 {


    //发邮件 ：class 锁
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + "发邮件");
    }


    //发短信：对象锁
    public  synchronized void sendMsg() {
        System.out.println(Thread.currentThread().getName() + "发短信");
    }
}

在这里插入图片描述

小结

new this 本身的这个对象，调用者

static class 类模板，保证唯一！

一个对象中有多个 synchronized方法，某个时刻内只要有一个线程去访问 synchronized 方法了就会被加锁，独立公共厕所！其他线程就会阻塞！
加了一个普通方法后两个对象，无关先后，一个有锁，一个没锁！情况会变化！
换成静态同步方法，情况会变化！ CLASS ，所有静态同步方法的锁唯一 ，对象实例class 本身！

有兴趣的老爷，可以关注我的公众号【一起收破烂】，回复【006】获取2021最新java面试资料以及简历模型120套哦~
在这里插入图片描述

收破烂的小熊猫~
关注
专栏目录
JUC并发编程《Java-2021面试谈资系列》
zjdzka的博客
03-25 3185
JUC并发编程一、什么是JUC二、线程和进程三、Lock锁(重点)区别：四、生产者消费者五、8锁现象问题1，2问题3，4问题5，6问题7，8总结六、集合不安全CopyOnWriteArrayListCopyOnWriteSetConcurrentHashMap七、Callable八、常用辅助类CountDownLatchCyclicBarrierSemaphore九、读写锁十、阻塞队列方式一方式二方式三方式四同步队列十一、JMM十二、Volatile十三、单例模式十四、CAS十五、原子引用十六、各种锁的理解
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 873
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
10.JUC线程高级-线程八锁
weixin_34004576的博客
09-05 113
所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下: 1.两个普通同步方法，两个线程，标准打印，结果：one two public class TestThread8Monitor { public static void main(String[]...
java多线程 线程八锁
ankan7400的博客
02-05 118
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
GUC-10 线程八锁
weixin_30932215的博客
03-05 163
/* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two * 3. 新增普通方法 getThree() , 打印? //three one two * 4. 两个普通同步...
11、JUC--线程八锁
weixin_33923148的博客
05-02 98
线程八锁 • 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用　　其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻　　内，只能有唯一一个线程去访问这些synchronized方法 • 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的　　synchronized方法 • 加个普通方法后发现和同...
【Java高级】JUC之线程八锁案例分析
阿杰
05-02 309
class Phone{ public static synchronized void sendEmail()throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("****sendEmail"); } public synchronized void sendSMS...
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
java并发编程-AQS和JUC实战
最新发布
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java内存模型和线程同步机制。 **可重入锁与可重入性** 可重入锁允许同一个线程反复进入它已经拥有的锁所保护的代码段。在Java中，...
juc-线程八锁
weixin_39535692的博客
10-27 357
松岛枫
JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况
姜皓的博客
05-10 313
多线程锁 -- 演示锁的八种情况
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
LXYDSF的博客
06-13 363
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
JUC多线程编程八锁你都知道了吗？关于锁的八个问题
不会编程的派大星的博客
04-21 140
关于锁的八个问题—八锁 前面的文章中留下一个疑问，到底什么是锁，锁到底锁的是谁？ 这里我们就用打电话和发短信的例子来距离说明八锁问题—>锁的是对象方法的调用者或者Class模板（.class） 1、标准情况下，两个线程先打印 发短信还是 先打印 打电话？ import java.util.concurrent.TimeUnit; /** * @program: juc * @description * @author: 不会编程的派大星 * @create: 2021-04-21 12:42
JUC并发编程（二）-- 线程八锁
书生灬今天不吃饭的博客
11-28 217
JUC并发编程（二）-- 线程八锁1、两个线程，分别调用同一个资源类的两个方法，哪个先执行？2、两个线程A和B，分别调用同一个资源类的两个方法，A线程休眠3秒，哪个线程先执行？3、非同步方法是否会受到对象锁的影响？4、同一个类中两个对象的同步方法时候会相互影响？5、同一个类中的两个静态同步方法时候会互相影响？6、同一个类中，一个静态同步方法和一个普通同步方法，会相互影响吗？ 线程八锁，指的就是线程中关于锁的八个问题，用来分辨清晰Java多线程中，锁究竟锁的是什么。 以下 5 和 6 两个问题分别是两个子问题
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2100
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
JUC详解-4-八锁现象彻底理解锁
baidu_38126306的博客
11-11 240
JUC详解 -> 八锁现象 如何判断锁的是谁？ import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 * 2.sendSms()延迟4秒，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 */ public class Test01 { public static void main(String[] args)
面试必备系列JUC(6)--八锁详解
欲问君有几多愁的博客
09-06 639
文章目录前言一、锁总述1.1. 乐观锁 VS 悲观锁2.读入数据总结 前言 最近有读者在后台私信，让我讲讲java里常见的锁，第一次被读者提要求，还是很高兴的，查阅了一些资料，尽量将常见的锁的概念讲的清清楚楚，希望读者读后，能对8锁有个清晰的认知！ 今天给大家介绍我一个很有趣的好友，秃头，干瘦，可能喜欢女生的广叔！！ 长相略微显老（认识五年了，颜值一直在40岁上下） 提示：以下是本篇文章正文内容，下面案例可供参考 一、锁总述 广叔：令狐兄，你知道java中常见的锁吗？ 令狐冲：当然知道，话说当年java
JUC并发编程——通过八锁现象更好的理解 Synchronized
万里顾一程的博客
09-15 143
文章目录JUC并发编程——八锁现象 JUC并发编程——八锁现象 八锁现象 八锁现象，其实就是关于锁的八个问题，通过八个问题，逐渐加深对锁的认识，为了方便演示，这里全部用synchronized。 案例一：两个synchronized 同步方法 + 两个线程 + 一个方法调用者 package com.cheng.Lock8; public class Test1 { public static void main(String[] args) { BackHome back
Java JUC并发编程实例：守护线程与Synchronized锁
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

收破烂的小熊猫~

你的鼓励将是我创造最大的东西~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值