synchronized - 八锁问题及扩展

最新推荐文章于 2024-09-20 16:00:20 发布
最新推荐文章于 2024-09-20 16:00:20 发布
阅读量999 收藏 8
点赞数 5
分类专栏： Java并发 文章标签： synchronized 对象锁 静态锁 重入锁 多线程同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40885085/article/details/110099014
版权

通过8锁问题，可以大致清楚synchronized是锁的什么东西。通过对8锁问题的扩展，可以进一步理解synchronized。

8锁问题

1、一个对象，两个synchronized方法，一个方法睡眠
public class LockTest {
    public static void main(String[] args) {
        Phone phone = new Phone();  // 一个Phone对象
        new Thread(() -> {
            phone.sendSms();
        },"A").start();
        new Thread(() -> {
            phone.call();
        },"B").start();
    }
}

class Phone{
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(1);  // 休眠1秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：1、发短信 2、打电话
原因：两个方法都被synchronized锁了，实际也就是锁的phone这个对象。A线程先拿到锁，sleep并不会释放锁。因此，只有当A线程执行完毕释放了锁，B拿到锁才能执行。

2、一对象，两synchronized方法，main方法里睡眠
public class LockTest {
    public static void main(String[] args) {
        Phone phone = new Phone();  // 一个Phone对象
        new Thread(() -> {
            phone.sendSms();
        },"A").start();
        try {
            TimeUnit.SECONDS.sleep(1);  // 休眠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("打电话");
    }
}

执行结果：1、发短信 2、打电话
原因：与第1中情况一样，锁的都是同一个对象，只有先拿到锁的才会先执行。

3、一对象，一synchronized方法，一普通方法
public class LockTest {
    public static void main(String[] args) {
        Phone phone = new Phone();  // 一个Phone对象
        new Thread(() -> {
            phone.sendSms();
        },"A").start();
        new Thread(() -> {
            phone.qq();
        },"B").start();
    }
}

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

    public void qq(){
        System.out.println("聊QQ");
    }
}

执行结果：1、聊QQ 2、发短信
原因：普通方法不受锁的影响，被锁住的方法休眠了2秒，但普通方法不受锁的影响，所以它会先执行。

4、两对象，两synchronized方法
public class LockTest {
    public static void main(String[] args) {
        Phone phone1 = new Phone();  // phone1
        Phone phone2 = new Phone();  // phone2
        new Thread(() -> {
            phone1.sendSms();
        },"A").start();
        new Thread(() -> {
            phone2.call();
        },"B").start();
    }
}

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

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

执行结果：1、打电话 2、发短信
原因：调用两个方法的是两个不同的对象，synchronized锁的也是不同对象，它们互不影响。

5、一个对象，两个静态synchronized方法
public class LockTest {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.sendSms();
        },"A").start();
        new Thread(() -> {
            phone.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);  // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    
    public static synchronized void call(){
        System.out.println("打电话");
    }
}

执行结果：1、发短信 2、打电话
原因：静态方法属于Class，Class对象全局唯一，一个类只有一个Class对象，因此这个synchronized锁的是Class。所以还是谁先拿到锁，谁先执行。

6、两对象，两synchronized静态方法
public class LockTest {
    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();
        new Thread(() -> {
            phone1.sendSms();
        },"A").start();
        new Thread(() -> {
            phone2.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);  // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

执行结果：1、发短信 2、打电话
原因：再次印证，静态方法锁的是Class。

7、一对象，一静态synchronized方法，一普通synchronized方法
public class LockTest {
    public static void main(String[] args) {
        Phone1 phone = new Phone();
        new Thread(() -> {
            phone1.sendSms();
        },"A").start();
        new Thread(() -> {
            phone1.call();
        },"B").start();
    }
}

class Phone{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);  // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}

执行结果：1、打电话 2、发短信
原因：sendSms方法的synchronized是锁的Class对象，而call方法的synchronized是锁的phone1对象。因此两个方法在上诉代码中的调用，各自持有一把锁，互不影响。

8、两对象，一静态synchronized方法，一普通synchronized方法
public class LockTest2 {
    public static void main(String[] args) {
        Phone1 phone1 = new Phone1();
        Phone1 phone2 = new Phone1();
        new Thread(() -> {
            phone1.sendSms();
        },"A").start();
        new Thread(() -> {
            phone2.call();
        },"B").start();
    }
}

class Phone1{
    public static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(2);  // 休眠2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}

执行结果：1、打电话 2、发短信
原因：再次印证static的synchronized锁的是Class对象

8锁结论

一个对象只有一把锁，加锁的普通方法，谁先抢到锁，谁先执行。
静态的加锁方法，锁的是Class对象，Class对象全局唯一。

synchronized的扩充问题

1、当被锁的对象发生变化的时候
public class Synchronized1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.changed();
        },"A线程").start();

        try{
            TimeUnit.SECONDS.sleep(2);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        Thread thread = new Thread(() -> {
           phone.changed();
        },"B线程");
        System.out.println(phone.object);
        // object对象发生了变化
        phone.object = new Object();
        System.out.println(phone.object);
        // 如果锁的对象发生改变，则相当于锁的是一个新的对象了
        thread.start();
    }
}

class Phone{
    Object object = new Object();

    public void changed(){
        // 锁的是object对象
        synchronized (object){
            while (true){
                try{
                    TimeUnit.SECONDS.sleep(2);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            }
        }
    }

}

在这里插入图片描述

当被锁的对象发生改变，则表示又锁了一个新的对象，应该避免将锁定对象的引用改变。如果只是改变对象的属性，则不会有影响。

2、以字符串常量作为锁定对象的时候
public class Synchronized1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.helloWorld();
        },"A").start();
        new Thread(() -> {
            phone.worldHello();
        },"B").start();
    }
}

class Phone{
    // 两个字符串引用都是指向常量池中的同一个字符串
    String str1 = "hello";
    String str2 = "hello";

    public void helloWorld(){
        synchronized (str1){
            System.out.println("str1 运行！");
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("str1 2秒后结束！");
        }
    }

    public void worldHello(){
        synchronized (str2){
            System.out.println("str2 运行！");
        }
    }
}

在这里插入图片描述
因为str1和str2都是指向字符串常量池中的同一个字符串，所以不管锁的是str1还是str2，都是锁的同一个对象。

3、synchronized方法里调用synchronized方法
public class Synchronized1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.one();
    }
}

class Phone{
    synchronized void one(){
        System.out.println("one func start...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        two();
    }

    synchronized void two(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("two func start...");
    }
}

在这里插入图片描述
可以调用到，因为synchronized是可重入锁。

4、继承情况下的重入锁
public class Synchronized1 {
    public static void main(String[] args) {
        MobilePhone mobilePhone = new MobilePhone();
        mobilePhone.phone();
    }
}

class Phone{
    synchronized void phone(){
        System.out.println("Phone Start...");
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Phone End...");
    }
}

class MobilePhone extends Phone{
    @Override
    synchronized void phone() {
        System.out.println("MobilePhone Start...");
        super.phone();
        System.out.println("MobilePhone End...");
    }
}

在这里插入图片描述

5、异常情况下的synchronized
public class Synchronized1 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(() -> {
            phone.test();
        },"A线程").start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.test();
        },"B线程").start();
    }
}

class Phone{
    int count = 0;

    synchronized void test(){
        System.out.println(Thread.currentThread().getName() + " Start...");
        while(true){
            count++;
            System.out.println(Thread.currentThread().getName() + "的count = " + count);
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(count == 5){
                try {
                    // 如果这里的异常没有被捕获处理，则会释放锁
                    int i = 1 / 0;
                }catch (Exception e){
                    System.out.println("异常处理！");
                }
            }
        }
    }
}

在这里插入图片描述
如果synchronized修饰的块里有地方出现异常，如果不去捕获处理这个异常，synchronized锁会被主动释放掉。如果捕获处理这个异常之后，这个锁就不会主动释放。

九月清晨柳成荫
关注
专栏目录
synchronized8锁问题
zds448588952的博客
06-09 153
synchronized8锁问题
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 493
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
Java 并发编程全面解析
最新发布
m0_57836225的博客
09-20 972
线程池的性能优化方法包括合理设置线程池的参数、使用合适的队列类型、选择合适的拒绝策略、避免任务的过度提交等。合理设置线程池的参数可以提高线程的利用率，降低系统的资源消耗。在 JDK 21 中，虚拟线程是一种轻量级的线程实现，它可以在不消耗大量系统资源的情况下创建大量的线程。虚拟线程是由 Java 运行时自动管理的，它们可以在需要的时候被创建和销毁，而不需要开发者手动管理线程的生命周期。虚拟线程的实现基于协程的概念，它们可以在用户空间中进行切换，而不需要进行系统调用，从而提高了线程的创建和切换效率。
synchronized八锁现象理解
lczcxyit的博客
04-19 1877
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronized锁——8锁
weixin_34413065的博客
04-08 163
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 503
关于锁的8个问题前言例子1例子2例子3例子4 前言 synchronize的8锁现象，其实就是利用锁的8种应用场景的代码，带你彻底搞懂： synchronized 锁的对象是方法的调用者 下面我们开始看例子 例子1 public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //这里注意不是先调用 phone.sendSms()，而是因为锁的存在
8锁问题和Synchronized
qq_37032116的博客
06-08 246
8锁问题和Synchronized的底层原理
synchronized锁升级流程（偏向锁、轻量级锁-锁自旋、重量级锁）
撸起袖子加油干
05-27 529
一、synchronized优化
13 - synchronized 同步互斥锁
pizicai007的博客
06-25 805
并发编程之 Synchronized 关键字：解决原子性1. Synchronized 使用1.1 线程安全问题1.2 Synchronized 概念1.3 Synchronized 的作用范围2. Synchronized 原理2.1 同步代码块2.2 同步方法2.3 Monitor2.3.1 Monitor 是什么2.3.2 Monitor 如何实现线程同步3. 解决三大问题：原子性、可见性和有序性3.1 保证原子性3.2 保证有序性3.3 保证可见性 1. Synchronized 使用 1.1 线程
多线程复习总结之解析Synchronized与重入锁
weixin_45974176的博客
04-17 2509
10分钟搞懂synchronized和重入锁
Java并发编程-synchronized关键字详解及案例实战
program哲学
06-30 390
详细介绍synchronized关键字及相关应用案例实战（微服务注册中心为例）
Java并发编程实践-07章-显示锁1
08-03
`ReentrantLock`是Java 5.0引入的，作为对`synchronized`关键字的一种扩展。 7.1. `Lock`和`ReentrantLock` `Lock`接口定义了一套锁操作，它允许开发者显式地控制线程的同步，提供了比内置锁更多的功能。`Lock`接口...
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1553
synchronized关键字到底锁的是谁？
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 178
1
synchronized的线程八锁问题
蒋大钊的博客
02-04 533
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
第二章 多线程入门之高级
黑魔仙小月的博客
05-13 809
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
Java 多线程中用 synchronized 加锁的八锁问题
Ironhide的博客
09-14 416
看以下代码，有一个 phone 对象，A、B 线程分别调用该对象的方法，问两个方法谁先调用？答：先发短信再打电话，因为 synchronized 锁住的是 phone 对象（锁的对象是方法调用者）。 public static void main(String[] args) throws InterruptedException { phone phone = new phone(); new Thread(() -> { phone.sendMsg(); .
【程序员必知必会】线程8锁现象：让你彻底理解synchronized到底锁了什么
qq_35754976的博客
12-21 691
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值