八锁问题详解

最新推荐文章于 2024-01-16 11:17:57 发布
最新推荐文章于 2024-01-16 11:17:57 发布
阅读量735 收藏 6
点赞数 1
分类专栏： 高并发 文章标签： java java-ee
“来自于网络，如果侵犯著作权，请联系删除”
本文链接：https://blog.csdn.net/weixin_45737330/article/details/125227234
版权
本文详细解读了八种不同场景下'八锁'问题，涉及线程同步、方法锁定、静态与实例锁的区别，展示了并发编程中并发与同步的微妙交互。从标准情况到延时、静态与普通方法、对象数量变化，逐个剖析了同步行为的先后顺序。
摘要由CSDN通过智能技术生成

“八锁”有什么含义？

很好理解，就是：有关8个锁的问题！

问题一：标准情况下，两个线程先打印发短信 还是打电话？

答案：

发短信
打电话

代码如下：

public class Demo1 {
    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 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

问题二：sendSms延迟4秒，两个线程先打印 发短信 还是打电话？

答案：
(4秒后，显示结果)
发短信
打电话

public class Demo1 {
    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 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call(){
        System.out.println("打电话");
    }
}

问题三：一个同步方法，一个普通方法， 先执行发短信 还是打电话？

答案： （先执行普通方法，因为他不是同步方法不受锁的影响，并且发短信睡眠了4秒，所以发短信肯定在她后面。）

打电话
(4秒后，显示)
发短信

public class Demo2 {
    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.call();

        }, "B").start();


    }
}

class Phone2 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
 //这里没有锁！不是同步方法，不受锁的影响！
    public void call() {
        System.out.println("打电话");
    }
}

问题四：两个对象，两个同步方法，先执行发短信 还是打电话？

答案：（先打电话，因为是两把锁，互不影响，然后发短信睡4秒）
打电话
(4秒后，显示)
发短信

public class Demo2 {
    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 {
    //synchronized 锁的对象是方法的调用者！
    //两个方法用的是同一个锁，谁先拿到谁执行！
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

问题五：增加两个静态的同步方法，只有一个对象，先打印发短信还是打电话？

答案：（因为用的是同一个锁，类锁，谁先抢到谁先执行，所以发短信先抢到。
(4秒后，显示)
发短信
打电话

public class Demo3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        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();
    }
}

//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    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秒后，显示)
发短信
打电话

public class Demo3 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        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();
    }
}
//Phone3 唯一的一个Class 对象
class Phone3 {
    //synchronized 锁的对象是方法的调用者！
    //static 静态方法
    //类只要加载就有了！ Class 模板
    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秒后，显示)
发短信

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        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();
    }
}

//Phone3 唯一的一个Class 对象
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秒后，显示)
发短信

public class Demo4 {
    public static void main(String[] args) {
        //两个对象的Class类模板只有一个，static ,锁的是Class
        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();
    }
}

//Phone3 唯一的一个Class 对象
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("打电话");
    }
}
已转行@
关注
专栏目录
【程序员必知必会】线程8锁现象：让你彻底理解synchronized到底锁了什么
qq_35754976的博客
12-21 688
我们都知道synchronized实现同步具体表现为以下三种形式： 1. 对于普通同步方法，锁是当前实例对象 2. 对于静态同步方法，锁是当前类的Class对象 3. 对于同步方法块，锁是synchronized括号里配置的对象 但是一到真实场景中，就难以判断synchronized锁的是谁了。 那么本篇文章，引用了著名的”8锁现象“，每个问题都会附一套代码，来帮助你彻底理解synchronized到底锁了什么，让你不论在多么复杂的场景下，都可以正确地判断锁的是谁。
关于8锁问题详细介绍
CP-Objeck的博客
05-18 1576
关于8锁问题 1、两个同步方法，一个对象调用。乌龟先跑？还是兔子先跑？ 答：乌龟先跑 /** * @Description: * @Package: com.cp.lock8 * @ClassName: Lock2 * @Author: cp * @Date: 2020/5/18 21:50 * @Version: 1.0 */ public class Lock1 { public static void main(String[] args) { Animal1
8锁问题
weixin_43912697的博客
03-01 124
8锁问题：关于锁的8个问题 public class demo01 { public static void main(String[] args) { Phone1 phone = new Phone1(); new Thread(()->{ phone.send(); },"A").start(); // 延时2秒 try { TimeUnit.SECONDS
线程第六课(附加)——八锁问题
Geek
11-28 401
  搞懂以下八个问题，同步锁就算真的搞懂了。   1 标准访问，先打印短信还是邮件   public class Lock_8 {     public static void main(String[] args) throws InterruptedException {         Phone phone1 = new Phone();         Phone ...
Oracle 锁机制问题详解
02-08
### Oracle 锁机制问题详解 #### 一、引言 在多用户数据库环境中，当多个用户尝试同时访问或修改同一份数据时，就需要通过锁机制来确保数据的一致性和完整性。Oracle 数据库提供了多种类型的锁来支持事务隔离级别，...
Java 八锁详解
NULL
11-23 874
1),标准访问,请问先打印 邮件 还是短信? /** synchronized 和 lock 一样我这里用的是 lock*/ class phone { Lock lock = new ReentrantLock(); void sendMAIL(){ lock.lock(); try { System.out.println("---------sendMAIL"); } catch (Exception e
详解智能家居控制八大系统
01-20
智能家居视频多媒体系统整合了家庭的音视频设备，如电视、音响、投影仪等，实现资源共享，避免了重复购置和复杂的布线问题，同时提供了更加智能化的控制体验。 最后，智能家居环境控制系统关注的是室内环境的质量。...
Java实现生产者消费者问题与读者写者问题详解
08-28
Java实现生产者消费者问题与读者写者问题详解 Java语言在多线程编程中提供了对同步机制的良好支持，解决生产者/消费者问题的方法可分为两类：（1）采用某种机制保护生产者和消费者之间的同步；（2）在生产者和消费...
【面试：并发篇12：多线程：线程八锁】
m0_71229547的博客
07-12 214
如果有任何问题请指出，感谢。线程八锁 其实就是考察 synchronized 锁住的是哪个对象 结果这个很好理解 两个锁的监听器都是 Number的对象n1，不过结果为什么有21 因为虽然可能性很小 但依然有可能先运行b线程 结果解释如果a b线程的监听器都是 n1对象，所以如果a线程执行 那么就会是先等1s 再12，如果是b线程先执行 就会是2等1s再1 结果解释因为c线程没有加锁，ab线程加锁且监听器都是n1，又因为 线程a等待1s，所以 要么b线程先执行要么c先执行，所以答案就是上述结果 结果解释因为
JUC——8锁问题
最新发布
鹏鹏2077
01-16 919
当关键字用于方法或代码块时，它可以用来实现对象级别的锁和类级别的锁。当用于非静态方法时，锁对象是调用该方法的实例对象。即每个对象实例都有自己的锁。当用于代码块时，锁对象可以是任意的Java对象。通常情况下，我们使用某个共享资源作为锁对象。无论是方法级别的锁还是代码块级别的锁，同一时间只能有一个线程获得锁并执行同步代码，其他线程需要等待锁释放。当用于静态方法时，锁对象是当前方法所属的类对象（Class对象）。类级别锁是针对整个类的所有对象实例生效的，不同实例之间共享这个锁。
经典8锁问题--助你彻底搞懂锁的概念
iME_cho的博客
04-07 1910
下面将通过经典的8锁问题，认清锁原理 场景一 import java.util.concurrent.TimeUnit; /** * 标准情况下 是先sendEmail()　还是先callPhone()? * 答案：sendEmail * 解释：被 synchronized 修饰的方式，锁的对象是方法的调用者 * 所以说这里两个方法调用的对象是同一个，先调用的先执行！ */ pub...
8锁问题示例-通俗易懂
weixin_45216009的博客
06-16 417
synchronized：互斥锁： 分为 静态互斥锁，非静态互斥锁。在一个类中用 synchronized 修饰两个方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？锁谁？锁的对象：就是方法的调用者(实例化对象)；两个方法用的是同一把锁，先拿到先执行。(取决于CPU的调度)错误解释：而不是对象先调用哪个方法就先执行。在一个类中用 synchronized 修饰一个方法(设置延迟4s)，一个普通方法，然后实例化当前类(一个对象)， 对象调用当前类中两个方法，两方法执行顺序？普通方
8锁问题，探究锁到底锁了谁，谁被锁了
qq_42388853的博客
12-25 373
8锁就是8个锁的问题，直接探究出到底锁的是谁：下面看题和结果就可以了。 题的情况很简单，就是一个Phone类，里面有打电话和发短信俩方法，答案就是先发短信还是先打电话即可： 问题1：正常情况下，谁会先输出出来 package lock8; import java.util.concurrent.TimeUnit; //1、正常情况下，谁会先输出出来 public class Test1 { public static void main(String[] args) { Phone
多线程8锁
weixin_42198596的博客
01-07 131
标准访问，请问先打印邮件还是短信？ 邮件方法暂停4秒钟，请问先打的邮件还是短信？ 新增一个普通方法hello（），请问先打印邮件还是hello？ 两部手机，请问先打印邮件还是短信？ 两个静态同步方法，同一部手机，请间先打印邮件还是短信？ 两个静态同步方法，2部手机，请问先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，1部手机，请间先打印邮件还是短信？ 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？ ...
Lock8锁
张鑫的博客
08-27 743
前言： Lock     替代了      synchronized Condition  替代了   Object中的wait 和notify 方法 为什么Lock会替代synchroized?   synchronized的局限性 占有锁的线程等待IO或者其他原因被阻塞，没有释放锁的情况下，其他线程一直阻塞 多个线程同时读写文件的时候，读和读操作也会发生冲突 我们没有办法知道当前...
Java并发编程-八锁问题带你彻底理解对象锁和类锁
Java硬件工程师的博客
01-15 2203
8锁问题演示 1.标准访问 标准访问，先打印邮件还是短信. 不一定谁先被打印。取决于CPU的执行情况.激活他们的是main线程，后面谁先被调度，不知道。 为了保证效果，我们在A和B的代码之间加thread.sleep(100).此时，可以确保A先被打印。 解释： 进入到main方法中之后，就是A找邮件，B找短信的方法。加完锁之后，同时进来，各回各家，各找各妈。因为我们人为的在A和B之间加了休眠时间，那么A肯定发生在B之前。按照标准访问。此时先打印邮件 /*手机类可以发邮件和发短信*/ class Phone
回溯算法详解：解决八皇后问题
八皇后问题是将八个皇后摆放在8x8的国际象棋棋盘上，使每个皇后都无法吃掉别的皇后，一共有多少种摆法？这个问题可以使用回溯算法来解决。 解决八皇后问题的步骤如下： 1. 尝试先放置第一个皇后，被涂黑的地块是不...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

已转行@

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值