八锁现象理解锁

最新推荐文章于 2023-06-12 16:08:46 发布
最新推荐文章于 2023-06-12 16:08:46 发布
阅读量280 收藏 1
点赞数 1
分类专栏： 多线程 JUC并发编程 文章标签： Java 并发 锁机制 同步方法 线程安全
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46027706/article/details/112912317
版权

接下来以代码为例来理解锁的八种情况：

TimeUtils工具类:API提供的常用工具类，时间处理。

1、以下代码是先发短信还是先打电话？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone.call();
            }).start();
        }
}


class Phone{

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

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


}

这时候是先发短信还是先打电话？
在这里插入图片描述

答案是先发短信， 但是我们要记住，这里不是因为hone.sendSms()先执行，而是锁的原因。

2、以下代码是先发短信还是先打电话？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone.call();
            }).start();
        }
}


class Phone{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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


}

答案依然是先发信息再打电话。

在这里插入图片描述
以上两个问题说明了不是因为执行的顺序原因而是锁的问题。
为什么是发短信先执行呢？原因是Synchrinized锁的对象是方法的调用者，这里是phone，两个方式使用的是同一把锁，谁先拿到就会谁来使用，发短信的方法先拿到锁，所以先进行发短信。

问题3:增加一个普通方法并调用，是先打印发短信还是打印hello？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

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


class Phone{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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


}

先看结果：
在这里插入图片描述
为什么呢？原因是因为hello方法不是同步方法，不受锁的影响。

问题4：两个对象，两个同步方法，打印结果是什么样的？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();
            Phone phone2 = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone2.call();
            }).start();
        }
}


class Phone{

    public synchronized void sendSms(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

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


}

结果：
在这里插入图片描述
两个锁对象判断谁先执行是根据对象调用的时间。

问题5：同步方法是静态方法一下代码打印的结果是？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone.call();
            }).start();
        }
}


class Phone{

    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("打电话");
    }



}

结果：
在这里插入图片描述
这里的原因是static修饰的同步方法在类加载的时候就存在了，锁的对象是Class,发短信先把调用。

问题6：两个对象调用两个静态同步方法，以下代码的结果？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();
            Phone phone2 = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone2.call();
            }).start();
        }
}


class Phone{

    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("打电话");
    }



}

看结果：
在这里插入图片描述
为什么呢？原因还是因为这时候的锁对象还是Class对象，Phone和Phone2对象的Class是一样的，所以在调用的时候先打印发短信。

问题7：一个静态同步方法，一个普通方法，一个对象，一下代码的结果是?

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone.call();
            }).start();
        }
}


class Phone{

    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("打电话");
    }



}

看结果：
在这里插入图片描述
解析：这时候锁的对象是两个，一个是Class模板，一个是Phone。属于两把锁，不需要相互去等待，完全可以去根据时间来看结果。

问题8：两个对象，一个静态同步方法一个普通同步方法，以下代码的结果？

package com.yy;

import java.util.concurrent.TimeUnit;

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

            Phone phone = new Phone();
            Phone phone2 = new Phone();

            new Thread(()->{
                phone.sendSms();
            }).start();

            try {
                TimeUnit.SECONDS.sleep(1);   //TimeUtil工具类提供睡眠时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            new Thread(()->{
                phone2.call();
            }).start();
        }
}


class Phone{

    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("打电话");
    }



}

结果：
在这里插入图片描述
原因还是因为程序中存在两把锁，锁的对象有两个，一个是Class模板，一个是Phone2。锁的对象不同，相互之间不需要等待。

总结：通过以上内容我们可以知道static锁的是this的Class模板，而普通的同步方法锁的是方法调用者，如果存在两把锁，调用之间是不冲突的。

InsistCode
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ORACLE锁机制深入理解
09-10
阻塞是数据库并发操作中常见的现象，当一个会话持有另一个会话需要的资源锁时，就会发生阻塞。例如，INSERT、UPDATE、DELETE和SELECT...FOR UPDATE这些DML语句都可能导致阻塞。INSERT操作如果遇到主键冲突，会阻塞...
教你完全理解ReentrantLock重入锁
10-16
公平锁的实现确保了等待获取锁的线程会按照它们请求锁的顺序获取，这在多线程环境中可以减少线程之间的竞争和饥饿现象。然而，公平锁也可能会导致性能下降，因为线程即使有机会获取锁，也可能因为遵守公平性而选择...
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1487
synchronized关键字到底锁的是谁？
【JUC中的 “8锁现象” 】 —— 每天一点小知识
最新发布
仰望天空，妳我亦是行人.
06-12 531
💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁......
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 728
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
五.锁的8种情况
weixin_42480780的博客
04-28 197
多线程8锁 标准访问，先打印短信还是邮件 停4秒在短信方法内，先打印短信还是邮件 普通的hello方法，是先打短信还是hello 现在有两部手机，先打印短信还是邮件 两个静态同步方法，1部手机，先打印短信还是邮件 两个静态同步方法，2部手机，先打印短信还是邮件 1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件 1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件 1.标准访问，先打印短信还是邮件 class Phone{ public synchronized v.
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8006
深入理解JUC的8锁现象
浅析斜井人车使用过程中的自锁现象
05-22
自锁现象的深入分析和理解，以及在此基础上的改型设计，对提高人车的性能和安全性有着重要意义。在实际的斜井人车设计和使用过程中，应充分考虑自锁现象的影响，采取相应的技术和措施，确保人车的安全可靠运行。
thinkPHP框架乐观锁和悲观锁实例分析
10-16
并且，在使用悲观锁时，要注意合理设置事务的隔离级别，以避免脏读、幻读等现象。 在实际应用中，选择使用乐观锁还是悲观锁，需要根据具体的业务场景和并发需求来定。如果业务操作大部分时间不会出现并发冲突，乐观...
juc并发07锁的八种情况
weixin_42537314的博客
09-08 124
8种锁: 1.标准访问，先打印短信还是邮件 2.停留4秒在短信方法内，先打印短信还是邮件 3.新增普通的hello方法，先是打短信还是hello 4.现在有两部手机，先打印短信还是邮件 5.两个静态同步方法，1部手机，先打印短信还是邮件 6.两个静态同步方法，2部手机，先打印短信还是邮件 7.1个静态同步方法，1个普通同步方法，1部手机，先打印短信还是邮件 8.1个静态同步方法，1个普通同步方法，2部手机，先打印短信还是邮件 一、标准访问，先打印短信还是邮件 资源类 创建线程操作方法 结果，因为当前
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2091
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
Java中的八种锁
chou_out_man的博客
11-16 1482
Java中的锁 java中所得分类 公平锁/非公平锁 可重入锁 独享锁/共享锁 互斥锁/读写锁 乐观锁/悲观锁 分段锁 偏向锁/轻量级锁/重量级锁 自旋锁 上面这些分类并不全是指所得状态 ， 有的指锁的特性 ， 有的指锁的设计。 一、公平锁/非公平锁 公平锁是指多个线程按照申请所得顺序来获取锁。 非公平锁是指多个线程获取锁的顺序并不是按照申请锁的顺序， 有可能后申请锁的线程 ， 先获取锁 。 有可
八锁现象的介绍及代码分析
weixin_43786099的博客
08-27 506
好的，前文我们简单的讲述了一下synchronized 锁的三种应用方式，他们是： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 好的我们知道了有这三种方式，但是他们三种不同的应用方式又有着什么不一样的区别呢，难道说还是只是位置不一样，其他作用都是一样的，那肯定不是的啦，他们的锁对象都是不一样的，下面我们就
八锁现象彻底理解锁
harry034的博客
02-09 206
1、synchronized修饰方法时，锁的对象是方法的调用者。如果一个类里面两个方法都有synchronized修饰，且两个方法的调用者是同一个对象，那么两个方法用的是同一个锁，谁先拿到谁先执行。 所以当有调用者不是同一个对象的时候则锁的是不同对象 2、synchronized修饰静态方法时，类一加载就有了，锁的是Class。 ...
8锁现象
c19990515的博客
02-09 147
5、8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ /** * 8锁，就是关于锁的8个问题 * 1、标准情况下，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 * 2、sendSms延迟4秒，两个线程先打印 发短信还是 打电话？ 1/发短信 2/打电话 */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone();
理解一下synchronized锁的是什么
Hai-Yang-code的博客
07-06 335
package com.qcby.lock; import java.util.concurrent.TimeUnit; /** * @author HuangHaiyang * @date 2020/07/06 * @description: description * @version: 1.0.0 */ /** * @Date: 2020/7/6 * 两个普通同步方法 发短信 打电话 * @return: */ public class SyncTest { pu
JUC-多线程锁
weixin_30922589的博客
08-27 177
多线程锁的练习题 1、标准访问，先打印短信还是邮件 class Phone { public synchronized void sendSMS() throws Exception { Thread.sleep(400);题【2】添加延时 System. out .println( "------se...
八锁现象带你了解 synchronized 到底是锁什么？
qq_44613591的博客
11-09 368
什么是八锁现象？ 八锁现象就是加锁的地方不一样，像加在普通方法，静态方法等，可以帮我们搞懂锁锁住的东西是什么。 第一种：标准情况下，两个线程先打印 发短信还是 打电话？ //标准情况下，两个线程先打印 发短信还是 打电话？ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); //锁的存在 new Thread(()-
8锁，就是关于锁的8个问题
weixin_45752694的博客
09-17 263
synchronized 锁的对象是方法的调用者,经过8锁问题能更加理解这个概念
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值