JavaSE之8锁现象线程彻底理解锁

最新推荐文章于 2023-05-24 09:08:42 发布
最新推荐文章于 2023-05-24 09:08:42 发布
阅读量184 收藏 1
点赞数 1
分类专栏： JavaSE 文章标签： 多线程 java 并发编程 thread
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46036165/article/details/106456755
版权

8锁现象线程彻底理解锁

利用8道题，彻底搞定锁

1.问题一

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

/*
1、标准的访问情况下，先执行 sendEmail 还是 sendSMS

   答案：sendEmail
   被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个
   先调用的先执行！
 */
public class LockDemo01 {
    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();

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

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(2);

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

class Phone{
    public synchronized void sendEmail(){
        System.out.println("sendEmail");
    }

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

2.问题二

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

/*
2、sendEmail休眠3秒后 ，先执行 sendEmail 还是 sendSMS

   答案：sendEmail
   被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个
   先调用的先执行！
 */
public class LockDemo02 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(2);

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

class Phone2{
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

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

3.问题三

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

/*
3、增加一个普通方法，请问先打印那个 sendEmail 还是 hello

   答案：hello
   新增加的这个方法没有 synchronized 修饰，不是同步方法，不受锁的影响！
 */
public class LockDemo03 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone3{
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println("sendEmail");
    }

    // 没有 synchronized 没有 static 就是普通方式
    public void hello(){
        System.out.println("hello");
    }
}

4.问题四

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

/*
4、两个手机，请问先执行sendEmail 还是 sendSMS
    答案：sendSMS
    被 synchronized  修饰的方式，锁的对象是调用者；我们这里有两个调用者，两个方法在这里是两个锁
 */
public class LockDemo04 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone1 = new Phone4();
        Phone4 phone2 = new Phone4();

        new Thread(()->{
            try {
                phone1.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone4{
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

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

5.问题五

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

//LockDemo05.Class 模板,只有一个     static
//new LockDemo05()，可以创建多个对象

/*
5、两个静态同步方法，同一个手机请问先执行sendEmail 还是 sendSMS

    答案：sendEmail
    只要方法被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一！所以说这里是同一个锁
    并不是因为synchronized
 */
public class LockDemo05 {
    public static void main(String[] args) throws InterruptedException {
        Phone5 phone = new Phone5();


        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone5{

    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS(){
        System.out.println("sendSMS");
    }

}

6.问题六

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

//LockDemo05.Class 模板,只有一个     static
//new LockDemo05()，可以创建多个对象

/*
6、两个静态同步方法，两个手机，请问先执行sendEmail 还是 sendSMS

    答案：sendEmail
    只要方法被 static 修饰，锁的对象就是 Class模板对象,这个则全局唯一！所以说这里是同一个锁
    并不是因为synchronized
 */
public class LockDemo06 {
    public static void main(String[] args) throws InterruptedException {
        Phone6 phone = new Phone6();
        Phone6 phone2 = new Phone6();

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone6{

    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

    public static synchronized void sendSMS(){
        System.out.println("sendSMS");
    }

}

7.问题七

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

//LockDemo05.Class 模板,只有一个     static
//new LockDemo05()，可以创建多个对象

/*
7、一个普通同步方法，一个静态同步方法，只有一个手机，请问先执行sendEmail 还是 sendSMS

    答案：sendSMS
    synchronized 锁的是这个调用的对象
    static 锁的是这个类的Class模板
    这里是两个锁！
 */
public class LockDemo07 {
    public static void main(String[] args) throws InterruptedException {
        Phone7 phone = new Phone7();

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone7{

    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

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

}

8.问题八

package com.coding.lock8;

import java.util.concurrent.TimeUnit;

//LockDemo05.Class 模板,只有一个     static
//new LockDemo05()，可以创建多个对象

/*
7、一个普通同步方法，一个静态同步方法，两个手机，请问先执行sendEmail 还是 sendSMS

    答案：sendSMS
    synchronized 锁的是这个调用的对象
    static 锁的是这个类的Class模板
    这里是两个锁！
 */
public class LockDemo08 {
    public static void main(String[] args) throws InterruptedException {
        Phone8 phone = new Phone8();
        Phone8 phone2 = new Phone8();

        new Thread(()->{
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        //Thread.sleep(200);
        TimeUnit.SECONDS.sleep(1);

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

class Phone8{

    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println("sendEmail");
    }

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

}

小结

1、new this 调用的这个对象，是一个具体的对象！

2、static class 唯一的一个模板！

在我们编写多线程程序得时候，只需要搞明白这个到底锁的是什么就不会出错了！

synchronized(Demo.class){

}
synchronized(this){

}
Coder-michael
关注
专栏目录
javase之多线程技术
10-16
从字节码角度分析，需要理解指令重排序和内存模型对多线程的影响。CPU上下文切换时，需确保数据的一致性，避免数据竞争和死锁。 3. **Callable与FutureTask模式** - **Callable**接口允许创建返回结果的线程，与...
8锁 现象
DaDaguai001的博客
07-01 401
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
八锁现象——synchronized关键字实战详解
最新发布
欢迎。
05-24 1527
synchronized关键字到底锁的是谁？
Java中的八种锁
chou_out_man的博客
11-16 1491
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
Java的8锁现象
weixin_56018532的博客
09-09 666
Java的8锁现象
经典 8 锁问题
yage124的博客
05-15 362
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
JavaSe知识总结：多线程.xmind
10-19
思维导图：含括多线程概念，线程创建开启方式，线程安全，线程状态及常见问题
JavaSE多线程
09-15
JavaSE的多线程特性是其强大的功能之一，它允许开发者编写能够同时处理多个任务的程序，从而提高程序的效率和响应性。在Java中，线程是程序执行的最小单位，而进程则是资源分配的基本单位。每个Java应用程序至少有一...
JavaSE专题-多线程总结.doc
06-03
JavaSE专题的多线程是Java编程中至关重要的一部分，它涉及到如何在单个程序中同时执行多个任务。以下是对多线程技术的详细说明： 1. **多线程技术介绍** - **进程**：一个进程是操作系统分配给应用程序的内存空间...
JavaSE之多线程实战视频课程
06-09
JavaSE之多线程实战视频课程是一系列深入探讨Java中多线程技术的教程，适合对Java编程有一定基础的学习者。课程涵盖了多线程的基本概念，以及如何在Java环境中实现和管理多线程，旨在提升开发者对并发编程的理解和...
9、8锁现象彻底的理解锁（锁的只有两个东西，一个是对象，一个是Class模板（static修饰））
分享java学习路上的一些笔记，不足之处多多见谅。
11-15 249
问题三：（我们在资源类中在给他一个没有锁的方法。问题7：（一个静态同步方法（static syn（休眠4s）），一个普通同步方法（syn），然后只有一个对象，两个线程使用）（先打电话，再等4s输出发短信）问题8：（一个静态同步方法（static syn（休眠4s）），一个普通同步方法（syn），然后两个实例对象）（还是先打电话，再等4s才是发短信）问题4：（我们准备两个对象，一个线程让对象1去调用发短信（还是睡眠4s的），一个线程让对象2去调用打电话）（这里是先打电话再等4s输出发短信了）
Java并发编程——八门金锁(8锁现象)
qq_43576814的博客
08-15 199
现象一 public class Test1 { public static void main(String[] args) { Phone phone=new Phone(); new Thread(()->{ phone.sendSms(); },"A").start(); try { TimeUnit.SECONDS.sleep(1); } catch (I
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2097
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
Java并发4——八锁现象
weixin_51818357的博客
07-25 169
Java并发之八锁现象 1.这么说吧，如果两个都是普通方法，那么就看谁先调用，一般先调用先执行 2.如果都是普通方法，但是有加延时，那么就延时少的先调用(因为时间是差不多同时调用，但是一个延时4秒再执行，一个延时2秒再执行，肯定2秒的先执行出来） 3.如果加锁的话，无延时，仍然是谁先调用谁执行 4.如果加锁加延时的话，延时不管，谁先调用谁执行，管它延不延时，反正没执行完不出来，这就是锁的作用 锁的是对象，没结束，锁不释放 （这里先后调用看的是 程序中先调用了哪个方法的线程） 5.两个对象，两把锁，不存在锁的
java的8锁现象
qq_45699784的博客
01-28 422
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
Java八锁现象
s17856147699的博客
08-30 283
Java八锁现象
再探JUC-8锁现象
qq_21793443的博客
03-21 460
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
JUC详解-4-八锁现象彻底理解锁
baidu_38126306的博客
11-11 235
JUC详解 -> 八锁现象 如何判断锁的是谁？ import java.util.concurrent.TimeUnit; /** * 八锁：就是关于锁的八个问题 * 1.标准情况下，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 * 2.sendSms()延迟4秒，两个线程先打印发短信还是打电话？ 1 发短信 -> 2 打电话 */ public class Test01 { public static void main(String[] args)
Java 八锁详解
NULL
11-23 863
1),标准访问,请问先打印 邮件 还是短信? /** synchronized 和 lock 一样我这里用的是 lock*/ class phone { Lock lock = new ReentrantLock(); void sendMAIL(){ lock.lock(); try { System.out.println("---------sendMAIL"); } catch (Exception e
JavaSE多线程编程详解：创建与管理
"JavaSE多线程编程专题.pptx" 在JavaSE中，多线程编程是一项核心技能，它允许程序并发执行多个任务，提高系统资源利用率和响应速度。多线程涉及到进程和线程两个概念。进程是操作系统分配资源的基本单位，每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值