JUC并发编程-8锁现象

最新推荐文章于 2023-06-12 16:08:46 发布
最新推荐文章于 2023-06-12 16:08:46 发布
阅读量309 收藏 2
点赞数 2
分类专栏： Java核心 文章标签： java 多线程 并发编程 8锁现象 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45240169/article/details/111361790
版权

文章目录


首先感谢下 B站的狂神，在这里第一次听到“8锁现象”，并弄懂了“锁到底锁的是谁”。
8锁现象，实际对应的就是8个问题。
掌握了这8个问题后：可以清楚判断锁的是谁！知道什么是锁，锁到底锁的是谁！

锁方法的调用者

问题一

如下代码：标准情况下，下边两个线程先打印 发短信 还是 打电话 ？

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.seedMsg();}, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();}, "B").start();
    }
}
class Phone{
    public synchronized void seedMsg(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出发短信，再输出打电话。
思考下为什么？
如果你是认为线程A先被调用的，那是不对的。现在抱着这个想法，再去思考下面的代码：

问题二

如下代码：将发短信的方法sleep四秒，两个线程先打印 发短信 还是 打电话 ？

public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{phone.seedMsg();}, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.call();}, "B").start();
    }
}
class Phone{
    public synchronized void seedMsg(){
    	try {TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：还是先输出发短信，再输出打电话。
思考下为什么？
首先知道 锁住的对象是谁？因为 synchronized 加在方法上，所以锁的对象是方法的调用者。如上示例：两条线程执行的方法调用者是不是都是new出来的phone 对象啊，所以两个方法用的是同一个锁，谁先拿到谁先执行！

通俗解释：
phone对象就是方法的调用者，也就是手机，它可以打电话和发短信。
现在有两个人线程A 和线程B，他们一个想打电话，一个想发短信。
线程A，先拿到锁（也就是手机），抱着锁（手机）睡了4秒。 线程B肯定拿不到锁（手机），需要等待。所以最终A睡了4秒醒了就执行输出了发短信，让后释放掉锁，线程B才能拿到锁执行输出打电话

问题三

如下代码：Phone类中新增一个普通方法hello()，线程B调用，那么两个线程先打印 发短信 还是 先输出hello？

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        new Thread(()->{ phone.seedMsg();}, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone.hello();}, "B").start();
    }
}
// 手机
class Phone2{
    //同步方法
    public synchronized void seedMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //同步方法
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出了hello，再输出发短信。
思考下为什么？
因为hello()方法，是普通方法，根本不受锁的影响。线程B执行hello方法，不需要获取锁就能执行，所以也不必等待A执行完释放锁。

问题四

如下代码：创建两个phone对象，线程调用不同对象的方法，那么两个线程先打印 发短信 还是 打电话？

public class Test2 {
    public static void main(String[] args) {
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        // 线程A，
        new Thread(()->{phone1.seedMsg();}, "A").start();
        // 1秒延迟
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B，人
        new Thread(()->{ phone2.call();}, "B").start();
    }
}

// 手机
class Phone2{
    //同步方法
    public synchronized void seedMsg(){
        // 4秒延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //同步方法
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出了打电话，再输出发短信。
思考下为什么？
还是那句话，synchronized用在方法上，那么锁的是方法的调用者。现在有两个调用者，就相当于你用你的手机发短信，我用我的手机打电话，所以互不影响啊。

锁class对象

问题五

如下代码：将方法变为静态同步方法，那么两个线程先打印 发短信 还是 打电话？

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        // 线程A，
        new Thread(()->{phone.seedMsg();}, "A").start();
        // 1秒延迟
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B，
        new Thread(()->{phone.call();}, "B").start();
    }
}
// 手机
class Phone3{
    // 静态同步方法
    public static synchronized void seedMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 静态同步方法
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出发短信，再输出打电话。
思考下为什么？
如果你的理解还是“synchronized用在方法上，那么锁的是方法的调用者”，那么就错了。别忘了方法用static修饰了。
static静态方法，在类初始化的时候，就加载到内存中生成了class对象。要知道java中所有的类，只有一个class对象，
这个class对象是唯一的，所以锁静态方法，其实锁的就是class对象。

问题六

如下代码：方法还是静态同步方法，但是我们创建两个对象来调方法，那么两个线程先打印 发短信 还是 打电话？

public class Test3 {
    public static void main(String[] args) {
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{phone1.seedMsg();}, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{ phone2.call();}, "B").start();
    }
}
// 手机
class Phone3{
    // 静态同步方法
    public static synchronized void seedMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 静态同步方法
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出发短信，再输出打电话。
上边已经说了，锁静态方法，其实锁的就是class对象，java中所有的类，只有一个class对象，所以无论几个对象，使用的锁都是一样的。

同时锁方法的调用者和class对象

问题七

如下代码：一个是静态同步方法，一个普通同步方法，那么两个线程先打印 发短信 还是 打电话？

public class Test4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        new Thread(()->{phone1.seedMsg();}, "A").start();
        // 1秒延迟
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 线程B，人
        new Thread(()->{phone1.call();}, "B").start();
    }
}
// 手机
class Phone4{
    // 静态同步方法
    public static synchronized void seedMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 普通同步方法
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：先输出打电话，再输出发短信。
思考下为什么？
这还用想？两个锁，锁的东西都不一样啊，一个锁class对象，一个锁Phone4 对象，两个都是互不影响的。

问题八

如下代码：在上面的基础上，增加一个对象，两个对象分别调用静态和非静态的同步方法，那么两个线程先打印 发短信 还是 打电话？

public class Test4 {
    public static void main(String[] args) {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();
        new Thread(()->{phone1.seedMsg();}, "A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{phone2.call();}, "B").start();
    }
}
// 手机
class Phone4{
    // 静态同步方法
    public static synchronized void seedMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    // 普通同步方法
    public synchronized void call(){
        System.out.println("打电话");
    }
}

相信到这里已经能肯定回答出“先输出打电话，再输出发短信了”。
不要怀疑，以为增加了一个对象，就会有什么影响？只要记住静态同步方法锁class对象，普通同步方法锁调用者就行。两个锁 锁住的东西不一样，所以互不影响的。

上一篇：JUC-Lock锁与Synchronized
下一篇：并发编程下如何使用安全的集合

凹凸曼蓝博one
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
java并发编程-AQS和JUC实战
04-29
java并发包详解，condition重入锁；Semaphore信号量；ReadWriteLock读写锁；CountDownLatch计时器；CyclicBarrier循环栅栏； 重⼊锁可以完全替代synchronized关键字。在JDK5.0的早期版本中，重⼊锁的性能远远好于 ...
【JUC中的 “8锁现象” 】 —— 每天一点小知识
仰望天空，妳我亦是行人.
06-12 525
💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁......
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1433
synchronized关键字到底锁的是谁？
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7986
深入理解JUC的8锁现象
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 722
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC_8锁问题
我认不到你的博客
09-20 165
“八锁”的含义：就是八个关于锁的问题
JUC并发编程视频教程
11-28
* 颠覆一些你以为"正确"的认知，纠正其它同类视频的错误* 100+ 张手绘图 & 流程图，帮助你形成正确的"多线程世界观"* 以知识点为主线、穿插讲解"应用"，"原理"和"多线程设计模式"，多维度学懂并发主讲内容第一章：...
根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档
09-21
1、根据尚硅谷JUC并发编程（对标阿里P6-P7）视频自己整理的pdf文档 2、包含源码 视频地址：https://www.bilibili.com/video/BV1ar4y1x727/?p=1&vd_source=c634d163b940964d44747b4c3976117b 参考资料：...
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2083
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1397
JUC 八锁现象 Java并发编程
8锁 现象
DaDaguai001的博客
07-01 387
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
八锁现象的介绍及代码分析
weixin_43786099的博客
08-27 499
好的，前文我们简单的讲述了一下synchronized 锁的三种应用方式，他们是： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 好的我们知道了有这三种方式，但是他们三种不同的应用方式又有着什么不一样的区别呢，难道说还是只是位置不一样，其他作用都是一样的，那肯定不是的啦，他们的锁对象都是不一样的，下面我们就
Java中的八种锁
chou_out_man的博客
11-16 1468
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
8锁现象
c19990515的博客
02-09 147
5、8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ /** * 8锁，就是关于锁的8个问题 * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone();
再探JUC-8锁现象
qq_21793443的博客
03-21 427
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
跟南桑学JUC第三节课（8锁）
ZN175623的博客
10-10 100
>关于8锁的问题 >list的线程安全问题和解决措施
JUC代码演示 Java多线程并发
最新发布
05-03
本资源主要介绍Java并发编程中的Java.util.concurrent (JUC) 库，以及多线程和同步机制。首先，我们探讨了用户线程与守护线程的区别。在Java中，用户线程（非守护线程）是主线程执行的主要工作单元，它们不会自动随...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值