八锁现象

最新推荐文章于 2023-07-24 09:30:03 发布
最新推荐文章于 2023-07-24 09:30:03 发布
阅读量88 收藏 1
点赞数 2
分类专栏： 多线程 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jhh415061344/article/details/117565004
版权

1. 问题:两个线程是先打印 发短信 还是 打电话

1.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

}

class Phone {

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

    public synchronized void call() {
        System.out.println("打电话");
    }
}

1.2 输出 ：

发短信
打电话

1.3 结论 ： 

并不是像表面那样看起来从上到下顺序执行的，而是因为有锁的存在，而此时synchronized 锁的对象是方法的调用者，也就是phone，而两个方法用的是同一个锁，也即谁先拿到谁执行！

 2. 问题:两个线程是先打印 发短信 还是 打电话（注：发短信的方法睡3秒）

2.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

}

class Phone {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

2.2 输出

发短信
打电话

2.3 结论 

A线程抱着锁去睡了3秒，醒来后发短信，完成后释放锁，接着B线程拿到锁，去打电话。对于同一把锁，谁先拿到谁先执行。

3. 两个线程是先打印 发短信 还是 打电话（注：发短信的方法睡3秒，打电话去掉synchronized 变成普通方法）

3.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

}

class Phone {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public void call() {
        System.out.println("打电话");
    }
}

3.2 输出

打电话
发短信

3.3 结论

 打电话时普通方法，不受锁的影响

4. 两个线程是先打印 发短信 还是 打电话（注：2个对象,2个同步方法，发短信的方法睡3秒）

4.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

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

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

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

}

class Phone {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

 4.2 输出

打电话
发短信

4.3 结论 

两个对象，两个调用者，也即是两把锁，按时间执行，发短信的方法睡了3秒，所以先输出打电话

5.两个线程是先打印 发短信 还是 打电话（注：1个对象,2个静态同步方法，发短信的方法睡3秒）

5.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

}

class Phone {

    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

5.2 输出

发短信
打电话

5.3 结论 

因为static的关系，此时锁的对象是Phone的class对象，而class是全局唯一的，只有1个，故用的是同一把锁

6.两个线程是先打印 发短信 还是 打电话（注：2个对象,2个静态同步方法，发短信的方法睡3秒）

6.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

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

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

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

}

class Phone {

    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public static synchronized void call() {
        System.out.println("打电话");
    }
}

6.2 输出

发短信
打电话

6.3 结论 

即使是两个不同的对象，但因为static的关系，此时锁的对象仍是Phone的class对象，而class是全局唯一的，只有1个，故用的是同一把锁

7.两个线程是先打印 发短信 还是 打电话（注：1个对象,1个静态同步方法发短信，1个同步方法打电话，发短信的方法睡3秒） 

7.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

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

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

}

class Phone {

    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

7.2 输出

打电话
发短信

7.3 结论 

静态的同步方法（发短信）锁的是 Class 类模板， 普通的同步方法（打电话）锁的是调用者，而发短信睡了3秒，故先输出打电话

8.两个线程是先打印 发短信 还是 打电话（注：2个对象,1个静态同步方法发短信，1个同步方法打电话，发短信的方法睡3秒）

8.1 代码

package com.lock;


import java.util.concurrent.TimeUnit;

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

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

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

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

}

class Phone {

    public static synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    public synchronized void call() {
        System.out.println("打电话");
    }
}

8.2 输出

打电话
发短信

8.3 结论 

跟7的结论一样，静态的同步方法（发短信）锁的是 Class 类模板， 普通的同步方法（打电话）锁的是调用者，而发短信睡了3秒，故先输出打电话

 

天忘寻痕
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
04-06
此外，Redisson还实现了公平锁，保证了等待锁的线程按照请求顺序获取锁，避免饥饿现象。 在实际的测试项目代码中，你可能需要关注以下几个方面： 1. 锁的创建和获取：使用`RLock`接口的`lock()`方法获取锁，确保...
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1499
synchronized关键字到底锁的是谁？
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 731
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
八锁现象彻底理解锁
LIAO_YUANLONG的博客
12-17 684
如何判断锁的是谁？知道什么是锁？ 1.标准情况下，两个线程先打印发短信还是打电话？—》发短信 2.sendMag延迟四秒，两个线程先打印发短信还是打电话？—》发短信 package com.liao.Lock8; import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？---》发短信 * 2.sendMag延迟四秒，两个线程先打印发短信还是打电话？---》发短信 */ public cla
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1415
JUC 八锁现象 Java并发编程
【Java多线程】一篇文章彻底解锁八锁现象（狂神说Java）
frozenpenguin的博客
07-12 1455
最近在看狂神老师的JUC课程时遇到了八锁问题，看的时候懵懵懂懂，于是在第二天又看了一遍，并记录了本次笔记，希望对大家有所帮助。时间匆忙的话一定要看文章最后的总结部分！
synchronized八锁现象理解
lczcxyit的博客
04-19 1845
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronized：锁的对象到底是谁？快速理解八锁现象
saya21的博客
07-24 909
通过总结和例子帮助快速理解八锁现象。
Java的8锁现象
weixin_56018532的博客
09-09 540
Java的8锁现象
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8025
深入理解JUC的8锁现象
JUC（4）八锁现象（关于锁的8个问题）
wang_luwei的博客
11-23 1515
文章目录一、问题1与问题2二、 问题3与问题4三、 问题5与问题6四、问题7与问题8五、小结 锁是什么，如何判断锁的是谁? 8锁，就是关于锁的8个问题 一、问题1与问题2 问题一：标准情况下，下面的AB两个线程哪个先执行？ 发消息？ or 打电话？ 问题一答：总是先执行 发消息send() 再执行打电话call()。（为什么？ 如果你认为是顺序在前？ 这个答案是错误的！） 问题二：让send() 方法休眠4s，此时AB两个线程哪个先执行？ 问题二答：还是先执行 发消息send() 再执行打电话
8八年级物理上册第二章 声现象综合课后练习二 .doc
11-29
标题提到的是"8八年级物理上册第二章 声现象综合课后练习二 .doc"，这表明我们讨论的主题是初中物理的声学部分，特别是关于声现象的一些综合练习题目。 【描述解析】 描述中只给出了文件的名称，没有额外的信息。...
苏教版八年级物理上册-声现象单元检测试题-.doc
10-06
标题和描述均指向一个针对八年级学生的物理试题，具体是"声现象"单元的检测试题。试题涵盖了声音的基本概念、声波的特性、声音的传播方式、声音的应用以及噪声控制等多个知识点。 【知识点详细说明】 1. **声音的...
苏教版八年级物理（上册）_声现象单元检测试题.doc
09-30
【标题】和【描述】提及的是一个针对八年级学生的物理检测试题，主要涉及声现象这一主题。试题包括选择题、填空题和实验题，旨在检验学生对声音的产生、传播、特性以及相关应用的理解。 【部分知识点】： 1. **...
（苏）版八年级物理上册声现象单元检测试题(卷）.doc
09-29
【标题】: "（苏）版八年级物理上册声现象单元检测试题(卷）" 【描述】: "此文档包含了（苏）版八年级物理上册关于声现象的单元检测试题" 【标签】: "文档" 【部分内容】 这份声现象单元检测试题主要考察学生对...
基于ssm和vue的 家庭理财系统源码 家庭理财系统代码（高分毕设项目源码）
08-23
1. 家庭理财系统代码说明：经导师指导并认可通过的98分毕设项目代码。 2.适用对象：本代码学习资料适用于计算机、电子信息工程、数学等专业正在做毕设的学生，需要项目实战练习的学习者，也适用于课程设计、期末大作业。 3.技术栈：前端是vue，后端是ssm，项目代码都经过严格调试，代码没有任何bug！ 4. 作者介绍：大厂码农，java领域创作者，阿里云开发社区乘风者计划专家博主，专注于大学生项目实战开发，文章底部有博主联系方式，更多优质系统、项目定制请私信。 5. 最新计算机软件毕业设计选题大全: https://blog.csdn.net/weixin_45630258/article/details/135901374
大数据湖体系规划与建设方案.pdf
08-23
大数据湖体系规划与建设方案.pdf
Kafka多租户消费：构建高效、安全的分布式消息处理
08-23
Kafka是一个分布式流处理平台，最初由LinkedIn公司开发，后来成为Apache软件基金会的一个顶级项目。Kafka主要用于构建实时数据管道和流处理应用程序。它能够高效地处理高吞吐量的数据流，并且具有很好的可扩展性、容错性和持久性。 以下是Kafka的一些关键特性： 1. **分布式系统**：Kafka通过多个代理（Broker）组成集群，支持数据的分布式存储和并行处理。 2. **发布-订阅模型**：Kafka使用发布-订阅模式，生产者（Producer）将消息发布到主题（Topic），消费者（Consumer）从主题订阅消息。 3. **高吞吐量**：Kafka设计用于处理高吞吐量的数据流，每秒可以处理数百万条消息。 4. **持久性**：Kafka将数据存储在磁盘上，支持数据的持久化，即使在系统故障的情况下也不会丢失数据。 5. **可扩展性**：Kafka可以通过增加更多的Broker来水平扩展，以处理更大的数据量。 6. **容错性**：Kafka支持数据的副本（Replication），确保数据的高可用性和容错性。 7. **实时性**：Kafka设计用于实时数据处理
containerd的配置文件
最新发布
08-23
【kubernetes】环境准备及K8S安装【最新完整版】 1./etc/containerd/ 2.更改真实对应的harbor镜像地址ip
数据库并发控制：意向锁与事务调度
在《AnIntroductiontoDatabaseSystem》的第八章并发控制中，作者详细探讨了并发控制的不同方式及其带来的挑战。首先，介绍三种主要的并发执行模式：事务串行执行、交叉并发和同时并发，每种模式都有其优缺点，如串行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值