synchronized - 八锁问题及扩展

最新推荐文章于 2023-05-24 09:08:42 发布
最新推荐文章于 2023-05-24 09:08:42 发布
阅读量969 收藏 8
点赞数 5
分类专栏： Java并发 文章标签： synchronized 8锁问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40885085/article/details/110099014
版权

synchronized 对象锁 静态锁 重入锁 多线程同步
关键词由CSDN通过智能技术生成

通过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锁会被主动释放掉。如果捕获处理这个异常之后，这个锁就不会主动释放。

九月清晨柳成荫
关注
专栏目录
Java并发编程-synchronized关键字详解及案例实战
program哲学
06-30 351
详细介绍synchronized关键字及相关应用案例实战（微服务注册中心为例）
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 478
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
synchronized8锁问题
zds448588952的博客
06-09 132
synchronized8锁问题
synchronized八锁现象理解
lczcxyit的博客
04-19 1853
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronized锁——8锁
weixin_34413065的博客
04-08 151
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 491
关于锁的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()，而是因为锁的存在
13 - synchronized 同步互斥锁
pizicai007的博客
06-25 782
并发编程之 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锁升级流程（偏向锁、轻量级锁-锁自旋、重量级锁）
撸起袖子加油干
05-27 514
一、synchronized优化
多线程复习总结之解析Synchronized与重入锁
weixin_45974176的博客
04-17 2482
10分钟搞懂synchronized和重入锁
Java并发编程实践-07章-显示锁1
08-03
`ReentrantLock`是Java 5.0引入的，作为对`synchronized`关键字的一种扩展。 7.1. `Lock`和`ReentrantLock` `Lock`接口定义了一套锁操作，它允许开发者显式地控制线程的同步，提供了比内置锁更多的功能。`Lock`接口...
8锁问题和Synchronized
qq_37032116的博客
06-08 229
8锁问题和Synchronized的底层原理
八锁现象——synchronized关键字实战详解
最新发布
欢迎。
05-24 1531
synchronized关键字到底锁的是谁？
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 164
1
synchronized的线程八锁问题
蒋大钊的博客
02-04 522
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
第二章 多线程入门之高级
黑魔仙小月的博客
05-13 796
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
Java 多线程中用 synchronized 加锁的八锁问题
Ironhide的博客
09-14 406
看以下代码，有一个 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 667
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
多线程synchronized对象锁与静态锁之间的8锁问题理解
m0_52889702的博客
02-02 618
8锁问题 锁1：多个线程使用同一对象分别调用不同带有带synchronized关键字且非静态的方法 锁2：在锁1基础上，增加A线程执行的方法的执行时间，使得B有机会参与执行 锁3：多个线程使用同一对象，一个线程执行带有对象锁的方法，一个线程执行普通方法 锁4：多个线程使用不同对象分别调用不同带有对象锁的方法 锁5：多个线程同一个对象分别调用对各自静态锁的方法 锁6：多个线程同多个对象分别调用对各自静态锁的方法 锁7：多个线程同一个对象分别调用对象锁的方法和静态锁的方法 锁8：多个线程不同对象分别调用对象锁的
synchronized与Lock实现详解：加锁与解锁的关键
首先，`synchronized`在Java中是一种内置的同步机制，通常用于控制对共享资源的访问，其语法是在方法或代码块前加上`synchronized`关键字，锁对象默认为当前对象（即`this`）。 方式一和方式二展示了`synchronized`...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值