多线程8锁问题

已于 2023-01-31 23:44:02 修改
阅读量186 收藏
点赞数 1
分类专栏： JUC 多线程 文章标签： java
于 2021-04-29 15:47:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46955971/article/details/116270648
版权

多线程8锁


Java的8锁问题链接

8锁即8个关于锁执行顺序的问题

解决问题前，首先需要明白的是 synchronized 只会锁两样东西，一样是调用的对象，一样是Class

一个对象里面如果有多synchronized方法，某一时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一时刻内，只能唯一一个线程去访问这些synchronized方法。锁的是当前对象this，被锁定后，其它的线程不能进入到当前对象的其它的synchronized方法

synchronized实现同步锁的基础：Java中的每一个对象都可以作为锁。
具体表现为以下3种形式：
对于普通同步方法，锁是当前实例对象
对于静态同步方法，锁是当前类的class 对象。
对于同步方法块，锁是synchronized括号里配置的对象。

问题一： 标准访问，请问先打印邮件还是短信?

class Phone {
    public synchronized void sendEmail() throws Exception {
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(1000);

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

判断执行顺序，先判断什么被锁了，这里synchronized锁的是Phone对象new出来的phone，因为先调用了sendEmail()睡1秒后调用的sendSMS()，sendSMS()需要等到sendEmail()释放锁后才会执行

输出结果
------sendEmail
------sendSMS

问题二：邮件暂停4秒钟，请问先打印邮件还是短信？

class Phone {
    public synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(100);

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

该情况其实和问题一 一样，synchronized锁的是Phone对象new出来的phone，当调用sendEmail()时，phone被锁，而程序不受sendEmail()内睡的影响继续执行，在调用sendSMS()的时候因为phone被锁导致等待，当sendEmail()执行完后sendSMS()瞬间执行

输出结果
------sendEmail
------sendSMS

问题三：新增一个普通方法hello(),请问先打印邮件还是hello?

class Phone {
    public synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }

    public void hello(){
        System.out.println("------hello");
    }

}

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

        Thread.sleep(100);

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

程序执行在sendEmail()中锁了fun并在方法中睡4秒，外部在睡1秒后调用hello()，因为无锁因此直接执行

输出结果
------hello
------sendEmail

问题四：两部手机，请问先打印邮件还是短信？

class Phone {
    public synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }
    
}

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

        Thread.sleep(100);

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

程序调用sendEmail()时锁住phone，外部睡1秒后调用sendSMS()时锁phon1，互不影响

输出结果
------sendSMS
------sendEmail

问题五：两个静态同步方法，同一部手机，请问先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public static synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(100);

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

这里多了静态static，因此此时锁的东西改变了，sendEmail()和sendSMS()都是锁的Phone这个class，程序在执行sendEmail()时锁住Phone class，睡1秒后调用sendSMS()，sendSMS()等待sendEmail()内睡完释放锁后再执行

输出结果
------sendEmail
------sendSMS

问题六：两个静态同步方法，两部手机，请问先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public static synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(100);

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

要注意的是，不管现在new结果对象，调用方法后锁的都是Phone class，sendSMS()会被sendEmail()阻塞

输出结果
------sendEmail
------sendSMS

问题七：一个静态的同步方法，一个普通同步方法，1部手机，请问先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(100);

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

同样只要确认锁的是不是一个东西就知道会不会阻塞，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phone

输出结果
------sendSMS
------sendEmail

问题八：1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？

class Phone {
    public static synchronized void sendEmail() throws Exception {
        try {
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("------sendEmail");
    }
    public synchronized void sendSMS() throws Exception {
        System.out.println("------sendSMS");
    }

}

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

        Thread.sleep(100);

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

解题跟问题七一致，调用sendEmail()时阻塞的是Phone class，调用sendSMS()时阻塞的是phon1

输出结果
------sendSMS
------sendEmail
LeslieWongJie?
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程8锁（详细）
cookies___的博客
05-13 1333
线程8锁，超详细。 1.两个线程调用同一个对象的两个同步方法 结果是：one two 分析：第一个线程调用了getOne方法，获得了number对象的互斥锁，第二个线程等待第一个线程的getOne执行 完毕后，再执行getTow方法 2. 结果： 休眠1秒钟 后 one two 分析：线程1的Thread.sleep不释放互斥锁 3.新增一个线程调用新增的一个普通方法 结果是：three 休眠1秒 one two 分析：没有synchronized修饰的方法，线程调用时是和锁无关的 4.两个线程调用两个
stm32单片机多线程实例
12-03
8. **设备驱动开发**：在多线程环境中，如何编写和管理设备驱动，确保驱动在不同线程间正常工作。 9. **调试与性能优化**：学习使用RT-Thread提供的调试工具进行问题定位，以及如何通过优化线程调度、减少内存开销...
Java并发之线程八锁
fyphome
01-30 1679
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
线程8锁问题
prefect_start的博客
03-17 233
1、线程8锁问题 1.1、代码 /* * * 资源类 */ class Resource { public static synchronized void sendEmail() { try { TimeUnit.SECONDS.sleep(3); System.out.println("*******sendEmail"); } catch (InterruptedException e) {
线程八锁问题
小鲁蛋的博客
02-03 344
考察内容：synchronized 锁住的是哪个对象。
【Java并发编程] 线程八锁问题
小新的博客
01-12 1240
生活总会有惊喜，谁知道下一秒会发生什么呢
Java多线程中Lock锁的使用总结
08-18
Java中的Lock锁是用于解决多线程访问共享资源时的同步问题的。Lock锁可以分为两种：独占锁和共享锁。独占锁允许多个线程访问同一个资源，但是同一时刻只能有一个线程可以访问该资源。共享锁允许多个线程同时访问同一...
QT中sqlite多线程操作4个注意问题
02-26
然而，当在多线程环境中使用SQLite时，需要注意一些关键问题以确保数据的安全性和一致性。以下是四个重要的考虑因素： 1. **线程安全**： SQLite本身并不提供完全的线程安全，这意味着在不同线程中并发访问数据库...
java多线程-读写锁原理
09-01
在Java多线程编程中，读写锁是一种高级的同步机制，它允许多个线程同时读取共享资源，但只允许一个线程写入。这种锁的引入提高了并发性能，特别是在读操作远多于写操作的场景下。Java 5开始，`java.util.concurrent....
详解Java多线程编程中互斥锁ReentrantLock类的用法
09-02
在Java多线程编程中，ReentrantLock提供了更灵活的锁管理机制，相比synchronized，它允许更细粒度的控制，并且提供了更多的同步原语。以下是一些使用ReentrantLock的关键点： 1. **可重入性**：ReentrantLock允许一...
java多线程详解，线程池原理，8种锁,java内存模型......
01-25
首先希望大家喜欢我制作的文档，如果文档中有什么误解的地方，望告诉一下，5分是也不多，是系统默认的，那么就5分咯，java多线程详解，线程池原理，8种锁,java内存模型......
java8的锁
MXqihang的博客
04-17 715
java8锁 文章目录java8锁CAS算法 Compare And Swap 比较与交换自旋锁 VS 适应性自旋锁自旋锁unsafe自适应自旋锁无锁->偏向锁->轻量锁->重量锁无锁偏向锁轻量级锁重量级锁公平锁、非公平锁公平锁可重入锁、非可重入锁可重入锁非可重入锁共享锁、独享锁底部 同步资源上锁 锁住 ： 悲观锁 不锁住： 乐观锁 锁同步资源，线程状态 阻赛 不阻赛： 自旋锁、适应性自旋锁 多线程竞争同步资源的流行细节 不锁资源，多线程中只有一个修改成功，其他线程重试：无锁
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7986
深入理解JUC的8锁现象
多线程8锁问题 详解
weixin_45631253的博客
04-08 191
多线程8锁问题详解 1.案例准备 首先我们准备一个资源类，在资源类定义两个同步方法，来测试在不同的访问方式下， 会产生什么样的结果。代码如下： class MyPhone { public synchronized void sendEmail() { // 发送邮件 System.out.println("----sendEmail"); } // 发送短信 public synchronized void sendMS() {
Java 多线程 线程8锁（含示例代码）
weixin_55871070的博客
04-17 704
以下内容根据视频https://www.bilibili.com/video/BV1vE411D7KE?p=6学习整理 1.标准访问 class Phone{ public synchronized void sendEmail() throws Exception { System.out.println("**sendEmail"); } public synchronized void sendSMS() throws Exception { ...
Java八锁现象
s17856147699的博客
08-30 269
Java八锁现象
Java源码学习之并发编程-锁-Java中8种锁机制
weixin_37627646的博客
07-14 791
​ 在ReentrantLock中包含了公平锁和非公平锁两种锁。 如果你用默认的构造函数来创建ReentrantLock对象，默认的锁策略就是非公平的。 ​ 多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。 优点：所有的线程都能得到资源，不会饿死在队列中。 缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大。 公平锁图示： 图示1： ​ 咱们重新回到第一张图，就是线程1刚刚释放锁之后，线程2还没来得及重新加锁的那个状
Java实现经典八锁问题
05-08 525
🚀在 Loki的个人博客，阅读体验更佳 下面将通过经典的8锁问题，认清锁原理
java面试第二部分：多线程与锁
最新发布
03-17
“Java面试第二部分：多线程与锁，涵盖了锁升级、虚拟机锁优化、锁的实现原理、线程安全、可重入锁、线程池的实现等内容，旨在帮助求职者准备Java面试。” 在Java编程中，多线程和锁机制是核心概念，对于系统性能...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值