Java 多线程之8锁现象---[观看bilibili-狂神说Java--学习笔记]

最新推荐文章于 2024-04-23 18:52:22 发布
最新推荐文章于 2024-04-23 18:52:22 发布
阅读量66 收藏
点赞数
分类专栏： 笔记 文章标签： java 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43268649/article/details/130066025
版权

场景1

package com.zj970.lock;

/**
 * 标准情况下 是先sendEmail()还是callPhone()?
 * 答案： sendEmail()
 * 解释： 被synchronized 修饰的方式，锁的对象是方法的调用者
 * 所以说这里两个方法调用的对象是同一个，先调用的先执行！
 *
 * @auther zj970
 * @create 2023-04-10 下午4:04
 */
public class LockDemo1 {
    public static void main(String[] args) {
        Phone1 phone = new Phone1();

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

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

class Phone1 {
    public synchronized void sendEmail() { System.out.println(Thread.currentThread().getName() + "--->sendEmail");}

    public synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景2

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * sendEmail()休眠3秒后 是先执行sendEmail()还是callPhone()
 * 答案：sendEmail()
 * 解释：被synchronized修饰的方式，锁的对象是方式的调用者
 * 所以说这里两个方法调用的对象是同一个，先调用的先执行！
 * @auther zj970
 * @create 2023-04-10 下午4:15
 */
public class LockDemo2 {
    public static void main(String[] args) throws InterruptedException {
        Phone2 phone = new Phone2();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone.callOPhone();
        }, "B").start();
    }
}

class Phone2 {
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景3

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 被synchronized修饰的方法和普通方法 先执行sendEmail()还是callPhone()
 * 答案：callPhone()
 * 解释：新增加的这个方法没有synchronized修饰，不是同步方法，不受锁的影响！
 *
 * @auther zj970
 * @create 2023-04-10 下午4:22
 */
public class LockDemo3 {
    public static void main(String[] args) throws InterruptedException {
        Phone3 phone = new Phone3();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone.callOPhone();
        }, "B").start();
    }
}

class Phone3 {
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(4);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    //没有synchronized、static就是普通方式
    public void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景4

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 被synchronized 修饰的不同方法？new两个实例 先执行sendEmail()还是callPhone()
 * 答案：先执行callPhone()
 * 解释：被synchronized修饰的不同方法，锁的对象是调用者也就是实例对象
 * 这里锁的是不同的调用者，所以互不影响
 * @auther zj970
 * @create 2023-04-10 下午4:29
 */
public class LockDemo4 {
    public static void main(String[] args) throws InterruptedException {
        Phone4 phone = new Phone4();
        Phone4 phone1 = new Phone4();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone1.callOPhone();
        }, "B").start();
    }
}

class Phone4 {
    public synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景5

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 两个静态同步方法，都被synchronized修饰。先sendEmail()还是callPhone()?
 * 答案：sendEmail()
 * 解释： 只要方法被static修饰，锁的对象就是class模板对象，这个则全局唯一！
 * 所以说这里是同一个锁，并不是因为synchronized这里程序会从上往下依次执行
 * @auther zj970
 * @create 2023-04-10 下午4:40
 */
public class LockDemo5 {
    public static void main(String[] args) throws InterruptedException {
        Phone5 phone = new Phone5();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone.callOPhone();
        }, "B").start();
    }
}

class Phone5 {
    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public static synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景6

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 被synchronized修饰的普通方法和静态方法 是先sendEmail()还是callPhone()?
 * 答案：callPhone()
 * 解释：只要被static修饰锁的是class模板，而synchronized锁的是调用的对像
 * 这两个锁互不影响，按时间先后执行
 * @auther zj970
 * @create 2023-04-10 下午5:07
 */
public class LockDemo6 {
    public static void main(String[] args) throws InterruptedException {
        Phone6 phone = new Phone6();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone.callOPhone();
        }, "B").start();
    }
}

class Phone6 {
    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景7

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 同被static+synchronized修饰的两个方法（两个实例对象），是先sendEmail()还是callPhone()?
 * 答案：sendEmail
 * 解释：只要方法被static修饰，锁的对象就是class模板对象，这个则全局唯一
 * 所以说这里是同一个锁，并不是因为synchronized
 * @auther zj970
 * @create 2023-04-10 下午5:19
 */
public class LockDemo7{
    public static void main(String[] args) throws InterruptedException {
        Phone7 phoneA = new Phone7();
        Phone7 phoneB = new Phone7();

        new Thread(() -> {
            try {
                phoneA.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phoneB.callOPhone();
        }, "B").start();
    }
}

class Phone7 {
    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public static synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

场景8

package com.zj970.lock;

import java.util.concurrent.TimeUnit;

/**
 * 一个被static+synchronized修饰的方法和普通的synchronized方法，先执行sendEmail还是callPhone?
 * 答案：callPhone()
 * 解释：只要被static修饰的锁就是整个class模板
 * 这里一个锁的是class模板，一个锁的是拥有者
 * 所以锁的是两个对象，互不影响
 *
 * @auther zj970
 * @create 2023-04-10 下午5:40
 */
public class LockDemo8 {
    public static void main(String[] args) throws InterruptedException {
        Phone8 phone = new Phone8();
        Phone8 phone1 = new Phone8();

        new Thread(() -> {
            try {
                phone.sendEmail();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }, "A").start();

        TimeUnit.SECONDS.sleep(2);
        new Thread(() -> {
            phone1.callOPhone();
        }, "B").start();
    }
}

class Phone8 {
    public static synchronized void sendEmail() throws InterruptedException {
        TimeUnit.SECONDS.sleep(3);
        System.out.println(Thread.currentThread().getName() + "--->sendEmail");
    }

    public synchronized void callOPhone() {
        System.out.println(Thread.currentThread().getName() + "--->callPhone");
    }
}

总结

  只要分析锁的对象是那个就可以，staic + synchronized 锁的class全局唯一模板。单独synchronized修饰锁的是调用者（也就是实例化出来的对象，这个不唯一），调用者是同一对象，则按照锁的流程走。没有修饰的不受锁的影响。

zhoujian970
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
learn-thread:Java多线程学习笔记
04-04
学习线程 介绍 Java多线程学习 PDF格式 Java并发编程的艺术.pdf JAVA并发编程实践.pdf图解Java多线程设计模式-第2版.pdf 代码 code1是《 Java并发编程的艺术》的源码ThreadDesignPatterns是《图解Java多线程设计模式》第1版的源码 视频 【狂神说Java】JUC并发编程最新版通俗易懂_哔哩哔哩（゜-゜）つロ干杯〜-bilibili 深入学习java并发编程，java基础进阶中级必会教程_哔哩哔哩（゜-゜）つロ干杯〜-bilibili
Juc并发编程学习笔记---狂神说（全）
ProGram_Java521的博客
10-31 1349
Juc并发编程学习笔记---狂神说（全）
线程安全list_不安全的集合类学习子笔记
weixin_40007515的博客
12-04 267
list不安全类是什么？不安全类是指在多线程并发的时候不能保证数据正确性的类，通常是由于这些类并没有加锁造成的。为什么不设计成加锁的？其实，在list之前有个集合类vector，它是内部加锁，它是一个线程安全类。不优先使用它的原因是加锁可以保证数据的正确性，但却降低了并发效率。list单线程安全，多线程不安全。并发条件下会产生ConcurrentModificationException异常（并发...
狂神JUC八种锁的理解
weixin_63497867的博客
05-06 91
2. 发短信 打电话。3.hello 发短信。1. 发短信 打电话。7. 打电话 发短信。8. 打电话 发短信。
Java 8 - juc - Lock和ReentrantLock
学无止境
06-01 128
【代码】Java 8 - juc - Lock和ReentrantLock。
java“锁事“ 之8lock
一个有信仰的技术人
06-24 248
java锁的八种示例
Java 多线程 线程8锁（含示例代码）
weixin_55871070的博客
04-17 691
以下内容根据视频https://www.bilibili.com/video/BV1vE411D7KE?p=6学习整理 1.标准访问 class Phone{ public synchronized void sendEmail() throws Exception { System.out.println("**sendEmail"); } public synchronized void sendSMS() throws Exception { ...
Java并发之线程八锁
fyphome
01-30 1643
一、引入 先了解什么是synchronized 不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的），记住一点，synchronized不是锁住了方法，而是锁住了使用了该方法的类对象或者对象实例，如： 1. 锁住对象实例： class Test{ public synchronized void test() { } } //等价于 class Test{ public void test() { synchronized(th
bilibili-live-hime：Chrome扩展程序-Bilibili直播姬
01-30
:strawberry: Chrome扩展-Bilibili直播姬 把浏览器页面直播到Bilibili直播间 说明 无需安装OBS这类直播软件，就可以把浏览器任何页面直播到B站，斗鱼或者虎牙的直播间里去，如果你有自己的直播间并且也安装了Node.js...
bilibili-mac-client：Mac的非官方bilibili客户端
02-04
Bilibili Mac客户端 Mac必备的在线视频播放器 产品特点 硬解播放 libass显示弹幕，超低CPU占用 通过支持近百家视频网站的解析与播放 自动分段分段视频 支持发送弹幕 弹幕亮度，字体大小调整 ：本地视频，自动加载同...
bilibili-img-uploader：Chrome扩展程序bilibili img uploader。
01-30
bilibili_img_uploader（Chrome） 哔哩哔哩图片上传插件，可以使用作为一个图床，国内速度快，各种图片格式选择。由于发布到Chrome插件市场需要收费，所以推荐直接下载解压之后用Chrome类浏览器手动导入安装即可。 ...
bilibili-api-docs:bilibili-api 的开发文档
07-24
bilibili-api-docs Python 库 的文档。 请向 dev 分支发起 PR。 若新增文档命名请使用 连字符命名法，如：this-is-an-example.md。 并在 docs/_sidebar.md 中增加对应目录。 使用技术：
经典 8 锁问题
yage124的博客
05-15 346
示例代码 1、资源类 import java.util.concurrent.TimeUnit; public class Phone { // 此方法根据题目需要添加 static public synchronized void sendSMS() { // 使用 TimeUnit 工具类执行 sleep 方法，比 Thread.sleep(毫秒)， // 方便控制输入的时间单位 // 根据题目要求设置该方法的休眠时间 try { TimeUnit.SEC
JDK8之ReentrantLock解读
JackCaptain1015的博客
03-14 736
阅读时请把下面所有代码复制到IDEA中的一个新文件中阅读（代码高亮）。 分析了公平锁与不公平锁，但是主要原理在AQS中，所以大家阅读的时候两者放在一起阅读。
Java8 读写锁的改进:StampedLock(高性能读写锁！)
靡不有初，鲜克有终。
04-29 691
https://blog.csdn.net/sunhaoning/article/details/68924625 https://www.cnblogs.com/ten951/p/6590579.html StampedLock是Java8引入的一种新的所机制,简单的理解,可以认为它是读写锁的一个改进版本,读写锁虽然分离了读和写的功能,使得读与读之间可以完全并发,但是读和写之...
Java多线程之8Lock问题解析
努力努力再努力L
05-13 401
Java多线程之8Lock问题解析 本文目录 1 标准访问的时候，请问先打印邮件还是短信？ 2 sendEmail方法暂停4秒钟，请问先打印邮件还是短信？ 3 新增Hello普通方法，请问先打印邮件还是Hello？ 4 两部手机，请问先打印邮件还是短信？ 5 两个静态同步方法，同1部手机 ,请问先打印邮件还是短信？ 6 两个静态同步方法，有2部手机 ,请问先打印邮件还是短信？ 7 1个静态同步...
Java并发编程：Lock
weixin_30779691的博客
08-20 1606
Java并发编程：Lock 　　在上一篇文章中我们讲到了如何使用关键字synchronized来实现同步访问。本文我们继续来探讨这个问题，从Java 5之后，在java.util.concurrent.locks包下提供了另外一种方式来实现同步访问，那就是Lock。 　　也许有朋友会问，既然都可以通过synchronized来实现同步访问了，那么为什么还需要提供Lock？这个问题将...
Java8 Lock锁详解(AQS，CAS)
Leetp
07-01 2960
什么是Lock锁？ Lock锁提供了的比synchronized关键字更加灵活的锁操作，是代码层面的锁操作。 为什么要使用Lock锁？ Lock锁和synchronized关键字的对比 类型 synchronized关键字 Lock锁 获取锁 无超时时间，未获取到则阻塞等待（占用cpu资源），且无法被中断 非阻塞，可以被中断，未获取到则排队，中断，可以自定义超时时间 共享锁 不支持 读写锁ReadWriteLock支持 释放锁 必须在当前代码块中，因为synchronized是以{
mybatisPlus使用MetaObjectHandler对字段进行更新
最新发布
m0_56356631的博客
04-23 372
都是符合我们的预期的。
you-get下载bilibili视频代码
07-10
但是，你可以使用you-get工具来下载Bilibili视频。你可以按照以下步骤进行操作： 1. 首先，确保你已经安装了Python环境。如果没有安装，可以从Python官方网站（https://www.python.org）下载并安装。 2. 打开...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhoujian970

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值