八锁现象

已于 2022-11-18 20:22:11 修改
阅读量166 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JUC 文章标签： juc
于 2022-11-18 20:21:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48426115/article/details/127928833

        8锁，就是关于锁的8个问题

        1.两个普通的同步方法，一个对象，两个线程先打印发短信还是打电话？

import java.util.concurrent.TimeUnit;

/**
 * 1.两个普通的同步方法，一个对象，两个线程先打印发短信还是打电话？ --  1.发短信  2.打电话
 */
public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

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

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

    }
}


class Phone{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的同一个锁，谁先拿到锁谁就先执行
    public synchronized void sendSMS(){
        System.out.println("发短信");
    }

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

        2.两个普通的同步方法，一个对象，发短信休眠4s，两个线程先打印发短信还是打电话？

import java.util.concurrent.TimeUnit;

/**
 * 2.两个普通的同步方法，一个对象，发短信休眠4s，两个线程先打印发短信还是打电话？ -- 1.发短信  2.打电话
 */
public class Test01 {
    public static void main(String[] args) {
        Phone phone = new Phone();

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

        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}


class Phone{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的同一个锁，谁先拿到锁谁就先执行
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

        3.一个普通方法(非同步)，一个普通的同步方法，一个对象，两个线程先打印发短信还是hello？

import java.util.concurrent.TimeUnit;

/**
 * 3.一个普通方法(非同步)，一个普通的同步方法，一个对象，两个线程先打印发短信还是hello？ --  1.hello  2.发短信
 */
public class Test02 {
    public static void main(String[] args) {

    Phone2 phone = new Phone2();

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

    //休眠1秒
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }

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

}
}


class Phone2{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的同一个锁，谁先拿到锁谁就先执行
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    //这里没有锁！不是同步方法块，不受锁的影响
    public void hello(){
        System.out.println("你好");
    }
}

        4.两个同步方法，两个对象， 两个线程先打印发短信还是打电话？

import java.util.concurrent.TimeUnit;

/**
 * 4.两个同步方法，两个对象， 两个线程先打印发短信还是打电话 --  1.打电话  2.发短信
 */
public class Test03 {
    public static void main(String[] args) {
        //2个对象，2个调用者，两把锁
        Phone3 phone1 = new Phone3();
        Phone3 phone2 = new Phone3();

        new Thread(()->{
            phone1.sendSMS();
        },"A").start();

        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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




class Phone3{
    //synchronized 锁的对象是方法的调用者
    //两个方法用的同一个锁，谁先拿到锁谁就先执行
    public synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    //这里没有锁！不是同步方法块，不受锁的影响
    public void hello(){
        System.out.println("你好");
    }
}

        5.两个静态的同步方法，一个对象，两个线程先打印发短信还是打电话？

import java.util.concurrent.TimeUnit;
/**
 * 5.两个静态的同步方法，一个对象，两个线程先打印发短信还是打电话 -- 1.发短信 2.打电话
 */
public class Test04 {
    public static void main(String[] args) {

        Phone4 phone = new Phone4();

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

        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}


class Phone4{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了，锁的是Class
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

        6.两个静态的同步方法，两个对象，两个线程先打印发短信还是打电话？

/**
 * 6.两个静态的同步方法，两个对象，两个线程先打印发短信还是打电话 -- 1.发短信 2.打电话
 */
public class Test05 {
    public static void main(String[] args) {

        //连个对象的Class类模板只有一个，static,锁的是Class
        Phone5 phone1 = new Phone5();
        Phone5 phone2 = new Phone5();

        new Thread(()->{
            phone1.sendSMS();
        },"A").start();

        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}


//Phone5 唯一的一个Class对象
class Phone5{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了，锁的是Class
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

}

         7. 一个静态同步方法，一个普通的同步方法，一个对象，两个线程先打印发短信还是打电话？

import java.util.concurrent.TimeUnit;

/**
 * 7. 一个静态同步方法，一个普通的同步方法，一个对象，两个线程先打印发短信还是打电话--1.打电话 2.发短信
 */
public class Test06 {
    public static void main(String[] args) {

        //连个对象的Class类模板只有一个，static,锁的是Class
        Phone6 phone = new Phone6();

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

        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

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

    }
}


//Phone6 唯一的一个Class对象
class Phone6{
    //synchronized 锁的对象是方法的调用者
    //static 静态方法
    //类一加载就有了，锁的是Class
    public static synchronized void sendSMS(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通的同步方法，锁的是调用者
    public synchronized void call(){
        System.out.println("打电话");
    }

}

         8. 一个静态同步方法，一个普通的同步方法，两个对象，两个线程先打印发短信还是打电话 ？

import java.util.concurrent.TimeUnit;

/**
 * 8. 一个静态同步方法，一个普通的同步方法，两个对象，两个线程先打印发短信还是打电话--1.打电话 2.发短信
 */
public class Test07 {
    public static void main(String[] args) {
        //连个对象的Class类模板只有一个，static,锁的是Class
        Phone7 phone1 = new Phone7();
        Phone7 phone2 = new Phone7();
        new Thread(() -> {
            phone1.sendSMS();
        }, "A").start();
        //休眠1秒
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }, "B").start();
    }
}

//Phone3 唯一的一个Class对象
class Phone7 {
    //静态的同步方法,锁的是Class
    public static synchronized void sendSMS() {
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    //普通的同步方法，锁的是调用者
    public synchronized void call() {
        System.out.println("打电话");
    }
}

小结

        new this 具体的一个手机

        static Class 唯一的一个模板

锁的艺术：Java并发中的常用锁策略与实践
张彦峰的博客
05-12 170万+
对java锁相关内容进行整理分析：乐观锁 VS 悲观锁+自旋锁 VS 适应性自旋锁+无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁+公平锁 VS 非公平锁+可重入锁 VS 非可重入锁+独享锁 VS 共享锁
跟南桑学JUC第三节课（8锁）
ZN175623的博客
10-10 144
>关于8锁的问题 >list的线程安全问题和解决措施
8锁 现象
DaDaguai001的博客
07-01 440
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
8锁现象
jj89929665的博客
01-21 275
8锁现象1.synchronized锁的对象是方法的调用者，两个方法用的是同一个锁，谁先拿到谁先执行2.这先后是锁的问题，那个线程先拿到3.当增加了一个普通方法，不受锁的影响，先执行4.多个对象跑不同线程，他们的线程不存在抢夺资源，同时进行（2把锁）5.增加个静态同步方法 static 静态方法（锁的是Class，全局唯一）6.两个对象！ 两个静态同步方法，两个对象的Class模板只有一个，static锁的是Class7. 一个静态同步方法（锁的是Class模板），一个普通同步方法（锁的是Phone对象），
Redis从入门到精通(八)Redis实战(五)分布式锁误删与原子性问题、Redisson 测试项目代码
最新发布
04-06
此外，Redisson还实现了公平锁，保证了等待锁的线程按照请求顺序获取锁，避免饥饿现象。 在实际的测试项目代码中，你可能需要关注以下几个方面： 1. 锁的创建和获取：使用`RLock`接口的`lock()`方法获取锁，确保...
AURIX TC3xx device被锁住的各种原因，详细解释介绍case
08-30
八、标头CRC计算 计算并验证所有相关标头的CRC是确保设备正常运行的关键步骤。任何CRC错误都可能导致启动故障。 九、如何锁定/解锁调试接口 调试接口的锁定通常涉及到PFLASH保护。为了重新启用调试，可能需要通过...
8八年级物理上册第二章 声现象综合课后练习二 .doc
11-29
本文将对《八年级物理上册第二章 声现象综合课后练习二》中涉及的各个题目进行详细解析，帮助学生更好地掌握相关知识点。 首先，声音的产生是由于物体的振动。当物体振动时，能够推动周围空气分子的运动，形成一...
苏教版八年级物理上册-声现象单元检测试题-.doc
10-06
标题和描述均指向一个针对八年级学生的物理试题，具体是"声现象"单元的检测试题。试题涵盖了声音的基本概念、声波的特性、声音的传播方式、声音的应用以及噪声控制等多个知识点。 【知识点详细说明】 1. **声音的...
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2165
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
java的8锁现象
qq_45699784的博客
01-28 463
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 813
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC并发编程-8锁现象
凹凸曼的博客
12-18 586
文章目录锁方法的调用者问题一问题二问题三问题四锁class对象问题五问题六同时锁方法的调用者和class对象问题七问题八 首先感谢下B站的狂神，在这里第一次听到“8锁现象”，并弄懂了“锁到底锁的是谁”。 8锁现象，实际对应的就是8个问题。 掌握了这8个问题后：可以清楚判断锁的是谁！知道什么是锁，锁到底锁的是谁！ 锁方法的调用者 问题一 如下代码：标准情况下，下边两个线程先打印 发短信 还是 打电话 ？ public class Test1 { public static void main(Stri
八锁现象的介绍及代码分析
weixin_43786099的博客
08-27 653
好的，前文我们简单的讲述了一下synchronized 锁的三种应用方式，他们是： 普通同步方法（实例方法），锁是当前实例对象 ，进入同步代码前要获得当前实例的锁 静态同步方法，锁是当前类的class对象 ，进入同步代码前要获得当前类对象的锁 同步方法块，锁是括号里面的对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁。 好的我们知道了有这三种方式，但是他们三种不同的应用方式又有着什么不一样的区别呢，难道说还是只是位置不一样，其他作用都是一样的，那肯定不是的啦，他们的锁对象都是不一样的，下面我们就
深入理解JUC的8锁现象
qq_51447436的博客
04-15 8154
深入理解JUC的8锁现象
JUC编程——（二）（深入理解锁—8锁现象，集合类不安全，走进Callable，常用辅助类（CountDownLatch，CyclicBarrier，Semaphore））
weixin_44324174的博客
04-12 332
一、深入理解锁 1、第一组 package com.JUC编程.代码; import java.util.concurrent.TimeUnit; /* * 1.标准情况下,输出: 1/发短信 2/打电话 * 2.sendmsg延迟4秒,输出: 1/发短信 2/打电话 * */ public class MyDemo8 { public static void main(String[...
lock8锁详解现象深入理解
m0_50146072的博客
09-02 581
8锁现象 如何判断锁的是谁！永远的知道什么锁，锁到底锁的是谁！ 深刻理解我们的锁 1、标准访问，先发送邮件还是短信 Email 锁是this 2、暂停3S在邮件方法里，先发送邮件还是短信 Email 锁是this 3、新增hello普通方法，先发送邮件还是hello hello 加个普通方法后发现和同步锁无关 4、有两部手机，先发送邮件还是短信 EMS 锁是两个不同的this，但是需要隔4s才能发送email 5、两个静态同步方法，有一部手机，先发送邮件
【并发编程篇】详细讲解八种锁现象，彻底理解锁
小吉妙妙屋
12-18 1074
原因是因为先调用发短信的方法吗。不对，原因是因为synchronized锁的对象是方法的调用者(发短信和打电话这两个方法，都使用了synchronized)，而且这两个方法都被phone所调用，由于。
解决手机图案解锁提示permission denied的方法
#### 知识点二：permission denied现象 在尝试使用ADB（Android Debug Bridge）工具进行图案解锁操作时，可能会遇到“permission denied”的错误提示。这通常意味着当前用户没有足够的权限去执行ADB命令或者连接到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值