JUC并发编程基础学习之彻底理解八锁问题

最新推荐文章于 2024-07-27 13:31:57 发布
最新推荐文章于 2024-07-27 13:31:57 发布
阅读量95 收藏
点赞数
分类专栏： JUC并发编程学习 文章标签： 并发编程 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45301250/article/details/119156127
版权

前言：

大家好，今天我们一起来学习JUC并发编程中的八锁问题！希望你在看完本文后会对八锁问题彻底理解！

1.1 只存在一个资源类

模拟场景：

只存在一个资源对象，判断手机是先打电话还是先发短信？

1.让发短信休眠
1-1 问题思考

思考1：

只存在一个资源对象，如果将线程B(发短信)进行休眠，先执行打电话还是发短信？

1-2 代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest1
 * @Description 彻底理解八锁问题
 * 模拟场景：只存在一个资源对象，手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest1 {

    public static void main(String[] args) throws InterruptedException {

        //获取资源对象的实例
        Phone phone = new Phone();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
        //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //发短信
           phone.sendMsg();
        },"B").start();
    }

}

//资源类：Phone手机
class Phone {

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

    //发短信
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }

}
1-3 测试结果

在这里插入图片描述

结果：先执行打电话！

1-4 结果分析

为什么先执行打电话？

错误回答：

因为线程A比线程B先执行，所以先执行打电话再执行发短

正确回答：

因为我们使用了synchronized同步锁，然后给线程B(发短信)设置了休眠时间，所以它会抱着锁睡觉，因此先执行打电话！

2.让打电话休眠
2-1 问题思考

思考2：

只存在一个资源对象，如果将线程B(发短信)休眠1s，线程A(打电话)休眠2s，结果仍然是先执行打电话再执行发短信吗？

2-2 代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest1
 * @Description 彻底理解八锁问题
 * 模拟场景：只存在一个资源对象，手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest1 {
public static void main(String[] args) throws InterruptedException {

        //获取资源对象的实例
        Phone phone = new Phone();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
        //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //发短信
            phone.sendMsg();
        },"B").start();
    }

}

//资源类：Phone手机
class Phone {

    //打电话
    public synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    /**
     * synchronized(同步锁)所锁定的对象是方法的调用者，
     * 两个方法用的是同一个锁，谁先获取锁，谁先执行！
     */
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
    
}
2-3 测试结果

在这里插入图片描述

结果：仍然先执行打电话！

2-4 结果分析

为什么仍然是先执行打电话？

由于synchronized同步锁所锁定的Phone对象是这两个方法的调用者，因此两个方法用的是同一个锁，谁先获取锁，谁就先执行！

虽然我们又给线程A(打电话)设置了2s休眠时间，但是线程A并不会立即解锁，而是会抱着锁睡觉，因此仍然是线程A(打电话)先执行！

3.调用非同步方法hello
3-1 问题思考

思考3：

只存在一个资源对象，如果将线程B(hello)休眠1s，线程A(打电话)休眠2s，结果是先执行打电话还是hello？

3-2 代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest1
 * @Description 彻底理解八锁问题
 * 模拟场景：只存在一个资源对象，手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest1 {
public static void main(String[] args) throws InterruptedException {

        //获取资源对象的实例
        Phone phone = new Phone();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
        //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //在线程B中调用hello方法
            phone.hello();
        },"B").start();
	}

}

//资源类：Phone手机
class Phone {

    //打电话
    public synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
    
    //hello方法(没有使用synchronized同步锁)
    public void hello() {
        System.out.println("hello");
    }
}
3-3 测试结果

在这里插入图片描述

结果：先执行hello！

3-4 结果分析

为什么先执行hello？

由于hello方法中没有使用synchronized同步锁，因此不受锁的影响，所以先执行hello方法

1.2 存在两个资源类

1. 问题思考

存在两个资源对象，如果将线程B(发短信)休眠1s，线程A(打电话)休眠2s，先执行打电话还是发短信？

2.代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest2
 * @Description 彻底理解八锁问题
 * 模拟场景：手机先打电话还是先发短信(存在两个资源对象)
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest2 {
    public static void main(String[] args) throws InterruptedException {
        //获取两个Phone对象实例
        Phones phone1 = new Phones();
        Phones phone2 = new Phones();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone1.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //发短信
            phone2.sendMsg();
        },"B").start();
    }

}

//资源类：Phones电话
class Phones {

    //打电话
    public synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
    
}
3.测试结果

在这里插入图片描述

结果：先执行发短信！

4.结果分析

为什么先执行发短信？

由于现在存在两个资源对象实例，也就是两个调用者，两把锁，因此这两个方法不是同一个锁，也就不存在谁先拿到锁，谁先执行！

而线程A(打电话)又被设置为休眠2s，线程B(发短信)被设置为休眠1s，因此执行时间比发短信晚1s，所以先执行发短信！

1.3 只存在一个资源类都为静态方法

1. 问题思考

只存在一个资源对象，如果将sendMsg(发短信)方法和call(打电话)同步方法都使用static修饰为静态方法，并且线程B(发短信)休眠1s，线程A(打电话)休眠2s，先执行打电话还是发短信？

2.代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest3
 * @Description 彻底理解八锁问题
 * (只存在一个资源对象，方法修改为静态方法)
 * 模拟场景：手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest3 {

    public static void main(String[] args) throws InterruptedException {
        //获取TelPhone对象实例
        TelPhone phone = new TelPhone();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //发短信
            phone.sendMsg();
        },"B").start();
    }

}

//资源类：TelPhone电话
//TelPhone是只有唯一一个实例的Class对象
class TelPhone {

    //使用static修饰以下同步方法，使其成为静态方法

    //打电话
    /**
     *  synchronized锁的对象是方法的调用者
     *  static静态方法，类一加载就有了(即Class模板，锁的是Class)
     */
    public static synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    public static synchronized void sendMsg() {
        System.out.println("发短信");
    }

}
3. 测试结果

在这里插入图片描述

结果：先执行打电话！

4.结果分析

为什么先执行打电话？

由于使用了static修饰了所有的同步方法，在TelPhone类一加载时就有了，属于同一个Class模板，并且TelPhones类是一个唯一的Class对象，因此锁的仍然是同一个Class类(即实际上只存在一个调用者)；

虽然线程A(打电话)进行了2s的线程休眠，但是它没有释放锁(相当于抱着锁睡觉)，所以先执行的是打电话

1.4 存在两个资源类只有一个静态方法

1. 问题思考

存在两个资源对象，如果将call(打电话)同步方法使用static修饰为静态方法，并且线程B(发短信)休眠1s，线程A(打电话)休眠2s，先执行打电话还是发短信？

2.代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest4
 * @Description 彻底理解八锁问题
 * (存在两个资源对象，只用打电话使用static修饰)
 * 模拟场景：手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest4 {

    public static void main(String[] args) throws InterruptedException {
        //获取两个TelPhone2对象实例
        TelPhones phone1 = new TelPhones();
        TelPhones phone2 = new TelPhones();

        //使用Lambda表达式创建和启动线程
        //线程A
        new Thread(()-> {
            //打电话
            phone1.call();
        },"A").start();

        //让发短信休眠1s
        try{
            //设置休眠时间为1s
            TimeUnit.SECONDS.sleep(1);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        //线程B
        new Thread(()-> {
            //发短信
            phone2.sendMsg();
        },"B").start();
    }

}

//资源类：TelPhones电话
//TelPhones是只有唯一一个实例的Class对象
class TelPhones {

    //打电话
    //使用static修饰该方法，使其成为静态方法
    //静态的同步方法锁的是Class类模板(即TelPhone2)
    public static synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    //普通的同步方法锁的是方法的调用者(即phone2)
    public synchronized void sendMsg() {
        System.out.println("发短信");
    }
}
3. 测试结果

在这里插入图片描述

结果：先执行发短信！

4.结果分析

为什么先执行发短信？

虽然存在两个资源对象，理应存在两个调用者，只使用了static修饰了call(打电话)的同步方法， 因此 静态同步方法call() 锁的是对应的Class类模板(TelPhones)，而 普通的同步方法senMsg() 锁的是 其方法的的调用者 (TelPhones的对象实例phone2)，所以 phone1和phone2 是两个资源对象，即不同的调用者和锁；

线程A(打电话)进行了2s的线程休眠，线程B(发短信)只休眠了1s，所以先执行的是发短信！

1.5 存在两个资源类都为静态方法

1. 问题思考

存在两个资源对象，如果将sendMsg(发短信)方法和call(打电话)同步方法都使用static修饰为静态方法，并且线程B(发短信)休眠1s，线程A(打电话)休眠2s，先执行打电话还是发短信？

2.代码实现
package com.kuang.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @ClassName LockTest4
 * @Description 彻底理解八锁问题
 * (存在两个资源对象，并且都使用static修饰)
 * 模拟场景：手机先打电话还是先发短信
 * @Author 狂奔の蜗牛rz
 * @Date 2021/7/27
 */
public class LockTest5 {

        public static void main(String[] args) throws InterruptedException {
            //获取两个TelPhone对象实例
            //使用static修饰，两个对象实例的Class类模板只有一个，锁的是同一个Class类
            TelPhones2 phone1 = new TelPhones2();
            TelPhones2 phone2 = new TelPhones2();

            //使用Lambda表达式创建和启动线程
            //线程A
            new Thread(()-> {
                //打电话
                phone1.call();
            },"A").start();

            //让发短信休眠1s
            try{
                //设置休眠时间为1s
                TimeUnit.SECONDS.sleep(1);
                //捕获中断异常
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            
            //线程B
            new Thread(()-> {
                //发短信
                phone2.sendMsg();
            },"B").start();
        }

    }

//资源类：TelPhones2电话
//TelPhones2是只有唯一一个实例的Class对象
class TelPhones2 {
    //使用static修饰以下同步方法，使其成为静态方法

    //打电话
    public static synchronized void call() {
        //让打电话休眠2s
        try{
            //设置休眠时间为2s
            TimeUnit.SECONDS.sleep(2);
            //捕获中断异常
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

    //发短信
    public static synchronized void sendMsg() {
        System.out.println("发短信");
    }
}
3. 测试结果

在这里插入图片描述

结果：先执行打电话！

4.结果分析

为什么先执行打电话？

虽然存在两个资源对象，理应存在两个调用者，但由于使用了static修饰了所有的同步方法，在TelPhone类一加载时就有了，属于同一个Class模板，并且TelPhones类是一个唯一的Class对象，因此锁的仍然是同一个Class类(即实际上只存在一个调用者)；

线程A(打电话)虽然进行了2s的线程休眠，但是它 没有释放锁(相当于抱着锁睡觉)，线程B(发短信)无法获取锁，所以先执行的仍然是打电话

到这里，今天的有关八锁问题的学习就结束了，欢迎大家学习和讨论！

参考视频链接：https://www.bilibili.com/video/BV1B7411L7tE (B站UP主遇见狂神说的JUC并发编程基础)

狂奔の蜗牛rz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
尚硅谷大厂必备技术之JUC并发编程基础视频 配套资料（自己根据视频整理课件，和代码）
09-23
【尚硅谷】大厂必备技术之JUC并发编程视频 配套资料，自己根据视频整理 pdf 课件，和代码 视频地址：...
juc并发编程脑图以及相关示例代码
07-30
juc并发编程脑图以及相关示例代码
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7995
深入理解JUC的8锁现象
JUC_8锁问题
我认不到你的博客
09-20 166
“八锁”的含义：就是八个关于锁的问题
JUC之八锁现象理解锁
可小辉的博客
11-23 249
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并发编程（五）-8锁的现象
二总的猫
02-26 2086
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
【Java高级】JUC之线程八锁案例分析
阿杰
05-02 298
class Phone{ public static synchronized void sendEmail()throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("****sendEmail"); } public synchronized void sendSMS...
JUC并发编程视频教程
11-28
视频详细讲解，需要的小伙伴自行网盘下载，链接见附件，永久有效...进程与线程第三章：Java 线程第四章：共享模型之管程第五章：共享模型之内存第六章：共享模型之无锁第七章：共享模型之不可变第八章：共享模型之工具
Java后端开发，JUC并发编程Java后端开发，JUC并发编程
04-14
Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程Java后端开发，JUC并发编程...
JUC并发编程学习笔记(硅谷)
07-23
"JUC并发编程学习笔记(硅谷)"很可能包含了关于Java并发工具集（Java Util Concurrency, JUC）的深入理解和实战经验。JUC是Java标准库提供的一套强大的并发处理工具，它极大地简化了多线程编程，提高了程序的可读性...
JUC学习之线程8锁
dyt443733328的博客
04-20 746
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
java多线程 线程八锁
ankan7400的博客
02-05 108
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
golang 接口
m0_70982551的博客
07-24 872
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 460
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
springboot之自动装配
weixin_50153914的博客
07-23 566
Spring Boot 通过一系列注解和条件配置实现了自动装配机制，使得开发者无需手动配置大量的 XML 文件或 Java 配置类。自动配置机制利用文件中的自动配置类，并结合条件注解和组件扫描，实现了灵活且强大的自动装配功能。这样，开发者可以专注于业务逻辑的实现，而无需处理繁琐的配置细节。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
最新发布
訾博（ZiBo）的博客
07-27 550
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 346
小A喜欢两种性质都成立的数字，小B喜欢至少符合一种性质的数字，小C喜欢不符合这两种性质的 数字。给出一个数字，请输出三个人是否喜欢这个数字。如果喜欢输出1，否则输出0，用空格分隔。输入数字 num，先定义三个整型代表三个人的喜欢与否，先默认设为 0。之后判断num对于性质1、2的条件，分别用 boolen 类型标识。对于每个整型进行判断，是否改为 1 代表喜欢。性质2：大于4且不大于12;
Java修炼 2024.7.26 0:24
2301_80011650的博客
07-26 398
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
学习笔记---java篇（0723）
m0_70630166的博客
07-23 839
java、数据类型、循环、选择等
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

狂奔の蜗牛rz

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

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

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

打赏作者

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

抵扣说明：

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

余额充值