4.如何判断锁的是谁 ：八个锁的问题

最新推荐文章于 2022-06-10 22:10:56 发布
最新推荐文章于 2022-06-10 22:10:56 发布
阅读量607 收藏
点赞数
分类专栏： 【Java】学习博客 # 【JUC并发编程】
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beiluoL/article/details/106307516
版权

感谢秦疆老师的JUC并发编程视频，更多了解哔哩哔哩搜索【狂神说Java】。

本文内容源于秦疆老师的JUC并发编程视频教程。给狂神推荐，点赞吧！

关于锁的八个问题 深刻理解我们的锁

如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！

1.标准情况下，两个线程先打印 发短信 还是打电话

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 1.标准情况下，两个线程先打印 发短信 还是打电话
 */
public class TestLock1 {

    public static void main(String[] args) {

        Phone phone = new Phone();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception 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("打电话！");
    }


}


//输出：
发短信！
打电话！

2.sendSms()延迟4s情况下，两个线程先打印 发短信 还是打电话 ？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 2.sendSms（）延迟4s情况下，两个线程先打印 发短信 还是打电话 ？
 */
public class TestLock1 {

    public static void main(String[] args) {

        Phone phone = new Phone();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}


class Phone {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

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


}


//输出：
发短信！
打电话！

分析：

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

synchronized 锁的存在 锁的对象是方法的调用者！
两个方法用的是同一把锁，谁先拿到就谁先执行！

3.增加一个普通方法hello（） ,线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 *3.增加一个普通方法hello（） ,线程先打印哪个？
 */
public class TestLock2 {

    public static void main(String[] args) {

        Phone2 phone = new Phone2();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }


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


    }
}


class Phone2 {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

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

    //普通方法 这里没有锁 不是同步方法，不受锁的影响
    public  void hello() {
        System.out.println("hello,你好！");
    }

}


//输出：
hello,你好！
发短信！
打电话！

4.两个对象，两个同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 *4.两个对象，两个同步方法，线程先打印哪个？
 */
public class TestLock2 {

    public static void main(String[] args) {

        //两个对象
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();

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

        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}


class Phone2 {


    public synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

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

    //普通方法 这里没有锁 不是同步方法，不受锁的影响
    public  void hello() {
        System.out.println("hello,你好！");
    }

}


//输出：
打电话！ 
发短信！

5.增加两个静态的同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 5.增加两个静态的同步方法，线程先打印哪个？
 */
public class TestLock3 {

    public static void main(String[] args) {

        Phone3 phone = new Phone3();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}


//Phone3 唯一的一个class 对象  全局唯一
// Class<Phone3> phone3Class = Phone3.class;
class Phone3 {

    //static 静态方法 类一加载就有了！ Class模板
    //锁的是Class
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

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


}


//输出：
发短信！
打电话！

6.两个对象，增加两个静态的同步方法，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 6.两个对象，增加两个静态的同步方法，线程先打印哪个？
 */
public class TestLock3 {

    public static void main(String[] args) {
        //两个对象的Class类模板只有一个 static 锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}


//Phone3 唯一的一个class 对象  全局唯一
// Class<Phone3> phone3Class = Phone3.class;
class Phone3 {

    //static 静态方法 类一加载就有了！ Class模板
    //锁的是Class
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

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


}


//输出：
发短信！
打电话！

7.一个静态的同步方法,一个普通的同步方法,一个对象，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态的同步方法,一个普通的同步方法,线程先打印哪个？
 */
public class TestLock4 {

    public static void main(String[] args) {
        //
        Phone4 phone = new Phone4();

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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}



class Phone4 {


    //static 静态的同步方法 锁的是 Class模板 类一加载就有了！
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    //普通同步方法 锁的是资源
    public  synchronized void call() {
        System.out.println("打电话！");
    }


}

//输出：
打电话！
发短信！

8.一个静态的同步方法,一个普通的同步方法,两个对象，线程先打印哪个？

package demo3;

import java.util.concurrent.TimeUnit;

/**
 * 8.一个静态的同步方法,一个普通的同步方法,两个对象，线程先打印哪个？
 */
public class TestLock4 {

    public static void main(String[] args) {
        //两个对象
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();


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


        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (Exception e) {
            e.printStackTrace();
        }

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

    }
}



class Phone4 {


    //static 静态的同步方法 锁的是 Class模板 类一加载就有了！
    public  static synchronized void sendSms() {

        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (Exception e) {
            e.printStackTrace();
        }

        System.out.println("发短信！");
    }

    //普通同步方法 锁的是资源
    public  synchronized void call() {
        System.out.println("打电话！");
    }


}



//输出：
打电话！
发短信！

小结

  • new this 具体的一个手机
  • static Class 唯一的一个模板
我有满天星辰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
ug四轴自锁判断后处理.rar
06-20
% ( Total_toolnumbers 3 ) (T05 D8 zmax=99.18 zmin=6.00) (T17 ZXZ zmax=50.00 zmin=7.00) (T09 Z5 zmax=50.00 zmin=-11.50) G40 G49 G80 G94 M11 G91 G30 Z0. S500 M01 ...(Name=D8 D=8.00 R=0.00) ...
如何判断锁是谁？锁到底锁的谁？
Sweet77
03-28 587
第一种： public static void main(String[] args) throws InterruptedException { Phone phone = new Phone(); //因为锁的存在 new Thread(()->{ phone.sendSms(); },"A...
8锁问题
weixin_43912697的博客
03-01 92
8锁问题：关于锁的8个问题 public class demo01 { public static void main(String[] args) { Phone1 phone = new Phone1(); new Thread(()->{ phone.send(); },"A").start(); // 延时2秒 try { TimeUnit.SECONDS
线程第六课(附加)——八锁问题
Geek
11-28 389
  搞懂以下八个问题，同步锁就算真的搞懂了。   1 标准访问，先打印短信还是邮件   public class Lock_8 {     public static void main(String[] args) throws InterruptedException {         Phone phone1 = new Phone();         Phone ...
多线程8锁
weixin_42198596的博客
01-07 107
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
8位密码锁单片机课程设计.doc
02-27
输入初始密码"0、1、2、3、4、5、6、7"，每输入一 位，"按键有效"指示灯亮约半秒钟，输完8位按确认键，锁打开，"锁开"指示灯亮； (2) 按"上锁"键，锁又重新上锁，"锁合"指示灯亮； (3) "锁开"状态下，可输入新密码，...
电子锁设计.doc
02-27
把"单片机系统"区域中的P2.0/A8－P2.7/A15用8芯排线连接到"四路静态 数码显示"区域中的任一个ABCDEFGH端子上； （4）． 把"单片机系统"区域中的P1.0用导线连接到"八路发光二极管模块"区域中 的L1端子上； （5）． ...
电子密码锁设计报告.docx
02-27
二，实验要求 1:用4×4矩阵键盘组成0－9数字键及确认键和删除键。 2:可以自行设定或删除8位密码，能够掉电保存。 3:用5位数码管组成显示电路提示信息，当输入密码时，只显示"8."，当密码位数输入完毕按下确认键时，...
电子密码锁的设计与实现.doc
02-27
用发光二极管模拟锁的情况，锁关时发光二极管灭，打开时发光二极管亮。 4. ．输入密码错误时报警，3 次输入错误时键盘锁定 10s，键盘无法接收数据。 软件的设计主要包括矩形键盘键值的读取、LED 动态扫描输出程序、...
java8锁问题
weixin_45664397的博客
05-17 178
经典八锁问题 1、synchronized标准访问 /** * @author alex tse * 8锁问题 * 1、标准访问，先发短信还是先打电话 */ public class test1 { public static void main(String[] args) { phone phone = new phone(); new Thread(()->{ phone.sendSMS(); //线程A执行发短信
八锁问题详解
酷小亚
06-10 692
“八锁”有什么含义？ 很好理解，就是：有关8个锁的问题！
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1494
关于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
java中同步锁的对象怎么确定_如何确定一个对象是否被锁定(同步),以便在Java中不阻塞？...
weixin_35340181的博客
03-02 524
有一点需要注意的是，你收到这样的信息的时刻，它是陈旧的。换句话说，你可以被告知没有人有锁，但是当你试图获取它，你阻止，因为另一个线程拿出了检查和你试图获取之间的锁。Brian是正确的指向Lock，但我想你真正想要的是它的tryLock方法：Lock lock = new ReentrantLock();......if (lock.tryLock()){// Got the locktry{// ...
锁（八）
shuduti的博客
11-06 215
锁 在java多线程中，我们知道使用synchronized关键字来实现线程间的同步互斥操作，那么其实还有一个更优秀的机制去完成“同步互斥”工作，它就是Lock对象，即重入锁和读写锁。他们具有比synchronized更为强大的功能，并且具有嗅探锁定、多路分支等功能。 ReentrantLock（重入锁） 概念： 在需要进行同步的代码部分加上锁定，但最后一定要释放锁，不然会造成锁用于无法释放，其...
8锁问题，面试必懂知识
细数长流
11-15 154
最近听到一些人问说8锁是什么，这里简单的用代码解释一下。 1、是先打电话还是先发短信？ 2、电话方法内停4秒，是先打电话还是发短信？ 3、新增普通方法充电，是先打电话还是先充电？ 4、现在有两部手机，先打电话还是先发短信？ 5、现在打电话和发短信变成静态同步方法，一部手机，是先打电话还是先发短信？ 6、现在打电话和发短信变成静态同步方法，两部手机，是先打电话还是先发短信？ 7、一个静态同步方法，一个普通同步方法，一部手机，是先打电话还是先发短信？ 8、一个静态同步方法，一个普通同步方法，两部手机，是先打电话
JUC-多线程锁
weixin_30922589的博客
08-27 165
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
8锁问题，探究锁到底锁了谁，谁被锁了
qq_42388853的博客
12-25 351
8锁就是8个锁的问题，直接探究出到底锁的是谁：下面看题和结果就可以了。 题的情况很简单，就是一个Phone类，里面有打电话和发短信俩方法，答案就是先发短信还是先打电话即可： 问题1：正常情况下，谁会先输出出来 package lock8; import java.util.concurrent.TimeUnit; //1、正常情况下，谁会先输出出来 public class Test1 { public static void main(String[] args) { Phone
基于stm32f103c8t6和RFID-RC522的智能门锁
最新发布
04-19
基于STM32F103C8T6和RFID-RC522的智能门锁是一种利用射频识别技术实现的门禁系统。下面是该智能门锁的基本介绍： 1. 硬件组成： ... 4. 是否支持远程控制和监控功能？ 5. 是否支持记录开锁日志和报警功能？

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值