八锁现象（彻底理解什么是锁）

最新推荐文章于 2024-08-24 22:01:16 发布
最新推荐文章于 2024-08-24 22:01:16 发布
阅读量101 收藏 1
点赞数 1
分类专栏： JUC并发编程 文章标签： java JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CNpeaceful/article/details/132628953
版权

本文主要介绍常见面试题，JUC并发编程中的八锁现象。通过这篇文章，可以让你彻底搞清楚锁对象或者是锁方法的不同之处！

问题一：标准情况下，一个对象，两个同步方法先执行哪一个？

1、测试代码：

public class Test01 {
    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 {

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

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

控制台打印结果：
先打印发短信，等待一秒后打印打电话

2、总结
Synchronized锁，锁的是对象的调用者，因为这两个线程同时用的一个对象phone，那么谁先拿到这把锁，谁就执行对应的方法

问题二：给其中一个同步方法加一个2秒的延时，先执行哪一个方法？

1、测试代码

public class Test01 {
    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 {

    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}


控制台打印结果：
延迟2秒后，打印顺序为发短信  打电话

2、总结
Synchronized锁，锁的是对象的调用者，因为这两个线程同时用的一个对象phone，那么谁先拿到这把锁，谁就执行对应的方法

问题三：资源类中增加普通方法，先执行加锁的还是普通的方法？

1、测试代码

public class Test02 {
    public static void main(String[] args) {
        //创建资源对象
        Phone2 phone = new Phone2();
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();
        //模拟延时
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.hello();
        }, "B").start();

    }

}

//资源类
class Phone2 {

    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秒钟打印发短信

2、总结
普通方法没有加Synchronized锁，那么他就不是同步方法，不受锁的影响

问题四：创建两个对象，都执行同步方法，先执行哪一个？

1、测试代码

public class Test02 {
    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();

    }

}

//资源类
class Phone2 {

    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");
    }
}

控制台打印结果：
先打印打电话，过了4秒钟打印发短信

2、总结

Synchronized锁的是对象的调用者，因为我们创建了两个对象，那么就会有两把锁，锁不一样，就按照他们各自的延迟时间执行，互不影响

问题五：增加两个静态的同步方法，两个线程调用，先执行哪一个？

1、测试代码

public class Test03 {
    public static void main(String[] args) {
        //创建资源对象
        Phone3 phone = new Phone3();
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

        //模拟延时
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.call();
        }, "B").start();

    }
}

//资源类
class Phone3 {
    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("打电话");
    }
}


控制台打印结果：
等待4秒钟打印发短信，紧接着执行打电话

2、总结

和问题一对比学习！
其一是Synchronized锁的对象是方法的调用者，因为只创建了一个对象，那么谁先拿到锁，谁先执行
其二是因为加了Static关键字，该方法就变成了静态方法，随着类的加载而加载，那么这个测试中的锁锁的是Class这个模板，Class模板全局唯一，也就是说他们还是共用一把锁，谁先拿到锁，谁先执行方法


问题六：创建两个对象，调用两个静态同步方法，先执行哪一个？

1、测试代码

public class Test03 {
    public static void main(String[] args) {
        //创建资源对象
        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();

    }
}

//资源类
class Phone3 {
    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("打电话");
    }
}

控制台打印结果：
和问题四执行结果相同，等待4秒钟打印发短信，紧接着执行打电话

2、总结
出现和问题四相同的执行结果的原因是Synchronized锁的是两个静态的方法，静态方法随着类的加载而加载，尽管我们创建了两个对象，但是他们的Class模板全局唯一，Synchronized锁锁的是这个唯一的Class模板，因此他们还是共用一把锁，所以还是先执行先得到锁的发短信方法，尽管他有4秒的延时。

问题七：一个静态同步方法，一个普通同步方法，一个对象，先执行哪个方法呢？

1、测试代码

public class Test04 {
    public static void main(String[] args) {
        //创建资源对象
        Phone4 phone = new Phone4();
        new Thread(() -> {
            phone.sendSms();
        }, "A").start();

        //模拟延时
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(() -> {
            phone.call();
        }, "B").start();

    }
}

//资源类
class Phone4 {
    //静态同步方法
    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("打电话");
    }
}

控制台打印结果：
先打印打电话，等待4秒后执行发短信

2、总结
静态同步方法锁的是Class模板，而普通同步方法锁的是对象的调用者，本质上是两把锁，执行的时候互不影响，按照他们本身的延迟时间进行先后的执行

问题八：两个对象，一个静态同步方法，一个普通同步方法，先执行哪一个？

1、测试代码

public class Test04 {
    public static void main(String[] args) {
        //创建资源对象
        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();

    }
}

//资源类
class Phone4 {
    //静态同步方法
    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("打电话");
    }
}


控制台打印结果：
先打印打电话，等待4秒后执行发短信方法

2、总结
还是同样的道理，静态同步方法锁的是Class模板，而普通同步方法锁的是对象的调用者，本质上还是两把锁，尽管我们创建了两个对象，但是依旧不改变两把锁的根本，所以执行结果是先打印打电话，等待4秒后执行发短信方法。

总结

主要就是搞清楚锁的对象是什么，new出来的是具体的对象，可以不唯一，但是通过static修饰的同步方法，是锁的全局唯一的Class模板

Be explorer
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
八锁现象彻底理解锁
LIAO_YUANLONG的博客
12-17 684
如何判断锁的是谁？知道什么是锁？ 1.标准情况下，两个线程先打印发短信还是打电话？—》发短信 2.sendMag延迟四秒，两个线程先打印发短信还是打电话？—》发短信 package com.liao.Lock8; import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？---》发短信 * 2.sendMag延迟四秒，两个线程先打印发短信还是打电话？---》发短信 */ public cla
JUC详解-4-八锁现象彻底理解锁
baidu_38126306的博客
11-11 228
JUC详解 -> 八锁现象 如何判断锁的是谁？ import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 * 2.sendSms()延迟4秒，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 */ public class Test01 { public static void main(String[] args)
狂神JUC——8锁现象彻底理解锁
黄坤的博客
06-02 931
1-2锁 package com.company.lock_8; /** * 8锁问题，就是关于锁的8个问题！，判断锁的是谁 */ import java.util.concurrent.TimeUnit; /** * 1.标志情况下，两个线程先打印，发短信？ 打电话？ * 2.sendSms延迟4秒，两个线程先打印，发短信？ 打电话？ */ public class Lock_1To2 { public static void main(String[] args) throw.
Java 八锁详解
NULL
11-23 860
1),标准访问,请问先打印 邮件 还是短信? /** synchronized 和 lock 一样我这里用的是 lock*/ class phone { Lock lock = new ReentrantLock(); void sendMAIL(){ lock.lock(); try { System.out.println("---------sendMAIL"); } catch (Exception e
线程八锁问题超简单理解
weixin_45953000的博客
11-15 242
在并发的环境中，锁机制一个良好的控制同步的方法，使用synchronize关键字对临界资源的锁，在普通的成员方法中添加锁的是调用该方法的对象public synchronized void Sem(){//普通同步的发邮件的方法 System.out.println("发邮件"); }，而在静态方法中使用 则锁的整个类对象（类对象是在class加载的时候进行创建的，每一个类只用有一个）public static synchronized void Sem(){//普通同步的发邮件的方法 System.out
thinkPHP框架乐观锁和悲观锁实例分析
10-16
另外，如果事务处理不当，比如忘记释放锁，或者事务回滚不彻底，都可能导致死锁的情况发生。 在ThinkPHP框架中使用悲观锁时，需要注意锁的粒度。尽量使用行锁而非表锁，因为表锁会影响到更多的行，降低并发性能。...
欧乐酷u1硬格解锁
11-08
由于【部分内容】中的文字似乎出现了乱码现象，我们将主要依据标题、描述以及标签来展开相关的知识点。 ### 欧乐酷U1硬格解锁 #### 一、什么是硬格解锁？ 在移动设备领域，“硬格”或称为“硬重启”，是指通过...
Oracle删除死锁进程的方法
12-16
5. **锁类型和模式**：Oracle中有多种锁类型，如行级锁、表级锁等，不同的锁定模式（如共享锁、独占锁）会导致不同的并发问题，理解这些概念对于避免死锁至关重要。 6. **事务管理**：良好的事务管理是防止死锁的...
彻底搞清楚library cache lock的成因和解决方法
05-18
### 彻底理解 Oracle 中 Library Cache Lock 的成因与解决办法 #### 一、引言 在日常数据库管理工作中，经常会遇到一些让人头疼的问题，比如会话挂起（hang）。其中一个常见的情况是当用户尝试执行某些操作时，比如...
2021面试题总结MySQL篇.pdf
01-27
- **定义**：最高级别的隔离级别，确保所有 SQL 操作按顺序执行，彻底解决脏读、不可重复读及幻读等问题。 - **特点**：虽然能保证数据一致性，但性能较低。 ### 幻读 - **定义**：在同一事务下，连续执行相同的 ...
阿里云服务器 篇七：服务器热备份/定时备份
最新发布
生活在别处
08-24 69
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 501
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Yolov8：模型部署到安卓端
m0_70694811的博客
08-21 760
下载安装jdk-8u202-windows-x64.exe，这篇文章有百度网盘资源链接，直接下载，并按照这篇文章的JDK步骤进行安装和环境变量配置。C:\Program Files\Java\jdk-1.8\bin和C:\Program Files\Java\jdk-1.8\jre\bin。比如因为我的jdk路径是C:\Program Files\Java\jdk-1.8，所以这两个相对路径就改成。参考这边文章的USB驱动设置和手机端设置。同意协议后，下载相应版本的JDK。
笔记redis
风止的博客
08-22 1041
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 694
linux上datax 安装以及使用
二叉树(源码+lw+部署文档+讲解等)
lpw1012的博客
08-21 722
🌞博主介绍：✌全网粉丝15W+,CSDN特邀作者、211毕业、高级全栈开发程序员、大厂多年工作经验、码云/掘金/华为云/阿里云/InfoQ/StackOverflow/github等平台优质作者、专注于Java、小程序技术领域和毕业项目实战，以及程序定制化开发、全栈讲解、就业辅导✌🌞👇🏻精彩专栏 推荐订阅👇🏻2023-2024年最值得选的微信小程序毕业设计选题大全：100个热门选题推荐✅2023-2024年最值得选的Java毕业设计选题大全：500个热门选题推荐✅Java精品实战案例《500套》
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 732
@Transactional中使用线程锁导致了锁失效与解决方案
android apk 加固后的地图加载异常及重新签名
calivnBao的博客
08-20 264
android apk 加固后的地图加载异常及重新签名
如何使用 Java 记录简化 Spring Data 中的数据实体
08-20 617
Java 开发人员一直依赖Spring Data来实现高效的数据访问。但是，随着Java Records的引入，数据实体的管理方式发生了重大变化。在本文中，我们将讨论 Java Records 在 Spring Data 应用程序中的集成。我们将探讨使用 Java 记录创建健壮的数据实体的好处，并提供真实世界的示例来展示它们在 Spring Data 中的潜力。Java 记录的力量：概述J...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Be explorer

若认可笔者文章，手头富裕望支持

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

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

打赏作者

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

抵扣说明：

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

余额充值