8锁 现象

已于 2023-03-18 21:28:28 修改
阅读量384 收藏
点赞数
分类专栏： JUC 文章标签： java 开发语言 后端
于 2020-07-01 10:05:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DaDaguai001/article/details/107056721
版权

锁的几种写法

锁的是对象

public synchronized void  printOdd() {
        
}

public  void  printOdd2() {
    synchronized (this) {
            
    }
}

锁的是Class字节码文件

public static synchronized void sendMessage() throws Exception{
    System.out.println("发短信");
}

// class对象锁
synchronized(Example.class) {
}

1

标准访问，先打印邮件还是先发送短信

   解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。但是在代码中添加了sleep().是为了让A线程一定在B线程之前执行，这只是为了更好的解释锁。

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        //TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停4秒钟
        System.out.println("发邮件");
    }

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



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

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

        Thread.sleep( 100 );//这是故意让A在B前面执行

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



标准访问，请问先打印邮件还是短信(线程调度，不一定) 邮件
 一个对象里面如果有多个synchronized方法，某一个时刻内，只要有一个线程去调用其中的一个synchronized方法了，
其他的线程都只能等待，换句话说，某一个时刻内，只能有唯一一个线程去访问这些synchronized方法

2 

在邮件方法暂停3秒钟，请问先打印邮件还是短信  答案： 邮件

解释：锁的对象是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其它synchronized方法

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停4秒钟
        System.out.println("发邮件");
    }

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


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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


//注意，在发邮件代码中，让其暂停3秒是为了验证，看其他线程能否访问当前被synchronize锁定的对象

在邮件方法暂停4秒钟，请问先打印邮件还是短信   邮件
锁的对象是当前对象this，被锁定后，其他的线程都不能进入到当前对象的其它synchronized方法

3 

新增普通的sayHello方法，请问先打印邮件还是sayHello   答案：sayHello。

解释：加一个普通方法和同步锁无关

    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停4秒钟
        System.out.println("发邮件");
    }

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

    public void sayHello() throws Exception{
        System.out.println("Hello");
    }



    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

4

两部手机，请问先打印邮件还是短信 答案：短信。（只是因为打印邮件等待了3秒）

解释：换成两个对象后，不是同一把锁了，情况立刻变化

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停4秒钟
        System.out.println("发邮件");
    }

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


    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();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

5

两个静态同步方法，同一部手机，请问先打印邮件还是短信 答案 ：邮件

解释 ：

static 锁的是全局锁

//Phone.java ---> Phone.class Class.forName() static 锁的是Class（字节码文件），但是不影响实例对象，

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停3秒钟
        System.out.println("发邮件");
    }

    public static synchronized void sendMessage() throws Exception{
        System.out.println("发短信");
    }
}



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

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

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

 * 5 两个静态同步方法，同一部手机，请问先打印邮件还是短信 邮件
 *           static 锁的是全局锁
 *           //Phone.java ---> Phone.class    Class.forName() static 锁的是Class
 *           synchronized实现同步的基础：Java中的每一个对象都可以作为锁
 *                具体表现为以下3中形式。
 *                    对于普通不同方法，锁的是当前实例对象。
 *                    对于同步方法块，锁是Synchronized括号里面配置的对象this
 *                    对于静态同步方法，锁是当前类的Class对象（模板  不管多少个对象，都是来源于这个锁 ）
 */

6 

两个静态同步方法，两部手机看，请问先打印邮件还是短信  答案：邮件

解释：和第五点几乎一样。

因为第一步手机对象，已经锁住字节码，第二个对象必须等着。所以还是第一个手机对象先。。

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停3秒钟
        System.out.println("发邮件");
    }

    public static synchronized void sendMessage() throws Exception{
        System.out.println("发短信");
    }
}


    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();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

7 

一个静态同步方法，一个普通同步方法，同一部手机，先打印邮件还是短信(普通同步方法)      答案: 短信
当一个线程视图访问同步代码块时，它首先必须得到锁，推出或抛出异常时必须释放锁。
也就是说如果一个实例对象的非静态同步方法获取锁后，该实例对象的其他非静态同步方法必须等待获取锁的方法后才能获取锁，
可是别的实例对象的非静态同步方法因为跟该实例对象的非静态同步方法用的时不同的锁，

所有的静态同步方法用的也是一把锁-类对象本身
这两把锁时两个不同的对象，所以静态同步方法与非静态同步方法之间时不会有静态条件的
但是一旦一个静态同步方法获取锁后，其他的静态同步方法都必须等待该方法释放锁后才能获取锁
还是不同的实例对象的静态同步方法之间，只要他们同一个类的实例对象

通俗的说法：

static锁的是大门（字节码文件），普通synchronize锁的是大门里面的一扇门，它的关闭不影响大门，也与大门无关（锁对象）

class Phone//Phone.java ---> Phone.class    Class.forName()
{
    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停3秒钟
        System.out.println("发邮件");
    }

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


    public static void main(String[] args) throws InterruptedException {
        Phone phone = new Phone();
        new Thread( ()->{
            try {
                phone.sendEmail();
            } catch (Exception e) {
                e.printStackTrace();
            }
        },"A").start();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

8

一个静态同步方法，一个普通同步方法，两部手机，请问先打印邮件还是短信  答案：短信

一个锁类对象，一个锁对象，互不影响。

    public static synchronized void sendEmail() throws Exception{
        TimeUnit.SECONDS.sleep(3);//新的写法
        //Thread.sleep(4000);//暂停3秒钟
        System.out.println("发邮件");
    }

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


    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();

        Thread.sleep( 100 );//这是故意让A在B前面执行

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

Bears9
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基础电子中的别克GL8商务车行驶中门锁经常会跳动故障现象诊断与排除
11-14
故障现象：2004款别克GL8商务车，在行驶中门锁经常会跳动，即车门已经锁好后，车门锁还是在不停地上锁；当车停下来但不熄火时，有时关车门会自动地把门锁上。用遥控器开门、开锁、上锁均工作正常。 故障诊断与排除...
Java的8锁现象
weixin_56018532的博客
09-09 464
Java的8锁现象
【JUC中的 “8锁现象” 】 —— 每天一点小知识
仰望天空，妳我亦是行人.
06-12 516
💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁......
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1277
synchronized关键字到底锁的是谁？
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 694
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7922
深入理解JUC的8锁现象
GA 374-2019 电子防盗锁
10-24
在主锁舌抗轴向静压力方面，A级智能锁由原来的980N增加到了1000N，B级保持不变依旧是3000N，但A、B级受规定轴向静压力时缩进由原来8mm缩小到5mm。在主锁舌抗侧向静压力方面，A级智能锁由原来的1470N增加到1500N，B级...
单片机密码锁设计.doc
02-27
并根据编好的程 序来确定哪个按键按下，并处理相应按键对应的功能，然后把相应的信息反应到 单片机的各个引脚，来实现按键实现的现象，如：显示是否开启锁，报警等。 AT89C51 提供以下标准功能： 4k 字节 Flash 闪速...
基于51单片机的密码锁设计.doc
02-27
并根据编好的程序来确定哪个 按键按下，并处理相应按键对应的功能，然后把相应的信息反应到单片机的各个引脚， 来实现按键实现的现象，如：显示是否开启锁，报警等。AT89C51 提供以下标准功能：4k字节Flash闪速...
ie8打印不正常问题解决
12-21
提示 “ factory.printing 为空或不是对象”，这种现象是网页缺少安装必要的插件造成不能打印，一般情况下网页会提示安装控件， 如不能安装控件可能由以下原因造成： 1.IE网络等级设置过高，请降到中级或以下进行...
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2070
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
Java中的八种锁
chou_out_man的博客
11-16 1435
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
java的8锁现象
qq_45699784的博客
01-28 402
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
JavaSE之8锁现象线程彻底理解锁
weixin_46036165的博客
05-31 159
8锁现象线程彻底理解锁 利用8道题，搞定锁这个概念！ 1.问题一 package com.coding.lock8; import java.util.concurrent.TimeUnit; /* 1、标准的访问情况下，先执行 sendEmail 还是 sendSMS 答案：sendEmail 被 synchronized 修饰的方式，锁的对象是方法的调用者，所以说这里两个方法调用的对象是同一个 先调用的先执行！ */ public class LockDemo01 {
再探JUC-8锁现象
qq_21793443的博客
03-21 412
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
Java并发4——八锁现象
weixin_51818357的博客
07-25 156
Java并发之八锁现象 1.这么说吧，如果两个都是普通方法，那么就看谁先调用，一般先调用先执行 2.如果都是普通方法，但是有加延时，那么就延时少的先调用(因为时间是差不多同时调用，但是一个延时4秒再执行，一个延时2秒再执行，肯定2秒的先执行出来） 3.如果加锁的话，无延时，仍然是谁先调用谁执行 4.如果加锁加延时的话，延时不管，谁先调用谁执行，管它延不延时，反正没执行完不出来，这就是锁的作用 锁的是对象，没结束，锁不释放 （这里先后调用看的是 程序中先调用了哪个方法的线程） 5.两个对象，两把锁，不存在锁的
java的八锁问题
qq_43662627的博客
08-18 267
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
经典 8 锁问题
yage124的博客
05-15 347
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
跟南桑学JUC第三节课（8锁）
ZN175623的博客
10-10 96
>关于8锁的问题 >list的线程安全问题和解决措施
MPU6050万向节锁
最新发布
07-25
MPU6050的万向节锁是指在使用MPU6050传感器时，偏航角会出现不正常的跳动现象。这个问题是硬件问题，即使使用高级算法也无法解决。解决这个问题的方法是添加磁力计，或者直接使用带有磁力计的MPU9250传感器。在使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值