八锁现象彻底理解锁

最新推荐文章于 2024-09-30 10:36:33 发布
最新推荐文章于 2024-09-30 10:36:33 发布
阅读量689 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LIAO_YUANLONG/article/details/121999497
版权

如何判断锁的是谁？知道什么是锁？
1.标准情况下，两个线程先打印发短信还是打电话？—》发短信
2.sendMag延迟四秒，两个线程先打印发短信还是打电话？—》发短信

package com.liao.Lock8;
import java.util.concurrent.TimeUnit;
/**
 * 八锁：就是关于锁的八个问题
 * 1.标准情况下，两个线程先打印发短信还是打电话？---》发短信
 * 2.sendMag延迟四秒，两个线程先打印发短信还是打电话？---》发短信
 */
public class Test1 {
    public static void main(String[] args) {
        //调用者
        Phone phone = new Phone();
        new Thread(()->{
            phone.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.Call();
        },"B").start();
    }
}
class Phone{
    //synchronized 锁的对象是方法的调用者！phone
    //两个方法用的是同一个锁，谁先拿到谁就执行
    public synchronized void sendMag(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void Call(){
        System.out.println("打电话");
    }
}

2.增加一个普通方法后，先输出hello，因为hello是普通方法，这里没有锁，不是同步方法，不受锁的影响！

package com.liao.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3.增加一个普通方法后，先执行发短信还是先hello？---》hello
 */
public class Test2 {
    public static void main(String[] args) {
        //调用者，两个对象
        Phone1 phone = new Phone1();
        new Thread(()->{
            phone.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone.hello();
        },"B").start();
    }
}
class Phone1{
    //synchronized 锁的对象是方法的调用者！phone
    //
    public synchronized void sendMag(){
        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");
    }
}

3.当对象变成两个以后，两个同步方法，先执行发短信还是先打电话？—》打电话，因为两个对象拿的锁不一样，没有延迟的先执行

package com.liao.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 3.增加一个普通方法后，先执行发短信还是先hello？---》hello
 * 4.两个对象，两个同步方法，先执行发短信还是先打电话？---》打电话
 */
public class Test2 {
    public static void main(String[] args) {
        //调用者，两个对象，两把锁
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(()->{
            phone1.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.Call();
        },"B").start();
    }
}
class Phone1{
    //synchronized 锁的对象是方法的调用者！phone
    //
    public synchronized void sendMag(){
        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");
    }
}

4.增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话-----》发短信，static 静态方法，类一加载就有了，锁的是Class对象，Phone3只有一个Class对象

package com.liao.Lock8;

import java.util.concurrent.TimeUnit;
/**
 * 5.增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话-----》发短信
 */
public class Test3 {
    public static void main(String[] args) {
        //调用者
        Phone2 phone1 = new Phone2();
        new Thread(()->{
            phone1.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.Call();
        },"B").start();
    }
}
class Phone2{
    //synchronized 锁的对象是方法的调用者！phone
    //static 静态方法
    //类一加载就有了，锁的是Class对象
    //Phone3只有一个Class对象
    public static synchronized void sendMag(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void Call(){
        System.out.println("打电话");
    }
}

5.两个对象！两个静态的同步方法，两个对象，先打印发短信还是打电话-----》发短信，两个对象的Class类模板只有一个，static，锁的是Class

package com.liao.Lock8;

import java.util.concurrent.TimeUnit;
/**
 * 5.增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话-----》发短信
 * 6.两个对象！两个静态的同步方法，两个对象，先打印发短信还是打电话-----》发短信
 */
public class Test3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static，锁的是Class
        Phone2 phone1 = new Phone2();
        Phone2 phone2 = new Phone2();
        new Thread(()->{
            phone1.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.Call();
        },"B").start();
    }
}
class Phone2{
    //synchronized 锁的对象是方法的调用者！phone
    //static 静态方法
    //类一加载就有了，锁的是Class对象
    //Phone3只有一个Class对象
    public static synchronized void sendMag(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public static synchronized void Call(){
        System.out.println("打电话");
    }
}

6.一个静态同步方法，一个普通同步方法，先发短信还是打电话—》打电话,普通同步方法，锁的调用者，static锁的Class，两把锁不一样，所以不需要等待

package com.liao.Lock8;
import java.util.concurrent.TimeUnit;
/**
 * 7.一个静态同步方法，一个普通同步方法，先发短信还是打电话---》打电话
 *
 */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        new Thread(()->{
            phone1.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone1.Call();
        },"B").start();
    }
}
class Phone3{
    //synchronized 锁的对象是方法的调用者！phone
    //static 静态方法
    //类一加载就有了，锁的是Class对象
    //
    public static synchronized void sendMag(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通同步方法，锁的调用者
    public synchronized void Call(){
        System.out.println("打电话");
    }
}

7.一个静态同步方法，一个普通同步方法，两个对象，先发短信还是打电话—》打电话,和第七个一样，普通同步方法，锁的调用者，static锁的Class，两把锁不一样，所以不需要等待

package com.liao.Lock8;

import java.util.concurrent.TimeUnit;

/**
 * 7.一个静态同步方法，一个普通同步方法，先发短信还是打电话---》打电话
 * 8.一个静态同步方法，一个普通同步方法，两个对象，先发短信还是打电话---》打电话
 *
 */
public class Test4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static，锁的是Class
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();
        new Thread(()->{
            phone1.sendMag();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(()->{
            phone2.Call();
        },"B").start();
    }
}
class Phone3{
    //synchronized 锁的对象是方法的调用者！phone
    //static 静态方法
    //类一加载就有了，锁的是Class对象
    //
    public static synchronized void sendMag(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    //普通同步方法，锁的调用者
    public synchronized void Call(){
        System.out.println("打电话");
    }
}
Marlboro~
关注
【程序员必知必会】线程8锁现象：让你彻底理解synchronized到底锁了什么
qq_35754976的博客
12-21 670
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
JavaSE之8锁现象线程彻底理解锁
weixin_46036165的博客
05-31 187
8锁现象线程彻底理解锁 利用8道题，搞定锁这个概念！ 1.问题一 package com.coding.lock8; import java.util.concurrent.TimeUnit; /* 1、标准的访问情况下，先执行 sendEmail 还是 sendSMS 答案：sendEmail 被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个 先调用的先执行！ */ public class LockDemo01 {
JUC详解-4-八锁现象彻底理解锁
baidu_38126306的博客
11-11 244
JUC详解 -> 八锁现象 如何判断锁的是谁？ import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 * 2.sendSms()延迟4秒，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 */ public class Test01 { public static void main(String[] args)
9、8锁现象彻底的理解锁（锁的只有两个东西，一个是对象，一个是Class模板（static修饰））
分享java学习路上的一些笔记，不足之处多多见谅。
11-15 258
问题三：（我们在资源类中在给他一个没有锁的方法。问题7：（一个静态同步方法（static syn（休眠4s）），一个普通同步方法（syn），然后只有一个对象，两个线程使用）（先打电话，再等4s输出发短信）问题8：（一个静态同步方法（static syn（休眠4s）），一个普通同步方法（syn），然后两个实例对象）（还是先打电话，再等4s才是发短信）问题4：（我们准备两个对象，一个线程让对象1去调用发短信（还是睡眠4s的），一个线程让对象2去调用打电话）（这里是先打电话再等4s输出发短信了）
java的8锁问题
toBeMN的博客
04-13 2669
正经学徒，佛系记录，不搞事情 8锁即8个关于锁执行顺序的问题 解决问题前，首先需要明白的是 synchronized 只会锁两样东西，一样是调用的对象，一样是Class 问题一：两个普通的锁方法，new一个对象调用，调用过程中间睡1秒，执行结果是什么 public class Test { public static void main(String[] args) thro...
thinkPHP框架乐观锁和悲观锁实例分析
10-16
另外，如果事务处理不当，比如忘记释放锁，或者事务回滚不彻底，都可能导致死锁的情况发生。 在ThinkPHP框架中使用悲观锁时，需要注意锁的粒度。尽量使用行锁而非表锁，因为表锁会影响到更多的行，降低并发性能。...
MySQL 锁原理通过 6 个死锁案例，让你彻底理解 MySQL 锁机制，死锁的原因！
2401_83816970的博客
04-19 1090
就写到这了，也算是给这段时间的面试做一个总结，查漏补缺，祝自己好运吧，也希望正在求职或者打算跳槽的 程序员看到这个文章能有一点点帮助或收获，我就心满意足了。多思考，多问为什么。希望小伙伴们早点收到满意的offer!越努力越幸运！金九银十已经过了，就目前国内的面试模式来讲，在面试前积极的准备面试，复习整个 Java 知识体系将变得非常重要，可以很负责任的说一句，复习准备的是否充分，将直接影响你入职的成功率。
【能彻底理解Java中的各种锁】这份笔记功不可没
ZXZN027的博客
05-15 308
彻底理解Java中的各种锁## 标题 1 乐观锁 CAS 2 悲观锁 synchronized、vector、hashtable 3 自旋锁 CAS 4 可重入锁 synchronized、Reentrantlock、Lock 5 读写锁 ReentrantReadWriteLock，CopyOnWriteArrayList、CopyOnWriteArraySet 6 公平锁 Reentrantlock(true) 7 非公平锁 synchronized、reentrantlock(false) 8 共享锁
【数据库】数据库的锁机制及原理
热门推荐
Zoom
03-08 5万+
数据库的锁机制，今天彻底理清楚。文章中有参考整理其他一些有价值的博客以及mysql官方文档的内容，如有侵权请联系删除。 数据库锁 先看一张图自己整理的数据库锁的树形图 概要 数据库锁一般可以分为两类，一个是悲观锁，一个是乐观锁。 乐观锁一般是指用户自己实现的一种锁机制，假设认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲...
Java并发4——八锁现象
weixin_51818357的博客
07-25 170
Java并发之八锁现象 1.这么说吧，如果两个都是普通方法，那么就看谁先调用，一般先调用先执行 2.如果都是普通方法，但是有加延时，那么就延时少的先调用(因为时间是差不多同时调用，但是一个延时4秒再执行，一个延时2秒再执行，肯定2秒的先执行出来） 3.如果加锁的话，无延时，仍然是谁先调用谁执行 4.如果加锁加延时的话，延时不管，谁先调用谁执行，管它延不延时，反正没执行完不出来，这就是锁的作用 锁的是对象，没结束，锁不释放 （这里先后调用看的是 程序中先调用了哪个方法的线程） 5.两个对象，两把锁，不存在锁的
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2102
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
Java 八锁详解
NULL
11-23 868
1),标准访问,请问先打印 邮件 还是短信? /** synchronized 和 lock 一样我这里用的是 lock*/ class phone { Lock lock = new ReentrantLock(); void sendMAIL(){ lock.lock(); try { System.out.println("---------sendMAIL"); } catch (Exception e
Java中的八种锁
chou_out_man的博客
11-16 1497
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
工厂模式的介绍及实现
户伟伟的博客
09-25 154
工厂模式（Factory Pattern）是一种创建型设计模式，提供了一种创建对象的接口，而无需显式指定对象的具体类。在这种模式中，我们通过定义一个工厂类，专门负责生产各种类型的对象，这样我们可以避免直接在代码中实例化具体类，使代码更具扩展性、灵活性和维护性。解耦：客户端代码与具体的类解耦，避免了对象创建逻辑的重复。简化对象创建：通过工厂统一管理对象的创建逻辑，使代码更清晰易懂。扩展性强：新增类时，只需在工厂中增加创建逻辑，而不必修改现有的业务代码。
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 558
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
最新发布
Lxn2zh的博客
09-30 423
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
JPA+Thymeleaf增删改查
y050505的博客
09-25 502
在使用JPA（Java Persistence API）和Thymeleaf作为模板引擎进行Web开发时，实现增删改查（CRUD）操作是一个常见的需求。下面，我将简要介绍如何使用Spring Boot框架结合JPA和Thymeleaf来实现这一功能。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 998
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
闭锁静电放电：理解与防护策略
闭锁，也称为闩锁或锁死，是一种可能导致集成电路（IC）性能受损的现象。闭锁通常发生在CMOS电路中，由于某些原因，如过度电压或电流，导致电路内部的寄生元件（如寄生晶闸管）意外导通，使得电流在电路内部形成环路...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Marlboro~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值