Java 多线程中用 synchronized 加锁的八锁问题

最新推荐文章于 2024-03-28 09:38:18 发布
最新推荐文章于 2024-03-28 09:38:18 发布
阅读量395 收藏 2
点赞数 2
分类专栏： Java 多线程/并发 文章标签： 多线程 并发编程 java thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38599840/article/details/108576243
版权
  1. 看以下代码，有一个 phone 对象，A、B 线程分别调用该对象的方法，问两个方法谁先调用？答：先发短信再打电话，因为 synchronized 锁住的是 phone 对象（锁的对象是方法调用者）。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

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

class Phone {
    synchronized void sendMsg() {
      	System.out.println("发短信");
    }

    synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 看以下代码，有一个 phone 对象，A、B 线程分别调用该对象的方法，问两个方法谁先调用？答：先发短信再打电话，理由还是 synchronized 锁住的是 phone 对象，从 A 线程开始执行方法时到 A 执行完毕，B 线程一定会等待 4 秒。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

    TimeUnit.SECONDS.sleep(1);

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

class Phone {
    synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 看以下代码，一个对象，俩线程分别执行有锁和无锁的方法，问两个方法谁先调用？答：先打电话再发短信，没有加锁的方法不受锁的影响，该调用还是调用。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();


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

class Phone {
    synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    void call() {
        System.out.println("打电话");
    }
}
  1. 看以下代码，两个对象，两个线程分别执行有锁和无锁的方法，问两个方法谁先调用？答：先打电话再发短信，当 A 线程开始执行时，等待一秒钟 B 线程的方法就执行，两个对象两把锁，互不影响。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

    TimeUnit.SECONDS.sleep(1);

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

class Phone {
    synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 两个线程分别调用两个静态加锁方法，问两个方法谁先调用？答：先发短信再打电话，两个方法加了 static ，上升到类级别，也就是说锁的是 phone 的 class，是一个类对象，在 A 线程调发短信方法时持有该 class，B 线程当然获取不到该 class，必须等待。
public static void main(String[] args) throws InterruptedException {
    
    new Thread(() -> {
        Phone.sendMsg();
    }, "A").start();

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

class Phone {
    static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 两个对象，两个线程分别调用两个静态加锁方法，问两个方法谁先调用？答：还是发短信再打电话，锁的是 phone 的类对象，两个 phone 对象所属的 class 是一致的，在 A 线程调发短信方法时持有该 class，B 线程获取不到该 class，必须等待。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

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

class Phone {
    static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 一个对象，先调用静态加锁方法，再调用成员加锁方法，问两个方法谁先调用？答：先打电话再发短信，加了 static 方法锁的对象是 phone 的 class，而未加 static 的方法锁的是原本的 phone 对象，锁的对象不同，并不互斥。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

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

class Phone {
    static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void call() {
        System.out.println("打电话");
    }
}
  1. 两个对象，先调用静态加锁方法，再调用成员加锁方法，问两个方法谁先调用？答：还是打电话再发短信，static 方法锁的是 class 对象，未加 static 的方法锁的是 phone2 对象，并不互斥。
public static void main(String[] args) throws InterruptedException {
    Phone phone = new Phone();
    Phone phone2 = new Phone();

    new Thread(() -> {
        phone.sendMsg();
    }, "A").start();

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

class Phone {
    static synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(3);
            System.out.println("发短信");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    synchronized void call() {
        System.out.println("打电话");
    }
}
0oIronhide
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 426
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
Java多线程安全问题和锁
01-20
文章目录多线程安全问题和锁线程在jvm中的特点锁的出现synchronized 关键字-监视器锁monitor lock死锁的产生和避免 什么是线程安全问题？ 当多个线程同时操作同一个数据是，可能会出现数据不一样的情况，这就是线程...
多线程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.
JUC：synchronized详解与线程八锁问题解析
最新发布
Cosmoshhhyyy的博客
03-28 1035
本章详细介绍了synchronized锁的使用和原理，同时包含线程八锁问题的解析帮我们更好的理解他的作用。
synchronized - 八锁问题及扩展
江南烟雨却痴缠丶
11-24 912
通过8锁问题，可以大致清楚synchronized是锁的什么东西。通过对8锁问题的扩展，可以进一步理解synchronized。 8锁问题 1、一个对象，两个synchronized方法，一个方法睡眠 public class LockTest { public static void main(String[] args) { Phone phone = new Phone(); // 一个Phone对象 new Thread(() -> {
第二章 多线程入门之高级
黑魔仙小月的博客
05-13 276
第二章 多线程入门之高级 第一章 多线程入门之概念 第二章 多线程入门之基础 第二章 多线程入门之高级 文章目录第二章 多线程入门之高级前言一、引入共享变量1.1 小故事正常情况下，小明使用完小红使用，最后的res=0没有任何问题。如下图所示： ![在这里插入图片描述](https://img-blog.csdnimg.cn/e0f1ebc598514544bc7d6db2b26a88b5.png) 可是有一天小明将res=1之后病倒了，老王看小明病倒了实在不能工作了就告诉小明那你先记着这个res的结果，
synchronized锁——8锁
weixin_34413065的博客
04-08 142
前言 多线程是Java面试中最喜欢问的问题之一，有一篇公众号推文内容很详细，推荐看看 但凡面试官考“多线程”，一定会问这10个问题！ 本文中仅对synchronized关键字的加锁进行一定分析 一、标准情况访问 按照普通的情况访问同步方法，查看输出 1 class Phone { 2 public synchronized void getIOS() thro...
Java 多线程synchronized关键字详解(六)
09-03
主要介绍了Java 多线程synchronized关键字详解(六)的相关资料,需要的朋友可以参考下
Java 多线程同步 锁机制与synchronized深入解析
09-05
从尺寸上讲，同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间
java多线程编程之Synchronized关键字详解
09-02
主要为大家详细介绍了java多线程编程之Synchronized关键字，感兴趣的朋友可以参考一下
java多线程编程之Synchronized块同步方法
09-03
主要介绍了java多线程编程之Synchronized块同步方法，synchronized关键字又称同步锁，当方法执行完后，会自动释放锁锁，只有一个线程能进入此方法，看看下文中各种例子对synchronized的详细解释
synchronized八锁现象理解
lczcxyit的博客
04-19 1814
八锁就是关于锁的八个问题 前提A方法 睡4秒 B方法直接执行 synchronized 无static 锁的是方法的调用者 谁先拿到锁谁谁先执行 两个Synchronized 谁先执行 谁输出(同一对象调用）A先 一个写Sy 一个无Sy 不影响 即便同一个对象调用 B先 *static 静态方法 锁类 即便两个类的对象调用也是 一个对象调用 A先 （同一对象）一个Static 一个无static 拿到的的不是同一个锁 一个类锁 一个对象锁 不影响 B先输出 （不同对象）.
synchronized的使用和线程八锁
qq_43684005的博客
09-15 143
1. 前言 临界资源：一次仅允许一个进程使用的资源就称为临界资源 临界区：访问临界资源的代码块 竞态条件：多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件。 为了避免临界区的竞态条件的发生，我们可以采用阻塞式的解决方案和非阻塞式的解决方案。阻塞式的方案就是使用synchronized。synchronized：对象锁，保证了临界区内代码的原子性，采用互斥的方式让同一时刻至多只有一个线程能持有对象锁，其它线程获取这个对象锁时会阻塞，保证拥有锁的线程可以安全的执行临
synchronized的线程八锁问题
蒋大钊的博客
02-04 453
synchronized线程八锁问题可以很好地辨析学习synchronized锁的是哪个对象。
synchronized8锁问题
zds448588952的博客
06-09 121
synchronized8锁问题
synchronized 八锁现象，搞懂 synchronized 的使用问题
小熊
10-13 352
一.同一个对象，两个线程分别调用对象的两个加锁方法 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"
synchronize的8锁现象带你彻底了解
烟花易冷
09-12 363
关于锁的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()，而是因为锁的存在
多线程synchronized对象锁与静态锁之间的8锁问题理解
m0_52889702的博客
02-02 593
8锁问题 锁1：多个线程使用同一对象分别调用不同带有带synchronized关键字且非静态的方法 锁2：在锁1基础上，增加A线程执行的方法的执行时间，使得B有机会参与执行 锁3：多个线程使用同一对象，一个线程执行带有对象锁的方法，一个线程执行普通方法 锁4：多个线程使用不同对象分别调用不同带有对象锁的方法 锁5：多个线程同一个对象分别调用对各自静态锁的方法 锁6：多个线程同多个对象分别调用对各自静态锁的方法 锁7：多个线程同一个对象分别调用对象锁的方法和静态锁的方法 锁8：多个线程不同对象分别调用对象锁的
JAVA并发编程的8锁问题（synchronized，static synchronized和普通方法调用）
Dream_6666的博客
08-22 236
通过示例说明：（注意代码中的延时问题） 情况1、2 /* 8锁，就是锁的8个问题 1.标准情况下（只有上面的延迟），两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发） 2.sendSms延迟4秒，两个线程先打印发短信还是打电话? 1.发短信 2.打电话 （锁的是同一个对象即方法的调用者，所以是并发），synchronized 锁的对象是方法的调用者！ */ public class Test1 {
java多线程锁synchronized
03-16
Java中的synchronized关键字可以用于实现多线程锁，保证多个线程对共享资源的访问是互斥的。当一个线程获取了锁，其他线程就必须等待该线程释放锁后才能继续访问共享资源。synchronized可以用于方法和代码块，使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值