JUC并发编程（二）: 8锁现象(深入理解锁)

最新推荐文章于 2024-01-16 11:17:57 发布
最新推荐文章于 2024-01-16 11:17:57 发布
阅读量476 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hi_alan/article/details/104674995
版权

8锁现象

在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？

首先看下以下8个问题

1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？
2、邮件方法暂停4秒钟，请问先打印邮件还是短信？
3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？
4、两部手机、请问先打印邮件还是短信？
5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？
6、两个静态同步方法，2部手机，请问先打印邮件还是短信？
7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？
8、一个普通同步方法，一个静态同步方法，2部手机，请问先打印邮件还是短信？

看下程序运行的效果：

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

public class Test1 {
    public static void main(String[] args) {
        Phone phone=new Phone();

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

		//干扰条件
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        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、邮件方法暂停4秒钟，请问先打印邮件还是短信？

public class Test2 {
    public static void main(String[] args) {

        Phone2 phone=new Phone2();

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

        //干扰
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        new Thread(()->{
            phone.sendSMS();
        },"B").start();
    }
}

/**
 * 手机，发短信，发邮件
 */
class Phone2{
      public synchronized void sendEmail(){
        try{
            TimeUnit.SECONDS.sleep(4);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

结果：
在这里插入图片描述
3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？

public class Test3 {
      public static void main(String[] args) {

        Phone3 phone = new Phone3();

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

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

        new Thread(() -> { // 一秒后执行
            phone.hello();
        }, "B").start();

    }
}


/**
 *手机，发短信，发邮件
 */
class Phone3 {
 
    public synchronized void sendEmail() {
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

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

}

结果：
在这里插入图片描述
4、两部手机、请问先打印邮件还是短信？

public class Test4 {

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

        new Thread(() -> { // 一开始就执行了
            phone1.sendEmail();
        }, "A").start();

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

        new Thread(() -> { // 一秒后执行
            phone2.sendMS();
        }, "B").start();

    }
    }

// 手机，发短信，发邮件
class Phone4 {
    public synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

}

结果：
在这里插入图片描述
5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

 public class Test5 {
     public static void main(String[] args) {
              Phone5 phone = new Phone5();

         new Thread(() -> { // 一开始就执行了
           phone.sendEmail();
       }, "A").start();

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

       new Thread(() -> { // 一秒后执行
           phone.sendMS();
       }, "B").start();

   }

}


// 手机，发短信，发邮件
class Phone5 {

    public static synchronized void sendEmail() {
       // 善意的延迟
       try {
           TimeUnit.SECONDS.sleep(4);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("sendEmail");
   }

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

}

结果：
在这里插入图片描述
6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

public class Test6 {
public static void main(String[] args) {
        Phone5 phone = new Phone5();
        Phone5 phone2 = new Phone5();

        new Thread(() -> { // 一开始就执行了
        phone.sendEmail();
        }, "A").start();

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

        new Thread(() -> { // 一秒后执行
        phone2.sendMS();
        }, "B").start();

        }

        }

// 手机，发短信，发邮件
class Phone6 {
       public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

}

结果：
在这里插入图片描述
7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

public class Test7 {
    
    public static void main(String[] args) {
           Phone7 phone = new Phone7();

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

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

        new Thread(() -> { // 一秒后执行
            phone.sendMS();
        }, "B").start();

    }
}


class Phone7{
    // CLASS
    public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    // 对象
    // 普通同步方法
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
在这里插入图片描述

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

public class Test8 {

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

        new Thread(() -> { // 一开始就执行了
            phone.sendEmail();
        }, "A").start();

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

        new Thread(() -> { // 一秒后执行
            phone2.sendMS();
        }, "B").start();

    }

}



class Phone8{

    // CLASS
    public static synchronized void sendEmail() {
        // 善意的延迟
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    // 对象
    // 普通同步方法
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }

}

结果：
在这里插入图片描述

总结：

  1. 锁是一种竞争机制，一个方法加锁，一个方法没有加锁，那么普通方法就会先运行，因为它不要去竞争！
  2. 被synchornized修饰的同步方法，锁的对象是方法的调用者。谁先调用，谁先执行！
  3. 被synchronized修饰和static修饰的方法，锁的对象是类的class对象,唯一的！
代码魔法师Sunny
关注
JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
深入理解高并发编程
qq_67447208的博客
09-09 888
线程可以有效降低程序的开发和维护成本，同时提升复杂应用程序的性能。在服务器应用程序中，可以提升资源利用率以及系统吞吐率，线程还可以简化JVM的实现，垃圾收集器通常在一个或多个专门的线程中运行，在许多重要的Java应用中，都在一定程度生用到了线程。
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1428
JUC 八锁现象 Java并发编程
4、JUC：8锁问题
cxycxytony的博客
10-31 127
第一组 package com.chen.lock8; import java.util.concurrent.TimeUnit; /** * 8 锁，就是关于锁的8个问题 * 1、标准情况下，两个线程先打印 打电话 还是 发短信？ 1.发短 2.打电话 * 2、sendSms延迟4秒，两个线程先打印 打电话 还是 发短信？ */ public class Test1 { public static void main(String[] args) { Phone ph
juc----举例说明8锁问题
qq_40927884的博客
05-20 530
class Phone { public static synchronized void SendSMS() throws InterruptedException { TimeUnit.SECONDS.sleep(4); System.out.println("发了短信"); } public synchronized void ...
JUC之八锁现象理解锁
可小辉的博客
11-23 258
1.JUC概述 2.八锁应用 Test1.java package lock8; import java.util.concurrent.TimeUnit; /** * 8锁，是锁的8个问题 * 1.标准情况下，两个线程打印，先打印？----- 发短信 打电话 * * @author Admin * */ public class Test1 { public static void main(String[] args) { Phone phone = new Ph.
JUC学习之线程8锁
dyt443733328的博客
04-20 762
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
juc之8锁问题
一个代码小白的历练的博客
06-20 134
8锁问题 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体验； 在创作中心设置你喜爱的代码高亮样式，Markdown 将代码片显示选择的高亮样式 进行展示； 增加了 图片拖拽 功能，你可以将本
JUC并发编程 进阶
Ctrl_kun的博客
03-06 854
Java JUC 并发编程进阶 笔记 1.线程与进程 2.Lock锁 3.8锁现象 4.多线程安全的集合 5.Callable 6.读写锁 7.阻塞队列 8.线程池 9.函数式接口 10.Stream流式计算 11.ForkJoin 12.异步回调 13.JMM 14.Volatile 15.单例模式深究 16.CAS 17.原子引用 18.常见锁
JUC并发编程学习笔记
Melekh_的博客
02-26 532
一、什么是JUC JUC指的是：Java里的三个包 java.util.concurrent java.util.concurrent.atomic：原子性 java.util.concurrent.locks：lock锁 二、线程和进程 1.进程 程序执行的一次过程，一个进程包含一个或多个线程。进程是资源分配的单位。 2.线程 可以指程序执行过程中，负责实现某个功能的单位。线程是CPU调度和执行的单位。 3.并发 同一时刻，多个线程交替执行。（一个CPU交替执行线程） 4.并行 同一时
JUC并发编程
qq_36781386的博客
03-23 330
1.什么是JUC? 业务: 普通的线程代码 Thread Runnable 没有返回值,效率相比较Callable较低! 2.线程和进程 线程.进程,如果不能使用一句话说出来的技术,不扎实! 进程: 一个程序,QQ.exe Music.exe 程序的集合; 一个进程往往可以包含多个线程,至少包含一个! java 默认有几个线程? 2 个 main / GC 回收器 线程: 开了一个进程 Typora , 写字, 自动保存(线程负责的) 对于 java 而言,: Thread/Run
再探JUC-8锁现象
qq_21793443的博客
03-21 463
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
JUC-8锁现象-03
rr18758236029的博客
11-04 116
JUC-8锁现象-03 如何判断锁的是谁？永远知道什么锁，锁的到底是谁 深刻理解锁 package com.rongrong.lock8; import java.util.concurrent.TimeUnit; /** * 8锁就是关于锁的8个问题 * 1.标准情况下，两个线程先打印 发短信还是打电话 * 2.sendSms延迟4s，先发短信还是打电话 */ public class Test1 { public static void main(String[] args) {
JUC——8锁问题
最新发布
鹏鹏2077
01-16 910
当关键字用于方法或代码块时，它可以用来实现对象级别的锁和类级别的锁。当用于非静态方法时，锁对象是调用该方法的实例对象。即每个对象实例都有自己的锁。当用于代码块时，锁对象可以是任意的Java对象。通常情况下，我们使用某个共享资源作为锁对象。无论是方法级别的锁还是代码块级别的锁，同一时间只能有一个线程获得锁并执行同步代码，其他线程需要等待锁释放。当用于静态方法时，锁对象是当前方法所属的类对象（Class对象）。类级别锁是针对整个类的所有对象实例生效的，不同实例之间共享这个锁。
JAVA高并发（JUC）多线程8锁讲解
Cocowwy的博客
05-11 709
先了解一个概念：synchronized 锁的是这个方法所在的资源类，就是这个对象，也就是同一时间段不可能有两个线程同时进到这个资源类，同一时间段，只允许有一个线程访问资源类里面的其中一个synchronized 方法！ T1：1.标准访问，请问先打印邮件还是短信？ 代码如下： public class Lock8 { public static void main(String[] args) { Phone phone = new Phone(); new Thr
JUC-8锁现象深度剖析
314
07-21 339
现象一 多个线程使用一把锁，也就是调用同一个对象，顺序执行。 “被synchronized修饰的方法，锁的对象是方法的调用者” public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ phone.sendSms(); },"A").start();
juc-线程八锁
weixin_39535692的博客
10-27 357
松岛枫
JUC- 八锁现象
hxy1625309592的博客
02-22 153
4.4 八锁现象 4.4.1 标准访问 package cn.guardwhy.test04; import java.util.concurrent.TimeUnit; /* * 标准访问：先发短信还是打电话? */ public class LockTest01 { public static void main(String[] args) { // 创建phone对象 Phone phone = new Phone(); new Thre
JUC -八锁现象
m0_46276938的博客
05-18 183
juc的八锁现象 8锁其实就是关于锁的8个问题 问题一和问题二 代码演示： 1.标准情况下，两个线程先打印 发短信和打电话 2.senMesg 延迟4秒，两个线程先打印 发短信和打电话 因为方法上有锁，锁的是phone这个类，所有会先发短信 再打电话 * */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值