Lock 8锁问题

已于 2022-06-23 11:15:29 修改
阅读量185 收藏 1
点赞数
分类专栏： java juc 文章标签： java 开发语言
于 2022-06-22 16:57:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71149992/article/details/125411729
版权
juc 同时被 2 个专栏收录
16 篇文章 0 订阅
订阅专栏
java
14 篇文章 0 订阅
订阅专栏

最初资源类

class Phone //资源类
{
    public  synchronized void sendEmail()
    {
        System.out.println("-----sendEmail");
    }

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

}

题目

/**
 * 题目：谈谈你对多线程锁的理解,8锁案例说明
 * 口诀：线程   操作  资源类
 * 8锁案例说明：
 * 1 标准访问有ab两个线程，请问先打印邮件还是短信
 * 2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信
 * 3 添加一个普通的hello方法，请问先打印邮件还是hello
 * 4 有两部手机，请问先打印邮件还是短信
 * 5 有两个静态同步方法，有1部手机，请问先打印邮件还是短信
 * 6 有两个静态同步方法，有2部手机，请问先打印邮件还是短信
 * 7 有1个静态同步方法，有1个普通同步方法,有1部手机，请问先打印邮件还是短信
 * 8 有1个静态同步方法，有1个普通同步方法,有2部手机，请问先打印邮件还是短信**/

第一题

1 标准访问有ab两个线程，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public  synchronized void sendEmail()
    {
       
        System.out.println("-----sendEmail");
    }

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

  
}

测试

public class Lock8Demo
{
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();


        new Thread(() -> {
            phone.sendEmail();
        },"a").start();

        //暂停毫秒,保证a线程先启动
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            phone.sendSMS();
        },"b").start();
    }
}

结果

-----sendEmail
-----sendSMS
 

第二题

2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public  synchronized void sendEmail()
    {
        try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("-----sendEmail");
    }

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


    

}

测试

public class Lock8Demo
{
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();


        new Thread(() -> {
            phone.sendEmail();
        },"a").start();

        //暂停毫秒,保证a线程先启动
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            phone.sendSMS();
        },"b").start();
    }
}

结果

-----sendEmail
-----sendSMS

第三题

3 添加一个普通的hello方法，请问先打印邮件还是hello

资源类

class Phone //资源类
{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }


    public void hello() {

        System.out.println("-----hello");
    }

}

测试

public class Lock8Demo
{
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();


        new Thread(() -> {
            phone.sendEmail();
        },"a").start();

        //暂停毫秒,保证a线程先启动
        try { TimeUnit.MILLISECONDS.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); }

        new Thread(() -> {
            phone.hello();
        },"b").start();
    }
}

结果

-----hello
-----sendEmai

 第四题

4 有两部手机，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

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




}

测试

public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        // 第一个手机
        Phone phone = new Phone();

        // 第二个手机
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendSMS();
        }, "b").start();
    }
}

结果

-----sendSMS
-----sendEmail

 第五题

5 有两个静态同步方法，有1部手机，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("-----sendSMS");
    }



}

测试

public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();


        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();
    }
}

结果

-----sendEmail
-----sendSMS

 第六题

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

资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

    public static synchronized void sendSMS() {
        System.out.println("-----sendSMS");
    }




}

测试


public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendSMS();
        }, "b").start();
    }
}

结果

-----sendEmail
-----sendSMS

 第七题

7 有1个静态同步方法，有1个普通同步方法,有1部手机，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

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



}

测试


public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

    

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.sendSMS();
        }, "b").start();
    }
}

结果

-----sendSMS
-----sendEmail

 第八题

8 有1个静态同步方法，有1个普通同步方法,有2部手机，请问先打印邮件还是短信

资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

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



}

测试


public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

        Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.sendSMS();
        }, "b").start();
    }
}

结果

-----sendSMS
-----sendEmail

其余问题

9  有1个静态同步方法，有1个普通方法,有1部手机，请问先打印邮件还是hello

 资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

    public void hello() {

        System.out.println("-----hello");
    }


}

测试


public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

       

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.hello();
        }, "b").start();
    }
}

结果

-----hello
-----sendEmail

10  有1个静态同步方法，有1个普通方法,有2部手机，请问先打印邮件还是hello

 资源类

class Phone //资源类
{
    public static synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("-----sendEmail");
    }

    public void hello() {

        System.out.println("-----hello");
    }


}

测试


public class Lock8Demo {
    public static void main(String[] args)//一切程序的入口
    {
        Phone phone = new Phone();

       Phone phone2 = new Phone();

        new Thread(() -> {
            phone.sendEmail();
        }, "a").start();

        //暂停毫秒,保证a线程先启动
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone2.hello();
        }, "b").start();
    }
}

结果

-----hello
-----sendEmail

注意

 阿里巴巴开发手册提到

原理

第一题和第二题

因为使用的是同一个对象锁 ，只要一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了， 其它的线程都只能等待，换句话说，某一个时刻内，只能有唯一的一个线程去访问这些synchronized方法

锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的synchronized方法



第三题

 一个对象  加个普通方法后发现和同步锁无关  所以先普通方法先执行

第四题

有2个对象，所以有2个不同的对象锁，情况会改变

第五题 和第六条

一个对象 或2个对象，有1个或2个不同的对象锁，但是 2个同步方法均都是 static 修饰的 所以这2个静态同步方法是属于 Class 的方法 ， 对于静态同步方法，锁的是当前类的为为一个模板Class对象，如Phone.class唯一的一个模板。所以会按照 谁先调用的静态同步方法谁就先执行。

第七题和第八题

一个对象 或2个对象，有1个或2个不同的对象锁 ，但是 有一个 静态同步方法 和一个普通同步方法 ，所以静态同步方法，锁的是当前类的为为一个模板Class对象，而普通同步方法是锁的是当前对象this 即对象锁，所以 这两把锁是两个不同的对象，所以静态同步方法与普通同步方法之间是不会有竞态条件的 但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁。

至于第九题和第十题 

一个对象 或2个对象，有1个或2个不同的对象锁，但是 有一个 静态同步方法 和一个普通方法，

而普通方法与同步锁无关，所以普通先执行

总结

同一对象：

 同一对象访问不同的同步锁，是按照顺序执行

同一对象访问同步锁与普通方法，是执行普通方法

同一对象访问不同静态同步锁，按照谁先调用谁先执行

同一对象访问一个静态同步锁，一个同步锁，先执行同步锁

多个对象

多个对象访问不同同步锁，按照顺序执行 

不同对象访问不同静态同步锁，按照谁先调用谁先执行

不同对象访问一个静态同步锁，一个同步锁，先执行同步锁即先出同步锁在出静态同步锁

帅气的喵喵
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1509
关于8锁问题 1、两个同步方法，一个对象调用。乌龟先跑？还是兔子先跑？ 答：乌龟先跑 /** * @Description: * @Package: com.cp.lock8 * @ClassName: Lock2 * @Author: cp * @Date: 2020/5/18 21:50 * @Version: 1.0 */ public class Lock1 { public static void main(String[] args) { Animal1
lock8锁详解现象深入理解
m0_50146072的博客
09-02 525
8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ 深刻理解我们的锁 1、标准访问，先发送邮件还是短信 Email 锁是this 2、暂停3S在邮件方法里，先发送邮件还是短信 Email 锁是this 3、新增hello普通方法，先发送邮件还是hello hello 加个普通方法后发现和同步锁无关 4、有两部手机，先发送邮件还是短信 EMS 锁是两个不同的this，但是需要隔4s才能发送email 5、两个静态同步方法，有一部手机，先发送邮件
JUC-关于Lock的8锁问题
Watson24的博客
01-12 173
JUC-Lock的8锁问题 Lock的8锁问题，即关于锁的8个问题，以下共展示了8种情况下的8个问题，更有利于理解锁的这个概念 标准情况下，两个线程先打印发短信还是打电话？ import java.util.concurrent.TimeUnit; public class Lock1 { public static void main(String[] args) { Phone1 phone = new Phone1(); new Thread(()-&gt
Lock8锁
张鑫的博客
08-27 682
前言： Lock     替代了      synchronized Condition  替代了   Object中的wait 和notify 方法 为什么Lock会替代synchroized?   synchronized的局限性 占有锁的线程等待IO或者其他原因被阻塞，没有释放锁的情况下，其他线程一直阻塞 多个线程同时读写文件的时候，读和读操作也会发生冲突 我们没有办法知道当前...
synchronized （普通同步锁，静态同步锁，TimeUnit）
骑大马挎大刀
11-06 814
1.同步代码块 1.锁对象可以是任意对象 2.多个线程使用同一个锁对象 synchronized (锁对象){ 可能出现线程安全问题的代码 } public class DemoThread implements Runnable { private Integer ticker = 100; Object obj = new Object();//创建锁对象 @Override public void run() { while (true)
Juc06_Lock8锁问题、字节码层面看Synchronized、反编译synchronized锁
所得皆惊喜
10-31 3871
Lock8锁问题、字节码层面看Synchronized、反编译synchronized锁
GBase 8s 锁简介
04-25
GBase 8s 锁简介 GBase 8s 锁是指在关系型数据库中，对数据库中的数据对象加锁，以...解决 GBase 8t 锁的问题需要从多方面进行尝试，包括应用程序锁使用模式设置、应用程序避免使用不必要的锁、避免死锁、避免活锁等。
MYSQL METADATA LOCK(MDL LOCK)MDL锁问题分析
09-09
8. MDL_SHARED_NO_WRITE（SNW）：禁止写入的共享锁。 9. MDL_SHARED_NO_READ_WRITE（SNRW）：禁止读写的共享锁。 10. MDL_EXCLUSIVE（X）：独占锁，仅允许一个事务拥有，其他所有读写操作都会被阻塞。 MDL锁的死锁...
Java多线程中Lock锁的使用总结
08-18
Java中的Lock锁是用于解决多线程访问共享资源时的同步问题的。Lock锁可以分为两种：独占锁和共享锁。独占锁允许多个线程访问同一个资源，但是同一时刻只能有一个线程可以访问该资源。共享锁允许多个线程同时访问同一...
STM32 HAL_LOCK问题
01-20
STM32 HAL_LOCK问题主要出现在使用STM32的HAL库进行UART和CAN通信时，当系统在接收数据过程中，可能出现无法进入接收中断的情况，导致数据接收中断。问题的关键点在于HAL库中的`__HAL_LOCK()`函数。 `__HAL_LOCK()`...
易语言 V8 RF门锁接口
05-09
"LockID.ini"是一个配置文件，通常用来存储设备设置、连接参数或者预定义的门锁ID等信息。开发者可以根据实际情况修改这个文件以适应不同的门锁环境。 "zzmk.e"可能是一个易语言的源代码文件，它可能包含了与RF门锁...
线程8锁机制
weixin_48149536的博客
05-31 172
1 标准访问，先打印短信还是邮件 package com.dym.jvm; class Phone { public synchronized void sendSMS() throws Exception { System.out.println("------sendSMS"); } public synchronized void sendEmail() throws Exception { System.out.pri
c# 非阻塞算法_非阻塞算法（Lock-Free）的实现
weixin_39880301的博客
12-20 220
上篇文章我们讲到了使用锁会带来的各种缺点，本文将会讲解如何使用非阻塞算法。非阻塞算法一般会使用CAS来协调线程的操作。虽然非阻塞算法有诸多优点，但是在实现上要比基于锁的算法更加繁琐和负责。本文将会介绍两个是用非阻塞算法实现的数据结构。非阻塞的栈我们先使用CAS来构建几个非阻塞的栈。栈是最简单的链式结构，其本质是一个链表，而链表的根节点就是栈顶。我们先构建Node数据结构：public class ...
public static void main(String[] args) 的介绍
热门推荐
故屿γ
02-02 2万+
但行好事，莫问前程。念念不忘，必有回响。诚心正意，手起键落："Hello,World!"。 我会写代码 + 代码改变世界 = "Hello,World!"
Java-Lambda
最新发布
lizhiwei21的博客
07-21 333
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 568
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
接口防刷！利用redisson快速实现自定义限流注解
架构师小吴的博客
07-18 1187
如登录接口，当用户使用手机号+验证码登录时，一般我们会生成6位数的随机验证码，并将验证码有效期设置为1-3分钟，如果对登录接口不加以限制，理论上，通过技术手段，快速重试100000次，即可将验证码穷举出来。解决思路：对登录接口加上限流操作，如限制一分钟内最多登录5次，登录次数过多，就返回失败提示，或者将账号锁定一段时间。在日常开发中，一些重要的对外接口，需要加上访问频率限制，以免造成资��损失。ok，通过以上两步，即可完成我们的限流注解了，下面通过一个接口验证下效果。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 1178
JVM-垃圾回收与内存分配
【Java算法】前缀和 下
2302_79806056的博客
07-18 1081
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
tryLock怎么释放锁
03-03
\u5bf9\u4e8e\u95ee\u9898 tryLock()，这是一个线程同步的方法，...如果你不小心使用 tryLock()，那么可能会导致死锁或其他线程同步问题。 总之，如果您不确定如何正确使用 tryLock()，最好查看相关文档并谨慎使用。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值