synchronized 八锁现象，搞懂 synchronized 的使用问题

最新推荐文章于 2023-02-24 21:59:05 发布
最新推荐文章于 2023-02-24 21:59:05 发布
阅读量351 收藏 1
点赞数 1
分类专栏： 学习笔记 文章标签： java 并发编程 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34217386/article/details/120719119
版权

前言

synchronized 八锁现象，就是 synchronized 使用中的八个问题，下面我们一一了解下。

一.同一个对象，两个线程分别调用对象的两个加锁方法

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    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{

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

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

}

运行结果
在这里插入图片描述
结论：
synchronized 在普通方法上修饰时，锁的对象是方法调用者，该示例中都是同一对象 phone 调用两个用 synchronized 修饰的普通方法 sendSms call，所以哪个线程先拿到锁哪个线程就先执行。

二.同一个对象，两个线程分别调用对象的两个加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    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{

    synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
synchronized 在普通方法上修饰时，锁的对象是方法调用者，该示例中都是同一对象 phone 调用两个用 synchronized 修饰的普通方法 sendSms call，所以哪个线程先拿到锁哪个线程就先执行。

三.同一个对象，两个线程分别调用对象的加锁方法和无锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    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::hello,"B").start();

    }

}

class Phone{

    synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

    void hello(){
        System.out.println("----hello----");
    }

}

运行结果
在这里插入图片描述
结论：
hello 方法未加锁，所以不受锁的限制，线程 B 延迟1秒后将直接执行 hello 方法，无需等待线程 A。

四.不同对象，调用各自的加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(phone1::sendSms,"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(phone2::call,"B").start();

    }

}

class Phone{

    synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
synchronized 在普通方法上修饰时，锁的对象是方法调用者，该示例中对象 phone1 调用 sendSms 方法，对象 phone2 调用 call 方法，sendSms 方法锁的是 对象 phone1 ， call 方法锁的是对象 phone2 ，是两把不同的锁，互不影响。

五.同一个对象，两个线程分别调用对象的两个静态加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    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{

    static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
synchronized 在静态方法上修饰时，锁的对象是 Class，该示例中同一对象 phone 调用两个用 synchronized 修饰的静态方法 sendSms call，为同一把锁，所以从上到下执行。

六.不同对象，调用各自的静态加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }

}

class Phone{

    static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
synchronized 在静态方法上修饰时，锁的对象是 Class，该示例中对象 phone1 调用静态锁方法 sendSms ，对象 phone2 调用静态锁方法 call，对象 phone1 phone2 的类模板都是 Phone.class，所以为同一把锁，所以从上到下执行。

七.同一个对象，两个线程分别调用对象的静态加锁方法和普通加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    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{

    static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
线程 A 调用静态加锁方法 sendSms ，锁的是 Phone.class，线程 B 调用普通加锁方法 call，锁的是对象 phone，是两把不同的锁，互不影响。

八.不同对象，分别调用静态加锁方法和普通加锁方法，sendSms 方法加上延迟3秒

package com.example.demo.module.synchronized8Test;

import java.util.concurrent.TimeUnit;

public class Test {

    public static void main(String[] args) {
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(() -> {
            phone1.sendSms();
        },"A").start();

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }

}

class Phone{

    static synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("----发短信----");
    }

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

}

运行结果
在这里插入图片描述
结论：
对象 phone1 调用静态加锁方法 sendSms ，锁的是 Phone.class，对象 phone2 调用普通加锁方法 call，锁的是对象 phone2，是两把不同的锁，互不影响。

敲代码的大雄
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 423
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
Java并发 synchronized锁住的内容解析
08-25
主要介绍了Java并发 synchronized锁住的内容解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java使用synchronized实现互斥锁功能示例
08-19
主要介绍了Java使用synchronized实现互斥锁功能,结合实例形式分析了Java使用synchronized互斥锁功能简单实现方法与操作技巧,需要的朋友可以参考下
11.线程八锁
DevOps海洋的渔夫@专栏
03-01 368
11.线程八锁线程八锁•一个对象里面如果有多个synchronized方法，某一个时刻内，只要一个线程去调用其中的一个synchronized方法了，其它的线程都只能等待，换句话说，某一...
通过线程八锁问题融会贯通synchronized关键字的使用
Forlogenの解忧杂货铺
08-25 191
文章目录1. 一锁2. 二锁3. 三锁4. 四锁5. 五锁6. 六锁7. 七锁8. 八锁 线程八锁 凯有八门遁甲之术，你晓得线程八锁问题吗？赶紧来看一下吧~ 1. 一锁 class Number{ public synchronized void a() { log.debug("1"); } public synchronized void b() { log.debug("2"); } } public static void m
synchronized锁——8锁
weixin_34413065的博客
04-08 142
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
第二章 多线程入门之高级
黑魔仙小月的博客
05-13 275
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
JUC并发编程 常用锁 三个辅助类的使用
Andrew0219的博客
08-12 149
1
synchronized枷锁实例
07-05
基于Synchronized加锁的四个demo，主要反映类锁、对象锁、方法锁的使用方法。 并测试不同类型锁之间的有效关系。
Synchronized_锁升级知识点总结
11-17
java高并发开发必须要会的知识,锁知识,关键字 Synchronized_锁升级知识点总结,面试常用
Java Synchronized锁失败案例及解决方案
08-19
主要介绍了Java Synchronized锁失败案例及解决方案,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
多线程8锁之synchronized
u014381566的博客
04-04 80
package com.lyon.juc; import java.util.concurrent.TimeUnit; //8锁 就是关于锁的8个问题 //1.标准情况下，两个线程先打印 发短信 打电话？ 1/发短信 2/打电话 //2.sendSms方法中延迟1秒，两个线程先打印 发短信 打电话？ 1/发短信 2/打电话 public class Test8Lock { public static void main(String[] args) { Phone.
synchronized介绍&线程八锁
qq_49567286的博客
02-24 199
synchronized基本叫啥以及线程八锁情况
synchronized的使用和线程八锁
qq_43684005的博客
09-15 143
1. 前言 临界资源：一次仅允许一个进程使用的资源就称为临界资源 临界区：访问临界资源的代码块 竞态条件：多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。 为了避免临界区的竞态条件的发生，我们可以采用阻塞式的解决方案和非阻塞式的解决方案。阻塞式的方案就是使用synchronized。synchronized：对象锁，保证了临界区内代码的原子性，采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其它线程获取这个对象锁时会阻塞，保证拥有锁的线程可以安全的执行临
synchronized8锁问题
zds448588952的博客
06-09 120
synchronized8锁问题
synchronized八锁现象理解
lczcxyit的博客
04-19 1809
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 360
关于锁的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()，而是因为锁的存在
Spring aop 五种通知类型
小熊
12-20 9430
Spring aop 五种通知类型 spring aop 的五种通知类型 前置通知 Before advice：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常 后置通知 After returning advice：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行 异常通知 After throwing advice：在连接点抛出异常后执行 最终通知 After (finally) advice：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内
synchronized是公平锁，不会产生线程极饿现象
最新发布
03-12
可以回答这个问题。synchronized是一种可重入锁，它可以保证同一时刻只有一个线程...但是，synchronized并不是公平锁，它并不能保证线程获取锁的顺序是公平的，可能会导致某些线程一直无法获取到锁，产生线程饥饿现象。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值