JUC（2）--- ＞ ⑧ 锁问题

最新推荐文章于 2024-06-02 21:34:36 发布
最新推荐文章于 2024-06-02 21:34:36 发布
阅读量140 收藏
点赞数
分类专栏： JUC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/You_are_mine/article/details/109667948
版权

1、8锁问题

8锁即对应为8个问题
了解这8个问题后：可以判断锁的是谁？什么是锁，锁到底锁的是谁！

问题一：

在标准情况下，两个线程的执行顺序是什么样的？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 09:16
 **/
public class TestEightLock {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendMsg();
        },'A').start();

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

class Phone{
    public synchronized void sendMsg(){
        System.out.println("发短信");
    }

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

在这里插入图片描述
为什么是这样的顺序？
是因为两个线程的先后顺序吗？
是，但是不全面，我们接着来看下一个例子！！！

问题二：

基于问题一，我们将线程A延迟四秒执行，请问现在结果是什么？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 09:16
 **/
public class TestEightLock {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendMsg();
        },'A').start();

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

class Phone{
    public synchronized void sendMsg(){
        try {
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

在这里插入图片描述
可以看到，这里的结果依旧是先发短信再打电话，

原因： synchronized 用在方法上，则锁的对象是方法的调用者，而在这里两个线程公用一个Phone实例，两个方法的锁是同一把，谁先获得谁先执行。

问题三：

增加一个普通方法，线程B进行调用，请问此时线程AB的执行顺序如何？

package com.lixiande.practice1101.eightlock;

import java.sql.Time;
import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 09:16
 **/
public class TestEightLock {
    public static void main(String[] args) {
        Phone phone = new Phone();

        new Thread(() -> {
            phone.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone.hello();
        }).start();
    }
}

class Phone{
    public synchronized void sendMsg(){
        try {
        	// 当时间改变，结果会发生相应的变化
            TimeUnit.SECONDS.sleep(4);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello(){
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： 普通方法不受锁的影响，但两者的执行顺序，是根据获取运行权利的早晚决定，即：当两者的睡眠时间改变，上述结果存在变化。

问题四：

创建两个Phone对象，分别进行线程AB调用，执行顺序？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description:测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 09:45
 **/
public class TestEightLock2 {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Phone2 phone2 = new Phone2();

        new Thread(() -> {
            phone.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone2.call();
        }).start();
    }
}

class Phone2 {
    public synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello() {
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： 这里和问题一对比，线程A、B 分别 拥有一把锁，所以在调用过程互不干扰；执行顺序取决于获取执行权利的早晚。

问题五：

如果将同步方法改为静态同步方法，则在同一对象下，两个线程的执行顺序如何？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 10:23
 **/
public class TestEightLock3 {
    public static void main(String[] args) {
        Phone3 phone3 = new Phone3();

        new Thread(() -> {
            phone3.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone3.call();
        }).start();
    }
}

class Phone3 {
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello() {
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： static静态方法，在程序刚执行的时候，就加载到内存中生成了.class模板

这个class模板是唯一的，所以锁静态方法，其实锁的就是class模板，唯一的。

问题六：

基于问题五，产生两个对象，利用线程A、B分别调用，执行顺序如何？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 10:23
 **/
public class TestEightLock3 {
    public static void main(String[] args) {
        Phone3 phone3 = new Phone3();
        Phone3 phone31 = new Phone3();
        new Thread(() -> {
            phone3.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone31.call();
        }).start();
    }
}

class Phone3 {
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello() {
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： 同问题五，虽然这里创建了两个对象，但是对于.class模板是唯一的，所以调用时还是同一把锁。

问题七：

对于资源类 Phone 改为一个静态同步方法，一个同步方法，两个线程的执行顺序如何？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 10:23
 **/
public class TestEightLock4 {
    public static void main(String[] args) {
        Phone4 phone4 = new Phone4();
        new Thread(() -> {
            phone4.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone4.call();
        }).start();
    }
}

class Phone4 {
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello() {
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： 一个锁是.class模板，一个锁是方法调用者（实例对象），两个线程之间互不影响。

问题八：

基于问题七，增加一个对象，两个线程分别调用静态同步方法和同步方法，两个线程执行顺序如何？

package com.lixiande.practice1101.eightlock;

import java.util.concurrent.TimeUnit;

/**
 * @program: juc
 * @description: 测试8锁问题
 * @author: Mr.LiXianDe
 * @create: 2020-11-13 10:23
 **/
public class TestEightLock4 {
    public static void main(String[] args) {
        Phone4 phone4 = new Phone4();
        Phone4 phone41 = new Phone4();


        new Thread(() -> {
            phone4.sendMsg();
        }).start();
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(() -> {
            phone41.call();
        }).start();
    }
}

class Phone4 {
    public static synchronized void sendMsg() {
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

    public void hello() {
        System.out.println("Hello!");
    }
}

在这里插入图片描述
原因： 同问题七，增加对象之后还是要根据锁的对象是什么，所以在这里两个线程的锁是不一样的，不会互相影响。

PatrickStar_8
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
juc尚硅谷-自学笔记
03-29
《juc尚硅谷-自学笔记》是一份针对Java并发编程领域的深入学习资料，主要涵盖了Java Concurrency Utility（juc）包中的核心概念和技术。在这个压缩包中，"尚硅谷juc"很可能包含了视频教程、课件或者讲义，旨在帮助...
heima-JUC-资料
04-25
在Java中，JUC包（java.util.concurrent）包含了一系列的类和接口，这些类和接口主要用于解决并发问题，如线程池、同步容器、并发集合、锁、原子变量等。下面我们将深入探讨这些关键概念： 1. **线程池**：Java通过...
Java基础-JUC篇-上
Always_zh的博客
11-09 589
Java基础 两句题外话，自己复习整理的知识点，准备发出来分享给大家。有不足之处还望不吝赐教，都是自己手打，难免有错别字，担待，谢谢各位！ JUC 1. 谈谈对volatile的理解 ① 保证可见性 ② 不保证原子性 ③ 禁止指令重排序 ④ volatile的原理和实现机制：观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。内存屏障 ⑤ volatile修饰的变量如果被修改会被强制立即写入主存，但是当前线程被
JUC探险-17、线程池
NarutoConanKing的博客
11-26 570
JUC探险-17、线程池
JUC - 并发编程
Adda_Chen的博客
08-17 409
传统的项目使用线程举例：卖票业务代码如下： 访问结果： 2.修改，可重复锁 - ReentrantLock ReentrantLock官方示例代码： 代码修改为： 访问结果，与之前传统写法一样： 代码优化： 代码过于臃肿，可以使用lamba表达式进行代码简洁 如果不计算返回值的话，上面的是最简洁的，计算的话就下面这样。 但是这样不适应内部逻辑很复杂的代码，因此看情况使用线程调用 .start() 方法后，线程进入就绪状态，并没有直接启动，而是等 cpu 来调用才会启用。查看源码枚举： 引申知识点：
回炉重造java----JUC(第一天)
qq_62366797的博客
06-02 1208
回炉重造java----JUC
Java并发编程与高并发---JUC
weixin_44450721的博客
09-19 316
Java并发编程与高并发解决方案 基本概念 并发:多个线程操作相同的资源，保证线程安全，合理使用资源 高并发:服务能同时处理很多请求，提高程序性能 为什么需要CPU cache : CPU的频率太快了，快到主存跟不上，这样在处理器时钟周期内，CPU常常需要等待主存，浪费资源。所以cache的出现，是为了缓解CPU和内存之间速度的不匹配问题（结构:cpu -> cache -> memory ) . CPU cache有什么意义: 1)时间局部性︰如果某个数据被访问，那么在不久的将来它很可能被
2-并发编程-中级
Steve韩峰的博客
03-12 361
线程问题 线程出现问题的根本原因是因为线程上下文切换，导致线程里的指令没有执行完就切换执行其它线程了， 举例 t1和t2线程分别并行执行5000次++操作和–操作，理论上结果应该等于0。 代码模拟 static int count = 0; public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(()->{ for (int i = 1;i<
java基础01 多线程01-JUC
weixin_44019875的博客
09-07 78
多线程笔记 1.定义 ①程序：为了完成特定的任务，使用某种语言编写的一组指令的集合。一段静态的代码，静态对象； ②进程：一个正在运行的程序，动态的过程，存在开始、运行、消亡的生命周期。 ③线程：线程是程序内部的一条执行路径，也就是说一个程序可以一条路径执行下来那么这个程序就是单线程的。 线程是调度和执行的单位，每个线程都有独立的运行栈和程序计数器。 一个进程可以包括好多个线程。 ④ 内存区域：主要包括本地方法栈、虚拟机栈、程序计数器、方法区、堆；其中方法区和堆区域是一个线程一份，共享区域，虚拟机栈和程序计
Java总结 - 问题总结
yuyehui的博客
09-08 604
1. InnoDB存储引擎，三层B+树，单表能存储多少数据MySQl存储单元为1页，1页为16K，即16384Byte非叶子节点存储单元为主键+指针，大小为8+6=14Byte单页可存储16384/14 ≈ 1170个单元，即可存储1170个子节点每个存储单元可标记1页，则前两层可标记1170x1170页第三层叶子节点存储数据，每条数据约1K，单页则可存储16/1=16个数据三层 B+树，单表可存数据约为1170x1170x16=21902400条数据。
JUC并发学习----Java内存模型_volatile_final原理
https://juejin.cn/user/4248168663101239/posts
07-17 182
Java内存模型一. Java内存模型概念二.Java内存模型的组成①. 主内存②. 工作内存三. JVM内存操作的并发问题①. 工作内存数据一致性②. 指令重排序优化四. Java内存间的交互操作五. Java内存交互的基本操作①. lock (锁定)②. unlock (解锁)③. read (读取)④. load (载入)⑤. use (使用)⑥. assign (赋值)⑦. store (存储)⑧. write (写入)六. Java内存交互基本操作的3个特性①. 原子性(Atomicity)②.
个人学习-JUC-笔记
02-25
通过尚硅谷周阳老师的JUC课程，我们可以系统地学习这些知识点，并通过实践提升自己的并发编程能力，为解决复杂的并发问题打下坚实基础。在实际开发中，合理利用JUC工具可以显著提高程序的并发性能和可维护性。
juc-1(2).docx
03-29
JUC 包含了线程池、并发容器、同步器、定时器等组件，帮助开发者更安全、高效地处理并发问题。 【线程状态】 线程有五种基本状态：新生、就绪、运行、阻塞和死亡。新生状态是在创建后未启动执行前；就绪状态是线程...
Java-JUC-多线程 进阶
07-05
Java-JUC-多线程进阶resources是 Java 并发编程的高级课程，涵盖了 Java 中的并发编程概念、线程安全、锁机制、集合类、线程池、函数式接口、Stream流式计算等多个方面。 什么是JUC JUC（Java Utilities for ...
传感器驱动+imx296驱动+Linux驱动
08-10
传感器驱动+imx296驱动+Linux驱动
ASP校园论坛的设计与实现(源代码+论文).rar
08-10
资源包主要包含以下内容： ASP项目源码：每个资源包中都包含完整的ASP项目源码，这些源码采用了经典的ASP技术开发，结构清晰、注释详细，帮助用户轻松理解整个项目的逻辑和实现方式。通过这些源码，用户可以学习到ASP的基本语法、服务器端脚本编写方法、数据库操作、用户权限管理等关键技术。 数据库设计文件：为了方便用户更好地理解系统的后台逻辑，每个项目中都附带了完整的数据库设计文件。这些文件通常包括数据库结构图、数据表设计文档，以及示例数据SQL脚本。用户可以通过这些文件快速搭建项目所需的数据库环境，并了解各个数据表之间的关系和作用。 详细的开发文档：每个资源包都附有详细的开发文档，文档内容包括项目背景介绍、功能模块说明、系统流程图、用户界面设计以及关键代码解析等。这些文档为用户提供了深入的学习材料，使得即便是从零开始的开发者也能逐步掌握项目开发的全过程。 项目演示与使用指南：为帮助用户更好地理解和使用这些ASP项目，每个资源包中都包含项目的演示文件和使用指南。演示文件通常以视频或图文形式展示项目的主要功能和操作流程，使用指南则详细说明了如何配置开发环境、部署项目以及常见问题的解决方法。 毕业设计参考：对于正在准备毕业设计的学生来说，这些资源包是绝佳的参考材料。每个项目不仅功能完善、结构清晰，还符合常见的毕业设计要求和标准。通过这些项目，学生可以学习到如何从零开始构建一个完整的Web系统，并积累丰富的项目经验。
Unity课程设计报告书PDF
最新发布
08-10
1.技术需求: 此游戏是在Unity5.3.3上开发出来的，Unity5.3.3可以支持2D、3D场景 的编辑，本游戏是基于3D场景开发的。游戏中的脚本语言使用的是C#, Unity5.3.3中的Monodevelop为脚本编辑提供了平台。 2.功能需求: Flappy Bird 是一款益智类的小游戏，其玩法为:游戏开始后，玩家需间歇 性的点击鼠标，让小鸟向上飞，不会掉下来，并且要穿过随机出现的管道的间隙， 不能碰到管道，碰到就游戏结束，穿过一个管道就可以得到一分。其制作包括对 以下六大功能的需求: (1)当开始游戏后，玩家需要单击指定位置才能开始游戏，否则无法开始: (2)需要通过点击屏幕来控制小鸟的位置，完成使小鸟上下移动的功能: (3)需要对小鸟是否碰到地面或者管道进行判断，从而决定游戏是否结束: (4)需要设置触发器以实现场景的延续，当小鸟碰到触发器，场景中的第一幅 背景便挪到最后一幅的后面，从而实现视觉上场景不断出现的效果: (5)需要对玩家进行记分，并对最高分进行判断和存储: (6)在失败后，需要使玩家通过点击按钮重新开始游戏。
毕业设计，基于ASP+ACCESS开发的民航售票管理系统，内含完整源代码，数据库，毕业论文
08-10
毕业设计，基于ASP+ACCESS开发的民航售票管理系统，内含完整源代码，数据库，毕业论文 随着计算机及网络技术的飞速发展，Internet/Intranet应用在全球范围内日益普及，当今社会正快速向信息化社会前进，信息自动化的作用也越来越大。 从而使我们从繁杂的事务中解放出来，提高了我们的工作效率。 本论文主要阐述一个功能比较强大的企业网站系统的后台操作过程及一些关键技术。该系统信息来源主要由用户直接添加，通过管理员审核后,在网站上发布出来,以供大家查询相关公司信息。本系统主要让社会各界能更好的了解本本企业，欢迎对本企业的发展提出更多宝贵留言。该企业网站系统是前台应用Dreamweaver MX、FireworksMX、Flash MX等软件，后台结合ASP编程技术和Access数据库技术开发出来的。 关键词：用户管理；信息发布；ASP；企业网站
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值