JUC并发编程（五）-8锁的现象

最新推荐文章于 2024-08-27 20:12:34 发布
最新推荐文章于 2024-08-27 20:12:34 发布
阅读量2.1k 收藏 14
点赞数 7
分类专栏： JUC并发编程
本文链接：https://blog.csdn.net/makyan/article/details/104524725
版权

5、8锁的现象

以下名词解释：

顺序执行：先调用的先执行；

随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。

5.1. 多个线程使用同一把锁-顺序执行

1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！

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

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseOneLock01 {
    public static void main(String[] args){

        Mobile mobile = new Mobile();
        // 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
        new Thread(()->mobile.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile {
    // 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendEmail() {
        System.out.println("sendEmail");
    }

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

5.2. 多个线程使用同一把锁，其中某个线程里面还有阻塞-顺序先执行

2、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行,即使在某方法中设置了阻塞。

示例2、邮件方法暂停4秒钟，请问先打印邮件还是短信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseOneLock02 {
    public static void main(String[] args){

        Mobile2 mobile = new Mobile2();
        // 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
        new Thread(()->mobile.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile2 {
    // 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendEmail() {

        //多个线程使用一把锁，这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

5.3. 多个线程有锁与没锁-随机执行

多个线程，有的线程有锁，有的线程没锁，两者之间不存在竞争同一把锁的情况，先后执行顺序是随机的。

​ 这种情况犹如你跟你老婆下班回家，家里面的厕所是有锁的，卧室没有锁，俩人到家后，你老婆先上厕所（有锁），你可以一直等待你老婆出来，你再去厕所后，才进卧室，你也可以先进卧室，等你老婆出来后，你再进厕所。

示例3、新增一个普通方法接收微信()没有同步,请问先打印邮件还是接收微信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadHaveLockAndNot03 {
    public static void main(String[] args){

        Mobile3 mobile = new Mobile3();
        // 两个线程使用的是同一个对象。两个线程是一把锁！先调用的先执行！
        new Thread(()->mobile.sendEmail(),"A").start();

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

        new Thread(()->mobile.getWeixinMs(),"C").start();
    }
}

// 手机，发短信，发邮件
class Mobile3 {
    // 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendEmail() {

        //多个线程使用一把锁，这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

    //接收微信，没有锁
    public void getWeixinMs() {
        System.out.println("getWeixinMs");
    }
}

5.4. 多个线程使用多把锁-随机执行

1、被 synchronized 修饰的方法，锁的对象是方法的调用者；
2、调用者不同，它们之间用的不是同一个锁，相互之间没有关系。

示例4、两部手机、请问先打印邮件还是短信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseMultiLock04 {
    public static void main(String[] args){

        // 两个对象，互不干预
        Mobile4 mobile1 = new Mobile4();
        Mobile4 mobile2 = new Mobile4();

        new Thread(()->mobile1.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile4 {
    /**
     *  @description:
     *  被 synchronized 修饰的方法，锁的对象是方法的调用者；
     *  调用者不同，它们之间用的不是同一个锁，相互之间没有关系。
     */
    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.5. Class锁：多个线程使用一个对象-顺序执行

被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。

锁Class和锁对象的区别：

1、Class 锁 ，类模版，只有一个；

2、对象锁 ， 通过类模板可以new 多个对象。

如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。

示例5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseOneObjectOneClassLock05 {
    public static void main(String[] args){


        Mobile5 mobile = new Mobile5();

        new Thread(()->mobile.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile5 {
    /**
     *  @description:
     *锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     *被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
     */
    public synchronized static void sendEmail() {

        //这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

5.6. Class锁：多个线程使用多个对象-顺序执行

被 synchronized 修饰 和 static 修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。

Class锁是唯一的，所以多个对象使用的也是同一个Class锁。

示例6、两个静态同步方法，2部手机，请问先打印邮件还是短信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseMultiObjectOneClassLock06 {
    public static void main(String[] args){


        Mobile6 mobile1 = new Mobile6();
        Mobile6 mobile2 = new Mobile6();

        new Thread(()->mobile1.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile6 {
    /**
     *  @description:
     *锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     * 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
     */
    public synchronized static void sendEmail() {

        //这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

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

5.7. Class锁与对象锁：多个线程使用一个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；

只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

示例7、一个普通同步方法，一个静态同步方法，同一部手机，请问先打印邮件还是短信？

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseOneObjectClassLockAndObjectLock07 {
    public static void main(String[] args){


        Mobile7 mobile = new Mobile7();

        new Thread(()->mobile.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile7 {
    /**
     *  @description:
     *锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     * 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
     */
    public synchronized static void sendEmail() {

        //这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    /**
     *  @description:
     *  普通同步锁：对象锁
     */
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }
}

5.8. Class锁与对象锁：多个线程使用多个对象-随机执行

被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁；

只被synchronized修饰的方法，是普通锁（如对象锁），不是Class锁，所以进程之间执行顺序互不干扰。

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

package com.interview.concurrent.lock.locakType;

import java.util.concurrent.TimeUnit;

/**
 * @author yangxj
 * @description 描述
 * @date 2020/2/22 15:57
 */
public class MultiThreadUseMultiObjectClassLockAndObjectLock08 {
    public static void main(String[] args){


        Mobile8 mobile1 = new Mobile8();
        Mobile8 mobile2 = new Mobile8();

        new Thread(()->mobile1.sendEmail(),"A").start();

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

// 手机，发短信，发邮件
class Mobile8 {
    /**
     *  @description:
     *锁Class和锁对象的区别：
     * 1、锁 Class，类模版，只有一个;
     * 2、锁  对象，通过 类模板可以new 多个对象.
     * 如果全部都锁了Class，那么这个类下的所有对象都具有同一把锁。
     * 被 synchronized和static修饰的方法，锁的对象是类的class对象！唯一的同一把锁
     */
    public synchronized static void sendEmail() {

        //这里设置一个干扰
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("sendEmail");
    }

    /**
     *  @description:
     *  普通同步锁：对象锁
     */
    public synchronized void sendMS() {
        System.out.println("sendMS");
    }
}

小结

new this 本身的这个对象，调用者

static class 类模板，保证唯一！

一个对象中有多个 synchronized 方法，某个时刻内只要有一个线程去访问 synchronized 方法了就会被加锁，独立公共厕所！其他线程就会阻塞！

加了一个普通方法后 ，两个对象，无关先后，一个有锁，一个没锁！情况会变化！

换成静态同步方法，情况会变化！ CLASS ，所有静态同步方法的锁唯一 ， 对象实例class 本身！

makyan
关注
专栏目录
java的八锁问题
qq_43662627的博客
08-18 313
java的锁有对象锁和类锁两种，但不同的锁在不同的场景下是不同的，区别在于 1.对于普通同步方法，锁是当前实例对象(this)。 2.对于静态同步方法，锁是当前类的Class对象。 3.对于同步方法块，锁是Synchonized括号里配置的对象 讨论到java的八锁问题，我们一般讨论的是java锁住了类还是对象，或者或者是静态方法块 同步方法块的讨论 package day2.八锁问题; import org.junit.Test; import java.util.concurrent.TimeUn
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 896
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 758
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC并发编程
最新发布
AlwaysBestSign_X的博客
08-27 34
https://github.com/CL0610/Java-concurrency?tab=readme-ov-file
8锁 现象
DaDaguai001的博客
07-01 408
以下都是为了更好的解释锁。 1 标准访问，先打印邮件还是先发送短信 解释 ：这个是不能确定的，线程的调度与cpu有关，所以不能确定。 class Phone//Phone.java ---> Phone.class Class.forName() { public synchronized void sendEmail() throws Exception{ //TimeUnit.SECONDS.sleep(3);//新的写法 //Threa..
java多线程 线程八锁
ankan7400的博客
02-05 123
package com.java.juc; /** * 题目：判断打印 "one" or "two" * * 1.两个普通同步方法，两个线程 ，标准打印，打印？// one two * 2.新增Thread.sleep(3000) 给getOne() 打印？ // 3s 后打印 one two * 3.新增普通方法 getThreee 打印？// 先打印thr...
跟南桑学JUC第三节课（8锁）
ZN175623的博客
10-10 114
>关于8锁的问题 >list的线程安全问题和解决措施
java并发编程专题（五）----详解（JUC）ReentrantLock
08-18
Java并发编程中的ReentrantLock是Java并发包（java.util.concurrent，简称JUC）中的一个重要的锁机制，它是Lock接口的一个具体实现，提供了比synchronized更强大的锁定功能和更细粒度的控制。ReentrantLock的主要...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
07-26
在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java内存模型和线程同步机制。 **可重入锁与可重入性** 可重入锁允许同一个线程反复进入它已经拥有的锁所保护的代码段。在Java中，...
java并发编程-AQS和JUC实战
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
JUC并发编程《Java-2021面试谈资系列》
zjdzka的博客
03-25 3203
JUC并发编程一、什么是JUC二、线程和进程三、Lock锁(重点)区别：四、生产者消费者五、8锁现象问题1，2问题3，4问题5，6问题7，8总结六、集合不安全CopyOnWriteArrayListCopyOnWriteSetConcurrentHashMap七、Callable八、常用辅助类CountDownLatchCyclicBarrierSemaphore九、读写锁十、阻塞队列方式一方式二方式三方式四同步队列十一、JMM十二、Volatile十三、单例模式十四、CAS十五、原子引用十六、各种锁的理解
JUC-8锁现象深度剖析
314
07-21 342
现象一 多个线程使用一把锁，也就是调用同一个对象，顺序执行。 “被synchronized修饰的方法，锁的对象是方法的调用者” public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ phone.sendSms(); },"A").start();
8锁现象
c19990515的博客
02-09 157
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();
JUC底层的详细学习+狂神JUC笔记+全网最全
热门推荐
qq_41617848的博客
07-27 2万+
1、什么是JUC 源码+官方文档 JUC是 java util concurrent 面试高频问JUC~！ java.util 是Java的一个工具包~ 业务：普通的线程代码 Thread Runnable： 没有返回值、效率相比于Callable 相对较低！ 2、线程和进程 进程：一个程序，QQ.EXE Music.EXE；数据+代码+pcb 一个进程可以包含多个线程，至少包含一个线程！ Java默认有几个线程？2个线程！ main线程、GC线程 线程：开了一个进程Typora，写字，等待几分钟会进行
JUC之八锁现象理解锁
可小辉的博客
11-23 265
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锁现象
qq_51447436的博客
04-15 8073
深入理解JUC的8锁现象
JUC学习之线程8锁
dyt443733328的博客
04-20 766
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
再探JUC-8锁现象
qq_21793443的博客
03-21 474
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
java的8锁现象
qq_45699784的博客
01-28 428
锁的8个现象我写了4个测试类，每个测试类里两个现象都是相似的！！！ /** * 8锁现象 * 1.先发短信还是先打电话？ 答：先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出 * 2.在发短信方法中加4秒延时，看先发短信还是先打电话？ 答：还是先发短信，再打电话，因为synchronized 锁的对象是方法的调用者，谁先执行谁先输出，即使发短信方法卡着4秒但是锁还没有被释放 * */ public class TestLock1 { public
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值