JUC_8锁问题

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量200 收藏 1
点赞数
分类专栏： JUC 文章标签： java jvm android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57581439/article/details/126949265
版权

8锁问题示例与探究（问题后附讲解）

“八锁”的含义：就是八个关于锁的问题

问题一：标准情况下，两个线程先打印发短信 还是打电话？

public class Demo1 {
    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{
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

答案：1、发短信 2、打电话

这个问题的本质是给 phone 这个对象加了 synchronized 锁 两个方法用的是同一个对象锁，A先执行，拿到了锁，只有A执行完，A解锁了（synchronized是自动释放锁），B才能拿到锁，从而去操作phone这个对象

问题二：sendSms延迟4秒，两个线程先打印 发短信 还是打电话？

public class Demo1 {
    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{
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

答案：（4秒后，显示结果）1、发短信 2、打电话

和问题一一样，同样是A拿到了锁，只有等A执行完，释放了锁（synchronized是自动释放锁），B才能拿到锁，从而操作hone对象

问题三：一个同步方法，一个普通方法， 先执行发短信 还是打电话？

public class Demo2 {
    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 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
 //这里没有锁！不是同步方法，不受锁的影响！
    public void call() {
        System.out.println("打电话");
    }
}

答案：1、打电话 （4秒后，显示） 2、发短信

先执行普通方法（不是同步方法，不受锁的影响），因为他不是同步方法不受锁的影响，并且发短信睡眠了4秒，所以发短信肯定在她后面。

问题四：两个对象，两个同步方法，先执行发短信 还是打电话？

public class Demo2 {
    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 (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();

        }, "B").start();


    }
}

class Phone2 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

答案：1、打电话（4秒后，显示）2、发短信

他们锁的是不同的两个对象，所以互不受影响，由于发短信睡了4秒中，使用发短信在打电话后面

问题五：增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话？

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

        //锁的存在
        new Thread(() -> {
            phone.sendSms();

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

//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    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("打电话");
    }
}

答案：（4秒后，显示）1、发短信 2、打电话

因为静态代码块实在类加载的时候就有了，他锁的是类（Class，类锁）用的是同一个锁，谁先抢到谁先执行，所以发短信先抢到。

问题六：增加两个静态的同步方法，两个对象，先打印发短信还是打电话？

public class Demo3 {
    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 (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }
}
//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    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("打电话");
    }
}

答案：（4秒后，显示）1、发短信 2、打电话

类锁锁的是class类，全局唯一，所以谁先抢到锁，谁先执行

问题七：一个静态的同步方法，一个普通的同步方法，一个对象；先打印发短信还是打电话呢？

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        Phone4 phone = new Phone4();

        //锁的存在
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();
        //捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.call();
        }, "B").start();
    }
}

//Phone3 唯一的一个Class 对象
class Phone4 {
    //静态的同步方法
    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、打电话（4秒后，显示）2、发短信

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁

问题八：一个静态的同步方法，一个普通的同步方法，两个对象；先打印发短信还是打电话呢？

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        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();
    }
}

//Phone3 唯一的一个Class 对象
class Phone4 {

    //静态的同步方法
    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、打电话（4秒后，显示）2、发短信

因为用的都不是一个锁，一个是类锁，一个是锁的调用者（对象）。所以对象锁与类锁，是两把锁

我认不到你
关注
专栏目录
JUC 常用类、锁
qq_48019875的博客
01-17 918
目录一、JUC 常用类1、ConcurrentHashMap 一、JUC 常用类 Java 5.0 在 java.utilconcurrent 包中提供了多种并发容器类来改进同步容器的性能. 1、ConcurrentHashMap ConcurrentHashMap 采用锁分段机制，并没有将整个hash表锁住，jdk8之后没有使用分段锁（给每个位置创建一个锁标志对象）。 采用CAS思想 + synchronized来实现 插入元素时，检测hash表对应位置是否是第一个节点，如果采用CAS机制（循环检查）
JUC 常见的锁
Java和算法学习的博客
09-11 2037
目录一、AtomicInteger1、底层实现（1） 如果在执行CAS操作的时候，在判断值是否为我期望的值后，马上有其他线程把这个值改为了其他的值，那这种情况不是依然有问题吗？（2）ABA问题（3）CAS底层是怎么做到的？2、SyncLong VS AtomicLong VS LongAdder二、ReentrantLock1、公平锁与非公平锁2、reentrantlock VS synchronized三、CountDownLatch（倒数 门闩）四、CyclicBarrier （循环 栅栏）五、Phas
java多线程 线程八锁
ankan7400的博客
02-05 127
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
JUC学习之线程8锁
dyt443733328的博客
04-20 766
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8080
深入理解JUC的8锁现象
JUC之八锁现象理解锁
可小辉的博客
11-23 268
1.JUC概述 2.八锁应用 Test1.java package lock8; import java.util.concurrent.TimeUnit; /** * 8锁，是锁的8个问题 * 1.标准情况下，两个线程打印，先打印？----- 发短信 打电话 * * @author Admin * */ public class Test1 { public static void main(String[] args) { Phone phone = new Ph.
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1448
JUC 八锁现象 Java并发编程
JUC线程锁框架
12-31
Java并发编程是Java平台的重要特性...通过深入学习和实践JUC线程锁框架，开发者可以更好地解决并发问题，提高程序的并发性能和稳定性。理解并掌握这些组件的原理和使用方式，对于编写高效、可靠的多线程代码至关重要。
尚硅谷Java视频_JUC 视频教程
02-17
尚硅谷_JUC线程高级_同步锁 Lock ·8. 尚硅谷_JUC线程高级_生产者消费者案例-虚假唤醒 ·9. 尚硅谷_JUC线程高级_Condition 线程通信 ·10. 尚硅谷_JUC线程高级_线程按序交替 ·11. 尚硅谷_JUC线程高级_...
Java——聊聊JUC中的锁（synchronized & Lock & ReentrantLock）
java_lujj的博客
09-12 380
这篇文章是关于锁的，是入门级别的文章，后续还会有更深入、更底层的JUC，我会慢慢更新的。。。
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2110
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 767
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC并发编程（二）: 8锁现象(深入理解锁)
Hi_alan的博客
03-05 490
8锁现象 在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？ 首先看下以下8个问题 1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步...
JUC并发编程基础学习之彻底理解八锁问题
weixin_45301250的博客
07-28 111
前言： 大家好，今天我们一起来学习JUC并发编程中的八锁问题！希望你在看完本文后会对八锁问题彻底理解！ 1.1 只存在一个资源类 模拟场景： 只存在一个资源对象，判断手机是先打电话还是先发短信？ 1.让发短信休眠 1-1 问题思考 思考1： 只存在一个资源对象，如果将线程B(发短信)进行休眠，先执行打电话还是发短信？ 1-2 代码实现 package com.kuang.lock8; import java.util.concurrent.TimeUnit; /** * @ClassNam
JUC并发编程-8锁现象
凹凸曼的博客
12-18 509
文章目录锁方法的调用者问题一问题二问题三问题四锁class对象问题五问题六同时锁方法的调用者和class对象问题七问题八 首先感谢下B站的狂神，在这里第一次听到“8锁现象”，并弄懂了“锁到底锁的是谁”。 8锁现象，实际对应的就是8个问题。 掌握了这8个问题后：可以清楚判断锁的是谁！知道什么是锁，锁到底锁的是谁！ 锁方法的调用者 问题一 如下代码：标准情况下，下边两个线程先打印 发短信 还是 打电话 ？ public class Test1 { public static void main(Stri
【Java高级】JUC之线程八锁案例分析
阿杰
05-02 312
class Phone{ public static synchronized void sendEmail()throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("****sendEmail"); } public synchronized void sendSMS...
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 449
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 944
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
尚硅谷Java8、JUC与NIO最新视频全解析
2. **Java并发工具 (JUC)**：Java并发工具包(Java Util Concurrency，简称JUC) 是Java提供的一套强大的并发处理工具，包括锁、并发容器、并发算法等。通过学习JUC，开发者可以更好地理解和管理多线程环境中的同步与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

我认不到你

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

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

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

打赏作者

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

抵扣说明：

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

余额充值