JUC-关于Lock的8锁问题

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量181 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Watson24/article/details/122459999
版权

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(()->{
            phone.sendSms();
        },"A").start();

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

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

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

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

在这里插入图片描述

  • 发短信延迟4秒，两个线程先打印发短信还是打电话？

    import java.util.concurrent.TimeUnit;

public class Lock2 {
    public static void main(String[] args) {
        Phone2 phone = new Phone2();
        //锁的存在
        new Thread(()->{
            phone.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.call();
        },"B").start();
    }
}

class Phone2{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

在这里插入图片描述

​ 以上例子表明，普通的同步方法锁的是new出来的对象，同一个对象调用的两个方法，谁先拿到谁先执行

  • 普通方法和普通的同步方法，先执行发短信还是hello？

    import java.util.concurrent.TimeUnit;

public class Lock3{
    public static void main(String[] args) {
        Phone3 phone = new Phone3();
        new Thread(()->{
            phone.sendSms();
        },"A").start();

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

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

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

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

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

在这里插入图片描述

  • 两个对象，两个同步方法，发短信还是打电话？

    import java.util.concurrent.TimeUnit;

public class Lock4{
    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 (InterruptedException e) {
            e.printStackTrace();
        }

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

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

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

在这里插入图片描述

  • 两个静态的同步方法，只有一个对象，先打印发短信还是打电话？

    import java.util.concurrent.TimeUnit;

public class Lock5 {
    public static void main(String[] args) {

        Phone5 phone = new Phone5();

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

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

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

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

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

在这里插入图片描述

  • 两个对象，两个静态的同步方法，先打印发短信还是打电话？

    import java.util.concurrent.TimeUnit;

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

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}

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

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

在这里插入图片描述

  • 1个静态的同步方法，1个普通的同步方法，只有一个对象，先打印发短信还是打电话？

    import java.util.concurrent.TimeUnit;

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

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

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

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

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

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

在这里插入图片描述

  • 1个静态的同步方法，1个普通的同步方法，两个对象，先打印发短信还是打电话？

    import java.util.concurrent.TimeUnit;

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

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

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

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

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

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

在这里插入图片描述

总结

锁有两种，一种通过new对象，锁的是调用者，另一种通过static修饰的静态方法，锁的是Class，这是全局唯一的一个模板

野猫爱吃鱼
关注
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1568
关于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
JUC-Lock接口
che_j的博客
10-20 234
什么是 Lock Lock 和 synchronized 的 不同
Lock 8锁问题
m0_71149992的博客
06-22 197
最初资源类 题目 /** * 题目：谈谈你对多线程锁的理解,8锁案例说明 * 口诀：线程 操作 资源类 * 8锁案例说明： * 1 标准访问有ab两个线程，请问先打印邮件还是短信 * 2 sendEmail方法中加入暂停3秒钟，请问先打印邮件还是短信 * 3 添加一个普通的hello方法，请问先打印邮件还是hello * 4 有两部手机，请问先打印邮件还是短信 * 5 有两个静态同步方法，有1部手机，请问先打印邮件还是短信 * 6 有两个静态同步方法，有2部手机，请问先打印邮
Lock8锁
张鑫的博客
08-27 734
前言： Lock     替代了      synchronized Condition  替代了   Object中的wait 和notify 方法 为什么Lock会替代synchroized?   synchronized的局限性 占有锁的线程等待IO或者其他原因被阻塞，没有释放锁的情况下，其他线程一直阻塞 多个线程同时读写文件的时候，读和读操作也会发生冲突 我们没有办法知道当前...
Java多线程之8Lock问题解析
努力努力再努力L
05-13 454
Java多线程之8Lock问题解析 本文目录 1 标准访问的时候，请问先打印邮件还是短信？ 2 sendEmail方法暂停4秒钟，请问先打印邮件还是短信？ 3 新增Hello普通方法，请问先打印邮件还是Hello？ 4 两部手机，请问先打印邮件还是短信？ 5 两个静态同步方法，同1部手机 ,请问先打印邮件还是短信？ 6 两个静态同步方法，有2部手机 ,请问先打印邮件还是短信？ 7 1个静态同步...
no module ‘fcntl‘、module ‘fcntl‘ has no attribute ‘LOCK_UN‘
dandanforgetlove的专栏
09-01 1763
no module 'fcntl' 或 module 'fcntl' has no attribute 'LOCK_UN' 原因：windows 不支持该module！！！！！！ 以上是Linux下的环境。 根据网上的内容如下 fcntl.py #fcnt1.py LOCK_UN=8 def fcntl(fd, op, arg=0): return 0 def ioctl(fd, op, arg=0, mutable_flag=True): if mutabl...
个人学习-JUC-笔记
02-25
- **Lock接口**：ReentrantLock是其典型实现，提供公平锁、非公平锁以及更细粒度的控制。 - **volatile**：保证变量在多线程环境中的可见性，但不保证原子性。 5. **并发容器** - **ConcurrentHashMap**：线程...
Java-JUC-多线程 进阶
07-05
Lock 锁可以分为独占锁（Exclusive Lock）和共享锁（Shared Lock）两种，独占锁只能被一个线程持有，共享锁可以被多个线程持有。Java 中提供了多种 Lock 实现，包括 ReentrantLock、LockSupport 等。 生产者和消费...
Java 多线程与并发(7-26)-JUC - 类汇总和学习指南.pdf
07-22
JUC 框架包含多个部分，包括 Lock 框架、Tools 类、Collections、Atomic、Executors 等。下面是每个部分的详细解释： 1.Lock 框架和 Tools 类： Lock 框架提供了一种更灵活的锁定机制，可以代替 synchronized 方法...
juc-1(2).docx
03-29
JUC 包含了线程池、并发容器、同步器、定时器等组件，帮助开发者更安全、高效地处理并发问题。 【线程状态】 线程有五种基本状态：新生、就绪、运行、阻塞和死亡。新生状态是在创建后未启动执行前；就绪状态是线程...
JMM:内存模型以及8种原子操作
starbxx的博客
08-07 6499
java内存模型中规定了所有变量都存贮到主内存（如虚拟机物理内存中的一部分）中。每一个线程都有一个自己的工作内存(如cpu中的高速缓存)。线程中的工作内存保存了该线程使用到的变量的主内存的副本拷贝。线程对变量的所有操作（读取、赋值等）必须在该线程的工作内存中进行。不同线程之间无法直接访问对方工作内存中变量。线程间变量的值传递均需要通过主内存来完成。 关于主内存与工作内存之间的交互协议，即一个变...
Java的8锁现象
weixin_56018532的博客
09-09 670
Java的8锁现象
JMM的八种操作与其规则
Bangtidy的博客
07-21 2140
## 一、什么是JMM** JMM即为JAVA 内存模型（java memory model），JMM规定了内存主要划分为主内存和工作内存两种。主内存对应的是Java堆中的对象实例部分，工作内存对应的是栈中的部分区域。每条线程拥有各自的工作内存，工作内存中的变量是主内存中的一份拷贝。 二、JMM的八种交互操作（每个操作都为原子操作） lock （锁定）：作用于主内存的变量，把一个变量标识为线程独占状态 unlock （解锁）：作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以
java多线程-JUC-Look锁了谁?
TianLiaoFeiJue的博客
10-22 1085
java多线程-JUC-Look到底锁了谁?demo总结 demo // 代码 import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /*** * ReentrantLock 锁的是 自己内部维护 的 资源 : state * 所有线程 争夺的 是 Reentran...
Java并发编程：Lock
weixin_30779691的博客
08-20 1642
Java并发编程：Lock 　　在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问。本文我们继续来探讨这个问题，从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。 　　也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock？这个问题将...
JUC并发编程-Lock锁
qq_50596778的博客
01-27 1531
Lock详解 简介 java.util.concurrent.locks包下常用的类与接口（lock是jdk 1.5后新增的） Lock和ReadWriteLock是两大锁的根接口： Lock代表实现类是ReentrantLock（可重入锁） ReadWriteLock（读写锁）的代表实现类是ReentrantReadWriteLock 同步实现原理 lock只能被一个线程获取,当一个线程执行lock.lock()后其他线程再尝试获取会进入lock对象中的等待队列,从而达到同步效果，ReenT
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 261
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 578
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 561
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

野猫爱吃鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值