JUC-02-8锁现象

最新推荐文章于 2024-07-13 15:29:04 发布
最新推荐文章于 2024-07-13 15:29:04 发布
阅读量147 收藏
点赞数
分类专栏： JavaSE-高级 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44900198/article/details/106823480
版权

现象一

多个线程使用一把锁，也就是调用同一个对象，谁先调用谁先执行

被 synchronized 修饰的方法、锁的对象是方法的调用者


public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程使用同一个对象（同一把锁）
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(3); // 中途睡眠

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

class Phone {
	// 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendMessage(){
        System.out.println("发短信");
    }

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

现象二

多个线程使用同一把锁，某个锁方法里有阻塞，依旧是谁先调用谁先执行

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程使用同一个对象（同一把锁）
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(3); // 中途睡眠

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

class Phone {

	// 被 synchronized 修饰的方法、锁的对象是方法的调用者、
    public synchronized void sendMessage(){
    	// 添加阻塞
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

现象三

多个线程中既有 有锁方法 也有无锁方法 会 随机执行

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程使用同一个对象（同一把锁）
        Phone phone = new Phone();

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

        TimeUnit.SECONDS.sleep(3); // 中途睡眠

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

class Phone {

	// synchronized 锁的对象是方法的调用者！
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

    // 这里是无锁方法
    public void call(){
        System.out.println("打电话");
    }
}

现象四

多个线程调用多个对象，多个线程使用多把锁， 会随机执行
Synchronized 锁的是方法调用者，两个线程调用两个不同的对象，所以互不干扰

package com.it.lock8;

import java.util.concurrent.TimeUnit;

/**
 * @author shkstart
 * @create 2020-06-18 9:21
 */

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程分别使用两把锁
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            phone1.sendMessage();
        }).start();

        TimeUnit.SECONDS.sleep(3); // 中途睡眠

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

class Phone {
	
	// synchronized 锁的对象是方法的调用者！
    public synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

现象五

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

被 synchronized 和 static 同时修饰的方法，锁的对象是类的 class 对象，是唯一的一把锁。线程之间是顺序执行。
锁Class和锁对象的区别：
1、Class 锁 ，类模版，只有一个；
2、对象锁 ， 通过类模板可以new 多个对象

public class Test {

   public static void main(String[] args) throws InterruptedException {

       // 两个线程使用同一把锁
       Phone phone = new Phone();

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

       TimeUnit.SECONDS.sleep(3); // 中途睡眠

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

class Phone {

   // synchronized 锁的对象是方法的调用者！
   // static 和 synchronized 同时修饰锁的是class
   public static synchronized void sendMessage(){
       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文，全局只有一个 会 顺序执行

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程分别使用两把锁
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            phone1.sendMessage();
        }).start();

        TimeUnit.SECONDS.sleep(3); // 中途睡眠

        new Thread(()->{
            phone2.call();
        }).start();
    }
}
// class 是唯一的class对象
class Phone {

    // synchronized 锁的对象是方法的调用者！
    // static 和 synchronized 同时修饰锁的是class
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }


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

现象七

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

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程分别使用两把锁
        Phone phone = new Phone();

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

//        TimeUnit.SECONDS.sleep(3); // 中途睡眠

        new Thread(()->{
            phone.call();
        }).start();
    }
}
// class 是唯一的class对象
class Phone {

    // synchronized 锁的对象是方法的调用者！
    // static 和 synchronized 同时修饰锁的是class
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }


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

现象八

两个静态同步方法，两个对象
顺序执行

public class Test {

    public static void main(String[] args) throws InterruptedException {

        // 两个线程分别使用两把锁
        Phone phone1 = new Phone();
        Phone phone2 = new Phone();

        new Thread(()->{
            phone1.sendMessage();
        }).start();

//        TimeUnit.SECONDS.sleep(3); // 中途睡眠

        new Thread(()->{
            phone2.call();
        }).start();
    }
}
// class 是唯一的class对象
class Phone {

    // synchronized 锁的对象是方法的调用者！
    // static 和 synchronized 同时修饰锁的是class
    public static synchronized void sendMessage(){
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }


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

总结

  1. 被 synchronized 修饰的方法，锁的对象是方法的调用者(实例对象)

  2. 被 static synchronized 修饰的方法，锁的对象就是 Class模板对象,这个则全局唯一

synchronized修饰的 多个线程调用单个对象（一把锁） 顺序执行

synchronized 修饰的 多个线程调用多个对象（多把锁） 随机执行

因为synchronized修饰 锁的是方法调用者（对象），
所以单个对象的时候谁先调用谁就先拿到锁先执行
多个对象的时候根据CPU调度，随机执行



static synchronized 修饰的 多个线程调用单个对象 顺序执行

static synchronized 修饰的 多个线程调用多个对象  顺序执行

因为 static synchronized 修饰 锁的是class 全局唯一
所以单个单个对象或多个对象调用的时候都是顺序执行
六道佩奇。
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
4、JUC：8锁问题
cxycxytony的博客
10-31 118
第一组 package com.chen.lock8; import java.util.concurrent.TimeUnit; /** * 8 锁，就是关于锁的8个问题 * 1、标准情况下，两个线程先打印 打电话 还是 发短信？ 1.发短 2.打电话 * 2、sendSms延迟4秒，两个线程先打印 打电话 还是 发短信？ */ public class Test1 { public static void main(String[] args) { Phone ph
JUC学习之线程8锁
dyt443733328的博客
04-20 745
本文为看视频学习资料，若有错误，请指正，谢谢！介绍线程8锁围绕一个题目展开，题目：打印的是“one”还是“two”？1.两个普通同步方法，两个线程，打印？public class TestThread8Monitor { public static void main(String[] args){ Number number = new Number(); ...
JUC- 八锁现象
hxy1625309592的博客
02-22 130
4.4 八锁现象 4.4.1 标准访问 package cn.guardwhy.test04; import java.util.concurrent.TimeUnit; /* * 标准访问：先发短信还是打电话? */ public class LockTest01 { public static void main(String[] args) { // 创建phone对象 Phone phone = new Phone(); new Thre
JUC -八锁现象
m0_46276938的博客
05-18 157
juc的八锁现象 8锁其实就是关于锁的8个问题 问题一和问题二 代码演示： 1.标准情况下，两个线程先打印 发短信和打电话 2.senMesg 延迟4秒，两个线程先打印 发短信和打电话 因为方法上有锁，锁的是phone这个类，所有会先发短信 再打电话 * */ public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(
JUC并发编程（二）: 8锁现象(深入理解锁)
Hi_alan的博客
03-05 442
8锁现象 在并发编程中，一直在谈论锁，但是锁到底是什么呢？它锁的是什么？ 首先看下以下8个问题 1、一部手机，两个线程，标准访问，请问先打印邮件还是短信？ 2、邮件方法暂停4秒钟，请问先打印邮件还是短信？ 3、新增一个普通方法hello()没有同步,请问先打印邮件还是hello？ 4、两部手机、请问先打印邮件还是短信？ 5、两个静态同步方法，同一部手机，请问先打印邮件还是短信？ 6、两个静态同步...
heima-JUC-资料
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：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-八锁现象
菜鸟程序员的成长之路
11-21 1400
JUC 八锁现象 Java并发编程
JAVA高并发（JUC）多线程8锁讲解
Cocowwy的博客
05-11 676
先了解一个概念：synchronized 锁的是这个方法所在的资源类，就是这个对象，也就是同一时间段不可能有两个线程同时进到这个资源类，同一时间段，只允许有一个线程访问资源类里面的其中一个synchronized 方法！ T1：1.标准访问，请问先打印邮件还是短信？ 代码如下： public class Lock8 { public static void main(String[] args) { Phone phone = new Phone(); new Thr
JUC-8锁现象深度剖析
314
07-21 298
现象一 多个线程使用一把锁，也就是调用同一个对象，顺序执行。 “被synchronized修饰的方法，锁的对象是方法的调用者” public class Test1 { public static void main(String[] args) { Phone phone = new Phone(); new Thread(()->{ phone.sendSms(); },"A").start();
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_40927884的博客
05-20 512
class Phone { public static synchronized void SendSMS() throws InterruptedException { TimeUnit.SECONDS.sleep(4); System.out.println("发了短信"); } public synchronized void ...
再探JUC-8锁现象
qq_21793443的博客
03-21 428
第二篇Java技术分享(再探JUC-8锁现象) Jpunster 前文：小伙伴们，大家好，这篇技术分享主要是讲解一下 JUC-locks下存在的8锁的问题（关于锁的8个问题），为了解决面试时不会判断锁的问题：知道是什么锁，并且判断锁的是谁！ 在开始正文之前，我们先来解决上篇文章遗留的一个小作业，i++是否是线程安全的？不知道大家有没有想出来呢？ 答案是：是不安全的。 举个例子： tp = i; ...
深入理解JUC的8锁现象
qq_51447436的博客
04-15 7990
深入理解JUC的8锁现象
JUC并发编程（五）-8锁的现象
二总的猫
02-26 2086
5、8锁的现象 以下名词解释： 顺序执行：先调用的先执行； 随机执行：没有规律，与计算机硬件资源有关，哪个线程先得到资源就先执行，各个线程之间互不干扰。 5.1. 多个线程使用同一把锁-顺序执行 1、多个线程使用同一个对象，多个线程就是使用一把锁，先调用的先执行！ 示例1、标准访问，请问先打印邮件还是短信？ package com.interview.concurrent.lock.lo...
java学习----递归
最新发布
qq_56798493的博客
07-13 145
【代码】java学习----递归。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值