JUC并发编程——通过八锁现象更好的理解 Synchronized

最新推荐文章于 2024-02-06 19:38:03 发布
最新推荐文章于 2024-02-06 19:38:03 发布
阅读量143 收藏
点赞数 1
分类专栏： JUC并发编程 文章标签： java lock synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wpc2018/article/details/120309838
版权

文章目录

JUC并发编程——八锁现象

八锁现象

八锁现象，其实就是关于锁的八个问题，通过八个问题，逐渐加深对锁的认识，为了方便演示，这里全部用synchronized。

案例一：两个synchronized 同步方法 + 两个线程 + 一个方法调用者

package com.cheng.Lock8;

public class Test1 {
    public static void main(String[] args) {
        BackHome backHome = new BackHome();
        new Thread(()->{
            backHome.car();
        },"A").start();

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

        new Thread(()->{
            backHome.bus();
        },"B").start();
    }
}

class BackHome{

    public synchronized void car(){
        System.out.println("开车回家");
    }

    public synchronized void bus(){
        System.out.println("坐公家回家");
    }

}

问题一：正常情况下，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

问题二：car() 同步方法延迟3秒，线程先打印"开车回家"还是"坐公家回家"？

public synchronized void car(){
    try {
        TimeUnit.SECONDS.sleep(3);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("开车回家");
}

启动程序打印测试：

在这里插入图片描述

解释：synchronized 锁的对象是方法的调用者，也就是上面的 backHome 对象， backHome 对象只有一个，因此锁也只有一个，两个方法用的是用一把锁，谁先拿到谁就先执行。

案例二：两个同步方法 + 一个普通方法 + 两个线程 + 一个方法调用者

package com.cheng.Lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        BackHome2 backHome = new BackHome2();
        new Thread(()->{
            backHome.car();
        },"A").start();

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

        new Thread(()->{
            backHome.bus();
        },"B").start();

        new Thread(()->{
            backHome.taxi();
        },"C").start();
    }
}

class BackHome2{
    public synchronized void car(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("开车回家");
    }

    public synchronized void bus(){
        System.out.println("坐公家回家");
    }

    //普通方法
    public void taxi(){
        System.out.println("坐出租车回家");
    }
}

问题三：car() 同步方法延迟3秒，线程先打印"开车回家"还是"坐出租车回家"？

启动程序打印测试：

在这里插入图片描述

解释：普通方法没有 synchronized 关键字，不受锁的影响，又因为car() 同步方法延迟3秒，所以线程先执行普通方法。

案例三：两个同步方法 + 两个线程 + 两个方法调用者

backHome1 调用 car()，

backHome2 调用 bus()

package com.cheng.Lock8;

import java.util.concurrent.TimeUnit;

public class Test2 {
    public static void main(String[] args) {
        BackHome2 backHome1 = new BackHome2();
        BackHome2 backHome2 = new BackHome2();
        
        new Thread(()->{
            backHome1.car();
        },"A").start();

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

        new Thread(()->{
            backHome2.bus();
        },"B").start();
    }
}

class BackHome2{

    public synchronized void car(){
        
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("开车回家");
    }

    public synchronized void bus(){
        System.out.println("坐公家回家");
    }
}

问题四：两个方法调用者情况下，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

一秒后打印"坐公家回家"，三秒后再打印 “开车回家”

解释：有两个方法调用者backHome1和backHome2，因此两个同步方法有两把锁，而因为car()方法有延迟，所以bus()方法先执行。

案例四：两个静态同步方法 + 两个线程 + 一个方法调用者

package com.cheng.Lock8;

import java.util.concurrent.TimeUnit;

public class Test3 {
    public static void main(String[] args) {
        BackHome3 backHome = new BackHome3();
  
        new Thread(()->{
            backHome.car();
        },"A").start();

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

        new Thread(()->{
            backHome.bus();
        },"B").start();

    }
}

class BackHome3{

    public static synchronized void car(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("开车回家");
    }

    public static synchronized void bus(){
        System.out.println("坐公家回家");
    }
}

问题五：静态同步方法下情况下，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

在案例四的基础上再加一个方法调用者：

BackHome3 backHome = new BackHome3();
BackHome3 backHome1 = new BackHome3();

new Thread(()->{
    backHome.car();
},"A").start();

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

new Thread(()->{
    backHome1.bus();
},"B").start();

问题六：静态同步方法下情况下两个方法调用者，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

解释：加了 static 的同步方法，在类一加载就有了，锁的对象不再是方法的调用者，而是Class的类模板，不管有几个方法调用者，锁的对象都是这个类模板且全局唯一。

案例五：一个静态同步方法 + 一个普通同步方法 + 一个方法调用者

package com.cheng.Lock8;

import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        BackHome4 backHome = new BackHome4();

        new Thread(()->{
            backHome.car();
        },"A").start();

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

        new Thread(()->{
            backHome.bus();
        },"B").start();

    }
}

class BackHome4{

    public static synchronized void car(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("开车回家");
    }

    public  synchronized void bus(){
        System.out.println("坐公家回家");
    }
}

问题七：一个静态同步方法 + 一个普通同步方法情况下，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

在案例五的基础上新增一个方法调用者：

BackHome4 backHome = new BackHome4();
BackHome4 backHome1 = new BackHome4();

new Thread(()->{
    backHome.car();
},"A").start();

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

new Thread(()->{
    backHome1.bus();
},"B").start();

问题八：一个静态同步方法 + 一个普通同步方法情况下 + 两个方法调用者，线程先打印"开车回家"还是"坐公家回家"？

启动程序打印测试：

在这里插入图片描述

解释：一个静态同步方法 + 一个普通同步方法情况下，锁的对象不同，静态同步方法锁的是全局唯一的类模板，普通同步方法锁的是方法的调用者，因此就算有两个方法调用者，锁也不会冲突，所以没有延迟的方法先执行。

总结

对于普通同步方法，锁是当前实例对象

对于静态同步方法，锁是当前类的class对象

对于同步方法块，锁是括号里面的对象

万里顾—程
关注
专栏目录
Java并发编程面试题——JUC专题
二蛋的博客
02-20 7439
1.1AQS是什么？1.2唤醒线程时，AQS为什么从后往前遍历？1.3AQS为什么用双向链表，（为啥不用单向链表）？1.4AQS为什么要有一个虚拟的head节点1.5ReentrantLock的底层实现原理1.6ReentrantLock的公平锁和非公平锁的区别1.7ReentrantReadWriteLock如何实现的读写锁2.1说下你熟悉的阻塞队列？2.2虚假唤醒是什么？3.1线程池的7个参数3.2线程池的状态有什么，如何记录的？3.3线程池常见的拒绝策略3.4线程池执行流程3.5线程池为什么添加空任务
Java并发编程（24）—— JUC并发编程类库详解
最新发布
shangjg3的博客
09-03 205
CyclicBarrier 是一个同步辅助类，用于让一组线程到达一个屏障（barrier）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。这意味着在修改操作发生时，会创建一个新的数组，并将现有的所有元素复制到新数组中，然后在新数组上进行修改。这意味着在修改操作发生时，会创建一个新的数组，然后将现有的所有元素复制到新数组中，并在新数组上进行修改。当一个线程到达交换点时，它会调用 exchange() 方法，该方法会尝试将该线程的数据与另一个线程的数据交换。
10.JUC线程高级-线程八锁
weixin_34004576的博客
09-05 113
所谓线程八锁实际上对应于是否加上synchronized，是否加上static等8种常见情况，代码如下: 1.两个普通同步方法，两个线程，标准打印，结果：one two public class TestThread8Monitor { public static void main(String[]...
java多线程 线程八锁
ankan7400的博客
02-05 118
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
GUC-10 线程八锁
weixin_30932215的博客
03-05 163
/* * 题目：判断打印的 "one" or "two" ？ * * 1. 两个普通同步方法，两个线程，标准打印， 打印? //one two * 2. 新增 Thread.sleep() 给 getOne() ,打印? //one two * 3. 新增普通方法 getThree() , 打印? //three one two * 4. 两个普通同步...
11、JUC--线程八锁
weixin_33923148的博客
05-02 98
线程八锁 • 一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用　　其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一个时刻　　内，只能有唯一一个线程去访问这些synchronized方法 • 锁的是当前对象this，被锁定后，其它的线程都不能进入到当前对象的其它的　　synchronized方法 • 加个普通方法后发现和同...
【Java高级】JUC之线程八锁案例分析
阿杰
05-02 309
class Phone{ public static synchronized void sendEmail()throws Exception{ TimeUnit.SECONDS.sleep(4); System.out.println("****sendEmail"); } public synchronized void sendSMS...
JUC高并发编程从入门到精通（全）
热门推荐
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
JUC-并发面试题
HBryce24的博客
02-06 1059
并发面试题
高级技术之 JUC 高并发编程
wa_ka_ka的博客
08-25 819
1，什么是 JUC 1.1 JUC简介 JUC 就是java.util.concurrent 工具包的简称，这一个专门用来处理线程的工具包，JDK1.5开始出现 1.2 进程与线程 **进程（Process）：**是系统进行资源分配和调度的基本单位，比如QQ启动就是一个进程。 **线程（Thread）：**是操作系统能够进行运算调度的最小单位，是程序执行的最小单位，它被包含在进程中，比如QQ中的各个功能，都是不同的线程。 1.3 线程的状态 在Thread类中枚举了线程的6种状态; pu
juc-线程八锁
weixin_39535692的博客
10-27 357
松岛枫
JUC高并发编程(07) -- 多线程锁 -- 演示锁的八种情况
姜皓的博客
05-10 313
多线程锁 -- 演示锁的八种情况
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
LXYDSF的博客
06-13 363
《JUC并发编程 - 高级篇》03 - 共享对象之管程 上篇（共享带来的问题 | synchronized | 线程八锁 | 线程安全类）
JUC多线程编程八锁你都知道了吗？关于锁的八个问题
不会编程的派大星的博客
04-21 140
关于锁的八个问题—八锁 前面的文章中留下一个疑问，到底什么是锁，锁到底锁的是谁？ 这里我们就用打电话和发短信的例子来距离说明八锁问题—>锁的是对象方法的调用者或者Class模板（.class） 1、标准情况下，两个线程先打印 发短信还是 先打印 打电话？ import java.util.concurrent.TimeUnit; /** * @program: juc * @description * @author: 不会编程的派大星 * @create: 2021-04-21 12:42
JUC并发编程（二）-- 线程八锁
书生灬今天不吃饭的博客
11-28 217
JUC并发编程（二）-- 线程八锁1、两个线程，分别调用同一个资源类的两个方法，哪个先执行？2、两个线程A和B，分别调用同一个资源类的两个方法，A线程休眠3秒，哪个线程先执行？3、非同步方法是否会受到对象锁的影响？4、同一个类中两个对象的同步方法时候会相互影响？5、同一个类中的两个静态同步方法时候会互相影响？6、同一个类中，一个静态同步方法和一个普通同步方法，会相互影响吗？ 线程八锁，指的就是线程中关于锁的八个问题，用来分辨清晰Java多线程中，锁究竟锁的是什么。 以下 5 和 6 两个问题分别是两个子问题
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2100
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
JUC详解-4-八锁现象彻底理解锁
baidu_38126306的博客
11-11 240
JUC详解 -> 八锁现象 如何判断锁的是谁？ import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 * 2.sendSms()延迟4秒，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 */ public class Test01 { public static void main(String[] args)
面试必备系列JUC(6)--八锁详解
欲问君有几多愁的博客
09-06 639
文章目录前言一、锁总述1.1. 乐观锁 VS 悲观锁2.读入数据总结 前言 最近有读者在后台私信，让我讲讲java里常见的锁，第一次被读者提要求，还是很高兴的，查阅了一些资料，尽量将常见的锁的概念讲的清清楚楚，希望读者读后，能对8锁有个清晰的认知！ 今天给大家介绍我一个很有趣的好友，秃头，干瘦，可能喜欢女生的广叔！！ 长相略微显老（认识五年了，颜值一直在40岁上下） 提示：以下是本篇文章正文内容，下面案例可供参考 一、锁总述 广叔：令狐兄，你知道java中常见的锁吗？ 令狐冲：当然知道，话说当年java
JUC并发编程学习（五）-8锁现象
收破烂的小熊猫
05-06 370
以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰 将从以下8个方面介绍锁现象1. 多个线程使用同一把锁-顺序执行2. 多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行3. 多个线程有锁与没锁-随机执行4.多个线程使用多把锁-随机执行5. Class锁：多个线程使用一个对象-顺序执行6. Class锁...
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

万里顾—程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值