5.八锁现象

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量86 收藏
点赞数
分类专栏： JUC 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49451343/article/details/117295129
版权

1、标准访问，同一个资源类对象，操作两个同步方法（谁先获取到锁谁先执行）

public class EightLock {
    public static void main(String[] args) {
        //创建一个资源类
        Phone phone = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone.call();
        },"A").start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.send();
        },"B").start();
    }
}
//资源类
class Phone{
    //打电话
    public synchronized void call(){
        System.out.println("打电话");
    }
    //发短信
    public synchronized void send(){
        System.out.println("发短信");
    }
}

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

可以看到，这个案例无论怎么运行都是先打电话后发短信。因为我们在发短信的线程前设置了延时干扰，所以每次都是打电话的线程先获取到锁。

2、同一个资源类对象，操作两个同步方法，其中一个方法有阻塞（谁先获取到锁谁先执行）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建一个资源类
        Phone phone = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.send();
        }).start();
    }
}
//资源类
class Phone{
    //打电话
    public synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }
    //发短信
    public synchronized void send(){
        System.out.println("发短信");
    }
}

在这里插入图片描述

第二个案例输出的也和第一个案例输出的内容一样，还是先执行打电话线程，再执行发短信线程。
因为这两个普通方法都只用了synchronized 锁来进行同步，而synchronized锁的对象是方法的调用者，两个方法用的是同一个锁，因此谁先拿到谁执行。

3、同一个资源类对象，操作一个方法为有锁的方法，一个为无锁的普通方法。（互不影响，各自执行）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建一个资源类
        Phone phone = new Phone();
        //创建两条线程，一个打电话，一个发短信
        
        new Thread(()->{
            phone.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
		new Thread(()->{
            phone.send();
        }).start();
    }
}
//资源类
class Phone{

    //打电话
    public synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

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

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

可以看到，这次执行就和前两种执行的结果不同，先执行了发短信，再执行打电话，因为我们这里的发短信方法是无锁方法，它不受锁的影响，而打电话方法由于休眠了2秒，所以是先输出发短信。

4、两个不同资源类对象操作两个方法（互不影响，各自执行）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建第1个资源类
        Phone phone1 = new Phone();
        //创建第2个资源类
        Phone phone2 = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone1.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.send();
        }).start();

    }
}
//资源类
class Phone{

    //打电话
    public synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }
    //发短信
    public synchronized void send(){
        System.out.println("发短信");
    }
}

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

这次的运行结果和3一样，先执行发短信，再执行打电话，和3的原理差不多，虽然这两个方法都是同步方法，但是锁的对象却不同，其中一个对象获得锁不影响另外一个对象获得锁。

5、同一个资源类对象操作两个静态同步方法（谁先获取到锁，谁先执行）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建第1个资源类
        Phone phone1 = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone1.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.send();
        }).start();

    }
}
//资源类
class Phone{
    //打电话
    public static synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }
    //发短信
    public static synchronized void send(){
        System.out.println("发短信");
    }
}

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

这里的运行结果和案例1、2一样，原理也差不多，只是锁的对象不同，案例1、2锁的是方法的调用者，而加了static的同步方法锁的是Class模板对象，一个类只会有一个Class模板对象，因此这里谁先获取到这个模板对象的锁谁就先执行。

6、同一个资源类对象，操作一个同步方法，一个静态同步方法（互不影响）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建第1个资源类
        Phone phone1 = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone1.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.send();
        }).start();
    }
}
//资源类
class Phone{

    //打电话
    public static synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

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

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

被static修饰锁的是class模板, 而synchronized 锁的是调用的对象，因此这两个锁的也是不同的对象，所以互不影响。

7、两个资源类对象操作两个静态同步方法（谁先获取到锁谁先执行）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建第1个资源类
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone1.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.send();
        }).start();

    }
}
//资源类
class Phone{

    //打电话
    public static synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }

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

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

只要方法被 static 修饰，被调用时，锁的对象就是 Class模板对象，这个则全局唯一，所以说这里锁的是同一个对象，并不是因为synchronized。

8、两个资源类对象，一个操作静态同步方法，一个操作同步方法（互不影响）

import java.util.concurrent.TimeUnit;
public class EightLock {
    public static void main(String[] args) {
        //创建第1个资源类
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        //创建两条线程，一个打电话，一个发短信
        new Thread(()->{
            phone1.call();
        }).start();
        //设置休眠（干扰）
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.send();
        }).start();

    }
}
//资源类
class Phone{

    //打电话
    public static synchronized void call(){
        //阻塞
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("打电话");
    }
    //发短信
    public synchronized void send(){
        System.out.println("发短信");
    }
}

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

只要被static 修饰的锁的就是整个class模板，而不被static修饰的就是调用者，这里一个锁的是class模板 一个锁的是调用者，所以锁的是两个对象，因此互不影响。

小结：

synchronized(Demo.class){
	//加了static锁的是Class模板对象
}
synchronized(this){
	//没加static锁的就是方法的调用者
}

在我们编写多线程程序的时候，只需要搞明白这个锁到底锁的是什么就不会出错了。

JohnGea
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第八章力复习题.doc
11-27
铅笔芯粉末加入锁中起润滑作用，减小摩擦。 【滑动摩擦力的测量】 通过弹簧秤拉着物体在水平面上做直线运动，当物体匀速运动时，拉力等于滑动摩擦力。如10题，当拉力为3.0牛时物体匀速运动，故滑动摩擦力为3.0牛。 ...
8八年级物理上册第二章 声现象综合课后练习二 .doc
11-29
5. 题六未给出具体选项，无法直接解析，但可能涉及声音传播的其他现象。 6. 题七探讨了声音的响度与振幅的关系，使用转换法观察音叉振动的幅度，同时需要控制实验条件，如声音的频率。 7. 题八是一个关于音调的...
JUC并发编程
weixin_46178009的博客
07-07 90
回顾 线程和进程 1.线程是在进程下进行的， 2.线程是进程的最小单位 3.一个进程是由多个线程组成的 4.Java默认的有两个线程：main、GC 5.Java真的可以开启线程吗？ 不可以，只能通过本地方法去调用，native本地方法，底层的C++，Java无法直接操作硬件。 并发和并行 解释一：并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔发生。 解释二：并行是在不同实体上的多个事件，并发是在同一实体上的多个事件。 解释三：并行是在多台处理器上同时处理多个任务。如
ARTS Share3 Java中的Synchronized
墨笙弘一
04-07 129
多线程程序经常会遇到一种问题，就是当多个线程试图访问同一个资源的时候，最后会产生不可预料的结果。因此，需要使用一些同步的措施来保证在一个给定的时间点只有一个线程可以来访问这个资源。 Java提供了一种使用synchronized块创建线程和同步其任务的方法。 Java中的同步块使用synchronized关键字标记。 Java中的同步块在某个对象上同步。 在同一对象上同步的所有同步块一次只能在其中...
面试官看了都说好的Synchronized详解
qq_46993700的博客
06-16 3477
互斥同步 Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 JVM 实现的 synchronized，而另一个是 JDK 实现的 ReentrantLock。 synchronized 1. 同步一个代码块 public void func() { synchronized (this) { // ... } } 它只作用于同一个对象，如果调用两个对象上的同步代码块，就不会进行同步。 对于以下代码，使用 ExecutorService 执行了两个线程，
Swing实现的带提示文本的验证文本框
manbusky的专栏
01-23 2186
import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import javax.swing.JTextField; public class JRichTextField extends JTextField { /** * */ pr
八锁现象彻底理解锁
harry034的博客
02-09 203
1、synchronized修饰方法时，锁的对象是方法的调用者。如果一个类里面两个方法都有synchronized修饰，且两个方法的调用者是同一个对象，那么两个方法用的是同一个锁，谁先拿到谁先执行。 所以当有调用者不是同一个对象的时候则锁的是不同对象 2、synchronized修饰静态方法时，类一加载就有了，锁的是Class。 ...
冬季八防安全考试题.pdf
12-24
15. **闪燃现象**：液体表面蒸汽与空气形成的可燃气体短暂燃烧即熄灭的现象称为闪燃。 16. **可燃物识别**：木材、硫、氯气都是可燃物，而氨气不是。 17. **火灾初期扑救**：火灾初期是最有利的扑救时机。 18. **...
苏教版八年级物理上册-声现象单元检测试题-.doc
10-06
标题和描述均指向一个针对八年级学生的物理试题，具体是"声现象"单元的检测试题。试题涵盖了声音的基本概念、声波的特性、声音的传播方式、声音的应用以及噪声控制等多个知识点。 【知识点详细说明】 1. **声音的...
八年级政治期中试题3.doc
10-30
这种心理在八年级的小华身上体现，表现为与父母对抗，可能是由于独立意识增强，追求自我认同的表现。 2. 子女角度的逆反心理原因：包括情绪难以控制、维护自尊心、追求个人兴趣和爱好。小华的行为可能源于这些因素...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 270
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1063
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 117
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 582
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
weixin_43561432的博客
07-24 341
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
Java的@DateTimeFormat注解与@JsonFormat注解的使用对比
訾博（ZiBo）的博客
07-27 708
在Spring和Jackson框架中，日期和时间格式化是一个常见需求。注解主要用于Spring的表单绑定，而注解则用于Jackson的JSON序列化和反序列化。了解这两个注解的使用场景和方法，可以帮助开发者更高效地处理日期和时间。和是处理日期和时间格式化的两个重要注解。主要用于Spring MVC的请求参数绑定，而主要用于Jackson的JSON序列化和反序列化。了解它们的使用场景和功能，可以帮助开发者更高效地处理日期和时间格式化需求。通过本文的介绍，希望读者能够更清晰地理解和。
Java代码基础算法练习-数的特性-2024.07.25
Sakurapaid的博客
07-25 395
小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 449
问题：编写一个方法，找出一个数组中的众数（出现次数超过数组长度一半的元素）。例如，输入 [2, 2, 1, 1, 2]，输出 2。编写一个方法，找出一个整数数组中的第二大元素。例如，输入 [3, 5, 1, 8, 7]，输出 7。例如，输入 5，输出 5。问题：编写一个方法，将给定的字符串逆转。问题：使用数组实现栈，并提供基本操作（push、pop、peek、isEmpty）。问题：实现一个单向链表，并提供基本的操作（添加、删除、查找元素）。问题：编写一个方法来查找一个给定字符串的所有子串。
新建springboot项目找不到java版本8?
weixin_74009895的博客
07-28 144
新建springboot项目找不到java版本8?
openwrt 22.03.5
07-28
根据引用\[2\]，编译完成后，你可以将OpenWrt 22.03.5版本烧写到设备上，并查看系统的现象。在引用中提供的示例输出中，可以看到BusyBox版本为v1.36.1，内置的shell为ash。此外，还提供了Linux内核版本为5.15.112的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值