JUC多线程编程八锁你都知道了吗？关于锁的八个问题

最新推荐文章于 2022-06-13 16:12:35 发布
最新推荐文章于 2022-06-13 16:12:35 发布
阅读量152 收藏
点赞数 1
分类专栏： JUC并发编程 文章标签： 多线程 并发编程 java juc 锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45827693/article/details/115945916
版权

关于锁的八个问题—八锁

前面的文章中留下一个疑问，到底什么是锁，锁到底锁的是谁？
这里我们就用打电话和发短信的例子来距离说明八锁问题—>锁的是对象方法的调用者或者Class模板（.class）

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

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 12:42
 **/
public class Test1 {
    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("打电话");
    }
}

运行结果：
在这里插入图片描述
注：先发短信 —>这里锁的是phone对象，谁先拿到锁谁就先执行,发短信先

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

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 12:52
 **/
public class Test2 {
    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("打电话");
    }
}

运行结果：
在这里插入图片描述
注：同样的，锁的phone对象，谁先拿到谁就用，先发短信

3、 增加了一个普通方法后！先执行发短信还是Hello？

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:05
 **/
public class Test3 {
    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.hello();
        },"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("打电话");
    }

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

运行结果：
在这里插入图片描述
注：hello方法不是同步方法，不受锁的限制，所以先执行
4、 两个对象，两个同步方法， 发短信还是 打电话？

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:11
 **/
public class Test4  {
    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();
        new Thread(()->{
            phone2.hello();
        },"C").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("打电话");
    }
    public void hello(){
        System.out.println("hello");
    }
}

运行结果：
在这里插入图片描述
注：这里有两把锁，打电话和hello用的是phone2的锁，发短信用的是phone1的锁 ，两把锁这里互不影响，hello不受锁影响

5、增加两个静态的同步方法，只有一个对象，先打印 发短信？打电话？

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:17
 **/
public class Test5  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.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("打电话");
    }
}

运行结果：
在这里插入图片描述
注：这里只有一个锁，锁的时phone3.class（Class）,在类加载时就已加锁，只有一把锁，所以先发短信

6、两个对象！增加两个静态的同步方法， 先打印 发短信？打电话？

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:23
 **/
public class Test6  {
    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("打电话");
    }
}

运行结果：
在这里插入图片描述

注：这里虽有两个对象，但是因为static的存在，这里所得是phone3.class，所以还是只有一把锁，固还是先发短信

7、1个静态的同步方法，1个普通的同步方法 ，一个对象，先打印 发短信？打电话？

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:27
 **/
public class Test7  {
    public static void main(String[] args) {
        // 两个对象的Class类模板只有一个，static，锁的是Class
        Phone4 phone1 = new Phone4();

        //锁的存在
        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        // 捕获
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.call();
        },"B").start();
    }
}
// Phone3唯一的一个 Class 对象
class Phone4{
    // 静态的同步方法 锁的是 Class 类模板
    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("打电话");
    }
}

运行结果：
在这里插入图片描述
注：这里要注意了哦，有两把锁，发短信锁的是phone4.class，而打电话则是锁的phone1对象的调用者，两把锁，而打电话不需要延迟四秒，先拿到锁，所以先执行

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

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description
 * @author: 不会编程的派大星
 * @create: 2021-04-21 13:31
 **/
public class Test8  {
    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{
    // 静态的同步方法 锁的是 Class 类模板
    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("打电话");
    }
}

运行结果：
在这里插入图片描述
注：这里和上面test7一样的，虽然有两个对象，但是还是两把锁，并且发短信锁的是phone4.class,打电话是phone2这个对象的调用者，而打电话没有延迟，先拿到锁，所以先执行。

7/8 两种情况下，都是先执行打电话,后执行发短信,因为二者锁的对象不同,
静态同步方法锁的是Class类模板,普通同步方法锁的是实例化的对象,
所以不用等待前者解锁后 后者才能执行,而是两者并行执行,因为发短信休眠4s
所以打电话先执行。

小结：
synchronized 锁的对象是方法的调用者
普通方法没有锁！不是同步方法，就不受锁的影响，正常执行
不同实例对象的Class类模板只有一个，static静态的同步方法，锁的是Class

此次八锁问题的说明就到这里了，欢迎小伙伴们留言讨论！

不会编程的派大星
关注
专栏目录
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
JUC线程锁框架
12-31
Java并发编程是Java平台的重要特性，它为多线程编程提供了强大的支持。JUC，全称为Java Util Concurrency，是Java并发包的简称，包含了大量用于处理并发问题的类和接口，极大地简化了多线程环境下的编程。在这个深度...
有关锁的8个问题
gakkimarryme的博客
01-27 202
1.先上第1段代码 package com.zmh.multithread.juc; class Phone { public synchronized void sendSMS() throws Exception { System.out.println("------sendSMS"); } public synchronized void sendEmail() throws Exception { System.out.println
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 282
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
10.JUC线程高级-线程八锁
weixin_34004576的博客
09-05 125
所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下: 1.两个普通同步方法，两个线程，标准打印，结果：one two public class TestThread8Monitor { public static void main(String[]...
java多线程 线程八锁
ankan7400的博客
02-05 128
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
juc之8锁问题
一个代码小白的历练的博客
06-20 145
8锁问题 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以将本
基于Java JUC框架的售票系统与多线程锁通信设计源码
最新发布
09-30
该项目为Java JUC框架下的售票系统设计源码，包含25个文件，其中包括23个Java源文件、1个属性文件和1个...项目涵盖了乘务员售票、一锁八式、Lock锁和多线程通信等多线程技术实践，旨在通过源码学习提升并发编程能力。
JUC代码收集，java高并发多线程学习
03-31
这个集合提供了一系列高效、线程安全的类和接口，用于简化多线程环境下的编程任务。本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `...
05-Java多线程并发编程JUC.pdf
09-16
根据提供的文档内容，以下是关于Java多线程并发编程与JUC知识点的详细解读： 1. 线程的状态 Java线程在其生命周期中可以拥有不同的状态。...掌握这些知识点对于进行Java多线程编程和面试准备非常有帮助。
GUC-10 线程八锁
weixin_30932215的博客
03-05 177
/* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two * 3. 新增普通方法 getThree() , 打印? //three one two * 4. 两个普通同步...
11、JUC--线程八锁
weixin_33923148的博客
05-02 104
线程八锁 • 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用　　其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻　　内，只能有唯一一个线程去访问这些synchronized方法 • 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的　　synchronized方法 • 加个普通方法后发现和同...
JUC并发编程（二）: 8锁现象(深入理解锁)
Hi_alan的博客
03-05 491
8锁现象 在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？ 首先看下以下8个问题 1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步...
juc----举例说明8锁问题
qq_40927884的博客
05-20 542
class Phone { public static synchronized void SendSMS() throws InterruptedException { TimeUnit.SECONDS.sleep(4); System.out.println("发了短信"); } public synchronized void ...
JUC之八锁现象理解锁
可小辉的博客
11-23 269
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.
【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...
juc-线程八锁
weixin_39535692的博客
10-27 376
松岛枫
JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况
姜皓的博客
05-10 321
多线程锁 -- 演示锁的八种情况
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
LXYDSF的博客
06-13 380
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值