JUC-8锁现象深度剖析

最新推荐文章于 2023-10-12 22:14:42 发布
最新推荐文章于 2023-10-12 22:14:42 发布
阅读量298 收藏
点赞数
分类专栏： 多线程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45610668/article/details/107488983
版权

现象一

多个线程使用一把锁，也就是调用同一个对象，顺序执行。

“被synchronized修饰的方法，锁的对象是方法的调用者”

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

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

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

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendSms() {
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
}

执行结果：发短信  打电话

 

现象二

多个线程使用同一把锁，其中一个锁方法里存在阻塞，顺序执行。

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

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

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

        new Thread(()->{
            phone.call();
        },"B").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("打电话");
    }
}

执行结果：发短信  打电话

 

现象三

多个线程中既有锁方法，也有普通方法，会随机执行。

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

        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    public synchronized void sendSms() {
        //此阻塞时间长短会对结果产生一定影响，但是理论不变
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public  void call() {
        System.out.println("打电话");
    }
}

执行结果：发短信  打电话

 

现象四

多个线程调用多个对象，多个线程使用多把锁，会随机执行。

“Synchronized锁的是方法调用者（即对象），两个线程调用两个不同的对象，所以互不干扰。”

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

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone2{
    public synchronized void sendSms() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }
    public synchronized void call() {
        System.out.println("打电话");
    }
}

执行结果：发短信  打电话

 

现象五

Class锁，static和Synchronized修饰的方法。

多个线程使用一个对象（一把锁）但是被static修饰，所以锁的是class文，全局只有一个class文，会顺序执行。

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

锁class和锁对象的区别：

  1. Class锁：类模板，只有一个；
  2. 对象锁：通过类模板可以new多个对象。
public class Test1 {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    //synchronized锁的是实例对象（即方法的调用者）
    //static 和 synchronized同时修饰 锁的是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("打电话");
    }
}

执行结果：发短信  打电话

 

现象六

Class锁，static和synchronized修饰的方法。

多个线程使用多个对象（多个锁），可是被static修饰，即锁的是class文，全局只有一个class文，会顺序执行。

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

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone{
    //synchronized锁的是实例对象（即方法的调用者）
    //static 和 synchronized同时修饰 锁的是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("打电话");
    }
}

执行结果：发短信  打电话

 

现象七

一个静态同步方法 ，一个普通同步方法。

多个线程去操作同一个对象，会先执行普通同步方法。

“这里虽然只有“一个对象”，但是这“一个对象”调用的方法不同，所以两个线程分别使用两把锁。”

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

        new Thread(()->{
            phone.sendSms();
        },"A").start();
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone.call();
        },"B").start();
    }
}
class Phone{
    //synchronized锁的是实例对象（即方法的调用者）
    //static 和 synchronized同时修饰 锁的是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("打电话");
    }
}

执行结果：打电话  发短信

 

现象八

两个静态同步方法，两个对象。

顺序执行。

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

        new Thread(()->{
            phone1.sendSms();
        },"A").start();
        //睡眠
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        new Thread(()->{
            phone2.call();
        },"B").start();
    }
}
class Phone{
    //synchronized锁的是实例对象（即方法的调用者）
    //static 和 synchronized同时修饰 锁的是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("打电话");
    }
}

执行结果：发短信  打电话

 

 

总结：

//被synchronized修饰的方法，锁的对象是实例对象（即方法的调用者）。

//被static synchronized修饰的方法，锁的对象就是class模板对象，这个是全局唯一的。

 

 

  1. synchronized修饰的，多个线程调用单个对象（一把锁）  顺序执行
  2. synchronized修饰的，多个线程调用多个对象（多把锁）  随机执行 

        （注意发短信线程阻塞时间不同会影响结果，阻塞时间长，后执行，反之亦然，而单个对象，即一把锁，无论发短信线程阻塞时间怎            么设置，都是顺序执行）

    //因为synchronized修饰的，锁的是实例对象（方法调用者），所以单个对象的时候谁先调用就谁先拿到锁先执行，而多个对象的时候就看cpu调度，随机执行。  

    3.static synchronized同时修饰的，多个线程调用单个对象，顺序执行。

    4.static synchronized同时修饰的，多个线程调用多个对象，顺序执行。

    //因为static synchronized同时修饰的，锁的是class文，全局唯一，所以单个对象或多个对象调用的时候都是顺序执行。

 

 

 

Thorzen
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
heima-JUC-资料
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：Java通过...
【JUC中的 “8锁现象” 】 —— 每天一点小知识
仰望天空，妳我亦是行人.
06-12 525
💧8锁现象指的是在多线程环境下，当多个线程同时对同一个对象的不同锁进行操作时，可能导致性能下降的现象。每个对象都有一个与之关联的监视器锁......
八锁现象——synchronized关键字实战详解
欢迎。
05-24 1439
synchronized关键字到底锁的是谁？
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7991
深入理解JUC的8锁现象
JUC学习笔记（二）：八锁现象
m0_56343209的博客
12-16 723
八锁现象主要是指 八种锁的情况，掌握了这八种情况我们以后碰到锁就能明白锁锁的是谁了 在了解八锁之前，我们需要先了解什么是锁： 锁是一种将资源私有化的的方式，在java中就是让某个类、变量、方法在同一个时刻只能被一个线程使用，保证数据的安全性，只要当使用锁的线程释放了这个锁，其它线程才能获取使用。 （1）让两个方法都加上同步锁 package com.lai.lock8; import java.util.concurrent.TimeUnit; /** * @author l...
JUC-八锁现象
菜鸟程序员的成长之路
11-21 1400
JUC 八锁现象 Java并发编程
tuling-juc-final.zip
05-23
本项目"tuling-juc-final.zip"显然聚焦于Java并发编程的实践，通过一系列代码示例来演示和解释Java内存模型（JMM）、`synchronized`关键字以及`volatile`关键字的使用。下面我们将深入探讨这些核心概念。 Java内存...
JUC-master
03-21
《JUC：Java并发编程的艺术》 在Java世界中，JUC（Java Util Concurrency）是并发编程的核心库，它提供了丰富的...通过深入学习JUC-master项目，我们可以更深入地理解Java并发编程的原理和实践，提升我们的编程技能。
个人学习-JUC-笔记
02-25
Java并发编程是Java开发中的重要领域，而JUC（Java Util Concurrency）是Java平台提供的一套高级并发工具包，它极大地简化了多线程和并发控制的复杂性。本笔记主要围绕尚硅谷周阳老师的JUC课程展开，旨在帮助个人...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
JUC并发编程——8锁现象（基于狂神说的学习笔记）
最新发布
whale_cat的博客
10-12 136
static 则表名该方法与Class同步产生，因此，static是在Class对象中的，如果synchronized锁锁住了static方法，则表明锁住了整个Class对象，而因为Class对象唯一（所有的实例对象都通过Class对象创建的）因此，无论后续创建了多少个实例对象资源，最终只要某一线程持有住某一静态同步方法的锁，则其他静态同步方法一律无法使用。8个锁的问题，两两分组，问题，答案，代码皆在下面代码块中，如有问题后续补充。普通同步锁实例，静态同步锁模板，即使再多实例在，静态之间统一管。
JUC并发编程笔记1__JUC概述、虚假唤醒问题、JUC的生产者和消费者关系、8锁问题（对象锁、类锁区别）
m0_62866676的博客
09-13 242
JUC概述、虚假唤醒问题、JUC的生产者和消费者关系、8锁问题（对象锁、类锁区别）
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2086
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
JUC之八锁现象理解锁
可小辉的博客
11-23 249
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_21793443的博客
03-21 428
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
JUC学习之线程8锁
dyt443733328的博客
04-20 745
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
JUC并发编程（二）: 8锁现象(深入理解锁)
Hi_alan的博客
03-05 442
8锁现象 在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？ 首先看下以下8个问题 1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步...
JAVA高并发（JUC）多线程8锁讲解
Cocowwy的博客
05-11 678
先了解一个概念：synchronized 锁的是这个方法所在的资源类，就是这个对象，也就是同一时间段不可能有两个线程同时进到这个资源类，同一时间段，只允许有一个线程访问资源类里面的其中一个synchronized 方法！ T1：1.标准访问，请问先打印邮件还是短信？ 代码如下： public class Lock8 { public static void main(String[] args) { Phone phone = new Phone(); new Thr
"Java-JUC-多线程 进阶：遇见狂神说的JUC并发编程进阶版概要
这门课程于2019年5月31日发布，主要涵盖了以下主题：JUC的概念，进程和线程的回顾，Lock锁的使用，生产者和消费者模式，8锁的现象，集合类的不安全性，Callable的使用以及常用的辅助类。 JUC，即Java Util ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值