Java多线程JUC8锁问题

最新推荐文章于 2023-01-12 22:17:37 发布
最新推荐文章于 2023-01-12 22:17:37 发布
阅读量294 收藏 2
点赞数 1
分类专栏： java并发编程 文章标签： java rust 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41898181/article/details/120473286
版权

一、线程的8锁问题

前提：8锁问题的讨论是建立在使用Thread.sleep(200)后，假设A线程先于B线程被CPU调度的前提下。

1.1 标准访问，请问先打印邮件还是短信？

class Phone{

    public synchronized void sendEmail() throws Exception{
        System.out.println("----------sendEmail");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println("----------sendSMS");
    }

}


/**
 * 题目：多线程8锁
 * 1.   标准访问，请问先打印邮件还是短信？
 */
public class Lock8 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
  		// 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);
        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}
  • 如果不加Thread.sleep(200) 则不确定是先打印发邮件还是先发短信，虽然打印邮件比打印短信线程先进入就绪状态，但是cpu调度其顺序不确定。
  • 加了Thread.sleep(200)很大概率先发送邮件再打印短信,200毫秒基本cpu已经调用了线程A

1.2邮件方法暂定4秒钟，请问先打印邮件还是短信？

class Phone{

    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(4);
        System.out.println("----------发送邮件");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println("----------发送短信");
    }

}
...
// Lock8类同上

先发邮件后发短信，sleep只是释放了cpu的调度时间并没有释放锁对象，B线程只有等A线程释放了当前对象锁才能执行。

1.3 新增一个普通方法hello(),请问先打印邮件还是hello?

public class Lock8 {

    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
               // phone.sendSMS();
                phone.hello();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }

    public void hello(){
        System.out.println(Thread.currentThread().getName()+"-----------hello");
    }

}


B-----------hello
A----------发送邮件

先打印hello在发送邮件

A线程被CPU调度，A发送邮件前睡1秒无释放锁对象即phone对象锁，A线程睡200毫秒后B线程进入就绪态被CPU调度，因为hello方法没有锁，无需获取锁也可执行，所以打印了hello，等到1秒后A线程睡醒打印发送邮件。

1.4两部手机请问先打印邮件还是短信？

public class Lock8 {

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

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }

    public void hello(){
        System.out.println(Thread.currentThread().getName()+"-----------hello");
    }

}

//输出
//B----------发送短信
//A----------发送邮件

解释：

synchronized是对象锁，A先被CPU调度、发送邮件先睡一秒，此时A线程锁的是phone对象，phone2对象并未上锁。200毫秒后B线程被CPU调度，发送短信。A线程1秒睡醒后发送邮件。

1.5两个静态同步方法，同一部手机，请问先打印邮件还是发送短信？

public class Lock8 {

    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public static synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }


}

A----------发送邮件
B----------发送短信

A线程被CPU调度，发送邮件前睡1秒，因为加了statics所以此时睡的时候锁的是类模板，这里也就是Phone，200毫秒后B线程被CPU调度，此时因为Phone类上锁了所以等待，1秒后A线程睡醒发送邮件释放Phone类锁，然后B线程再发送短信

1.6 两个静态同步方法，2部手机，请问先打印邮件还是发送短信？

public class Lock8 {

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

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public static synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }

}

A----------发送邮件
B----------发送短信

phone和phone2的类模板都是Phone，线程A被CPU调度后，发送邮件前睡1秒锁上类模板，200毫秒后B线程进入就绪态开始被CPU调度，但是Phone类模板被锁，所以B线程只有等A线程释放类模板锁。

1.7 1个普通同步方法，1个静态同步方法，1部手机，请问先打印邮件还是短信？

public class Lock8 {

    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
                phone.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }

    public void hello(){
        System.out.println(Thread.currentThread().getName()+"-----------hello");
    }

}

B----------发送短信
A----------发送邮件

类模板锁和具体的对象锁无关

A线程被调度，发送邮件前睡1秒锁住创建类的类模板，200毫秒后B线程被调度，因为B发送短信的方法是具体对象的，而且类模板锁和具体的对象锁又无关所以此时可以发送短信，然后A线程睡1秒后继续执行。

1.8 1个普通同步方法，1个静态同步方法，2部手机，请问先打印邮件还是短信？

public class Lock8 {

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

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();
        // 这里使线程先睡眠200毫秒  模拟出A线程先于B线程被CPU调用
        Thread.sleep(200);

        new Thread(()->{
            try {
                phone2.sendSMS();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"B").start();


    }
}

class Phone{

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(1);
        System.out.println(Thread.currentThread().getName()+"----------发送邮件");
    }

    public synchronized void sendSMS() throws Exception{
        System.out.println(Thread.currentThread().getName()+"----------发送短信");
    }

    public void hello(){
        System.out.println(Thread.currentThread().getName()+"-----------hello");
    }

}

B----------发送短信
A----------发送邮件

原因同1.7.1

奋斗的校长
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线程8锁（详细）
cookies___的博客
05-13 1334
线程8锁，超详细。 1.两个线程调用同一个对象的两个同步方法 结果是：one two 分析：第一个线程调用了getOne方法，获得了number对象的互斥锁，第二个线程等待第一个线程的getOne执行 完毕后，再执行getTow方法 2. 结果： 休眠1秒钟 后 one two 分析：线程1的Thread.sleep不释放互斥锁 3.新增一个线程调用新增的一个普通方法 结果是：three 休眠1秒 one two 分析：没有synchronized修饰的方法，线程调用时是和锁无关的 4.两个线程调用两个
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7990
深入理解JUC的8锁现象
Java并发之线程八锁
fyphome
01-30 1682
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
【Java并发编程] 线程八锁问题
小新的博客
01-12 1240
生活总会有惊喜，谁知道下一秒会发生什么呢
多线程8锁问题
lesliewongjie
04-29 187
多线程8锁问题一： 标准访问，请问先打印邮件还是短信? Java的8锁问题链接 8锁即8个关于锁执行顺序的问题 问题一： 标准访问，请问先打印邮件还是短信?
JUC代码演示 Java多线程并发
最新发布
05-03
JUC代码演示 Java多线程并发 源于B站https://www.bilibili.com/video/BV1Kw411Z7dF/?p=32&spm_id_from=333.1007.top_right_bar_window_history.content.click课程自我项目记录。 适合有一定基础的朋友。
Java多线程和JUC.pdf
01-22
java多线程的一些知识与问题的总结
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得开发者能够高效、安全地处理多线程环境中的并发问题。以下将详细介绍JUC中的关键概念和特性。 1. **线程池**：JUC通过Executor...
JUC代码收集，java高并发多线程学习
03-31
本资源"JUC代码收集，java高并发多线程学习"显然是一个专注于探讨和学习JUC库的资料包。 JUC库包含多个子包，如`concurrent`, `atomic`, `locks`等，每个子包都有其特定的功能和用途： 1. **concurrent**：这是JUC...
JUC学习笔记（Java多线程）
07-04
本笔记将深入探讨JUC的相关知识点，帮助开发者理解并掌握Java多线程的核心概念。 首先，我们来了解一下Java线程。线程是程序执行的基本单元，允许多个任务在同一时间运行，从而提高了系统资源的利用率。在Java中，...
Java八锁现象
s17856147699的博客
08-30 272
Java八锁现象
java多线程之线程八锁案例
qq_42400763的博客
04-27 336
1.八锁现象 如何判断锁的是谁?永远的知道什么锁,锁到底锁的是谁? 深刻理解我们的锁! 1.标准情况下,两个线程先打印.是先发短信还是打电话? public class Teat01 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->...
JUC-多线程锁
weixin_30922589的博客
08-27 165
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
多线程8锁问题 详解
weixin_45631253的博客
04-08 192
多线程8锁问题详解 1.案例准备 首先我们准备一个资源类，在资源类定义两个同步方法，来测试在不同的访问方式下， 会产生什么样的结果。代码如下： class MyPhone { public synchronized void sendEmail() { // 发送邮件 System.out.println("----sendEmail"); } // 发送短信 public synchronized void sendMS() {
java的八锁问题
qq_43662627的博客
08-18 278
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
Java实现经典八锁问题
05-08 525
🚀在 Loki的个人博客，阅读体验更佳 下面将通过经典的8锁问题，认清锁原理
Java并发4——八锁现象
weixin_51818357的博客
07-25 163
Java并发之八锁现象 1.这么说吧，如果两个都是普通方法，那么就看谁先调用，一般先调用先执行 2.如果都是普通方法，但是有加延时，那么就延时少的先调用(因为时间是差不多同时调用，但是一个延时4秒再执行，一个延时2秒再执行，肯定2秒的先执行出来） 3.如果加锁的话，无延时，仍然是谁先调用谁执行 4.如果加锁加延时的话，延时不管，谁先调用谁执行，管它延不延时，反正没执行完不出来，这就是锁的作用 锁的是对象，没结束，锁不释放 （这里先后调用看的是 程序中先调用了哪个方法的线程） 5.两个对象，两把锁，不存在锁的
JAVA中synchronized修饰方法的8锁问题
weixin_43907440的博客
04-22 428
JAVA中synchronized锁的总结 前提：phone类中有两个synchronized修饰的同步方法，让两个线程分别去执行这两个方法，判断谁先输出。 //基础代码，线程A\B分别执行send()和call() public class LockDemo { public static void main(String[] args) { Phone phone = ...
JAVA-8锁
CB_Beginner的博客
02-09 493
例子： package com.cb.demo.example; import java.util.concurrent.TimeUnit; class Phone { public static synchronized void sendEmail()throws Exception { //暂停一会4秒 try{TimeUnit.SECONDS.sleep(4);}catch(InterruptedException e){e.printStack
Java JUC并发编程实例：守护线程与Synchronized锁
这个资源通过具体的代码实例，展示了Java多线程编程中的基础概念，包括如何使用用户线程和守护线程，以及如何利用JUC库中的同步机制（如`synchronized`和`Lock`）来处理并发场景中的数据一致性问题。这些知识对于有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值