拓展8锁问题

最新推荐文章于 2024-10-06 20:16:20 发布
最新推荐文章于 2024-10-06 20:16:20 发布
阅读量111 收藏
点赞数
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WDlanguang/article/details/108046656
版权

原问题

8锁问题探讨的是在多线程环境中，各线程访问资源的先后顺序。
具体问题为开启两个线程，其中线程2比线程1慢开启，线程1先进入了资源类的sendSms，然后延迟打印“发短信”，根据不同的条件，判断最终是先打印了“发短信”，还是“打电话”。

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

        Phone1 d = new Phone1();
        new Thread(()->{
            d.sendSms();
        }).start();
        
        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);
        
        new Thread(()->{
            d.call();
        }).start();
    }
}

class Phone1{

    public void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

其实，通过查看这8个问题的条件，可以知道他们是通过改变几个条件来产生不同的锁问题的，分别是：

  1. 是否为静态方法
  2. 是否有Synchronized修饰
  3. 实例化一个或是两个资源类对象

而这3个条件可以用枚举法列举出所有的情况：
1、是否为静态方法：
因为有两个方法，所以可能的情况是：两个都为静态方法、两个都为非静态方法、一个静态方法一个非静态方法，共3种。
2、是否有Synchronized修饰：
两个方法都有Synchronized修饰、两个方法都没有Synchronized修饰、一个有修饰一个没有修饰，共3种。
3、实例化一个或是两个资源类对象：
实例化了一个对象、实例化了两个对象，共2种。
注意：

  • 因为这个问题要出现锁，如果没有锁的话就没有讨论的意义了，所以在第二个条件中至少要有一个方法有被Synchronized修饰，所以第二个条件只能有两种情况：两个方法都有Synchronized修饰、一个有修饰一个没有修饰。
  • 条件1的一个静态方法一个非静态方法和条件2的一个有Synchronized修饰一个没有Synchronized修饰的方法有两种可能的组合情况。

因此，总共需要探讨的情况有3×2×2+2=14种。

关注点

在探讨不同线程执行资源类方法的先后顺序中，我们需要了解：
1、当线程执行了资源类的有Synchronized修饰的方法时，它会拿到一个锁，这个锁与该方法是否是静态有关：

  • 如果该方法是静态方法，则拿到的是类锁
  • 如果该方法是非静态方法，则拿到的是对象锁

2、拿到了锁的线程只有在该方法正常执行结束后才会释放锁，之后其他线程才有机会能拿到锁

1、两个都是静态、Synchronized修饰的方法，一个资源类对象
public class LockTest1 {
    public static void main(String[] args) throws InterruptedException {

        Phone1 d = new Phone1();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone1{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

发短信
打电话

资源类的两个方法都有static、Synchronized修饰，所以线程执行任一个方法时都会拿到类锁，而线程一先进入sendSms方法，所以需要等待sendSms执行完毕后才能释放类锁。

2、两个都是静态、Synchronized修饰的方法，两个资源类对象
public class LockTest2 {
    public static void main(String[] args) throws InterruptedException {

        Phone2 d1 = new Phone2();
        Phone2 d2 = new Phone2();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone2{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

发短信
打电话

与第1种情况类似，因为进入两个方法拿到的都是类锁，所以结果打印的先后顺序只与这个类有关，与是这个类的哪个对象调用的方法无关。

3、两个都是非静态、Synchronized修饰的方法，一个资源类对象
public class LockTest3 {
    public static void main(String[] args) throws InterruptedException {

        Phone3 d = new Phone3();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone3{

    public synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果

发短信
打电话

资源类的两个方法是非静态的，并且都有Synchronized修饰，所以线程执行任一个方法后都会拿到对象锁，而两个线程执行的都是同一个资源类对象的方法，所以当线程一执行sendSms方法时拿到了对象锁，此时线程二必须等待线程一释放对象锁后，才有可能拿到对象锁。

4、两个都是非静态、Synchronized修饰的方法，两个资源类对象
public class LockTest4 {
    public static void main(String[] args) throws InterruptedException {

        Phone4 d1 = new Phone4();
        Phone4 d2 = new Phone4();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone4{

    public synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第3种情况类似，但由于是调用两个资源类对象的方法，所以两个线程拿到的对象锁是不同的，两者并不冲突，线程二不用等待，又sendSms方法打印“发短信”的时间较长，所以程序运行结果是先打印了“打电话”，再打印“打短信”。

5、一个静态、Synchronized修饰的方法，一个非静态、Synchronized修饰的方法，一个资源类对象
ew Phone5();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone5{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

执行sendSms方法拿到了类锁，执行call拿到了对象锁，所以线程二不用等待，最终先打印了“打电话”。

6、一个静态、Synchronized修饰的方法，一个非静态、Synchronized修饰的方法，两个资源类对象
public class LockTest6 {
    public static void main(String[] args) throws InterruptedException {

        Phone6 d1 = new Phone6();
        Phone6 d2 = new Phone6();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone6{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第5种情况类似，线程二不用等待，并且与是哪个对象调用的方法无关。

7、一个静态、Synchronized修饰的方法，一个静态、无Synchronized修饰的方法，一个资源类对象
public class LockTest7 {
    public static void main(String[] args) throws InterruptedException {

        Phone7 d = new Phone7();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone7{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

call方法没有Synchronized修饰，只是普通方法，所以线程二不用等待，直接执行call方法。

8、一个静态、Synchronized修饰的方法，一个静态、无Synchronized修饰的方法，两个资源类对象
public class LockTest8 {
    public static void main(String[] args) throws InterruptedException {

        Phone8 d1 = new Phone8();
        Phone8 d2 = new Phone8();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone8{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第7种情况类似。

9、一个非静态、Synchronized修饰的方法，一个非静态、无Synchronized修饰的方法，一个资源类对象
public class LockTest9 {
    public static void main(String[] args) throws InterruptedException {

        Phone9 d = new Phone9();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone9{

    public synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

sendSms方法有Synchronized修饰，所以执行他会拿到对象锁，而call方法只是普通的方法，所以线程二不用等待，直接执行call方法。

10、一个非静态、Synchronized修饰的方法，一个非静态、无Synchronized修饰的方法，两个资源类对象
public class LockTest10 {
    public static void main(String[] args) throws InterruptedException {

        Phone10 d1 = new Phone10();
        Phone10 d2 = new Phone10();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone10{

    public synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第9种情况类似。

11、一个静态、Synchronized修饰的方法，一个非静态、无Synchronized修饰的方法，一个资源类对象
public class LockTest11 {
    public static void main(String[] args) throws InterruptedException {

        Phone11 d = new Phone11();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone11{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

call方法是普通方法，所以线程二不用等待，直接执行call方法。

12、一个静态、Synchronized修饰的方法，一个非静态、无Synchronized修饰的方法，两个资源类对象
public class LockTest12 {
    public static void main(String[] args) throws InterruptedException {

        Phone12 d1 = new Phone12();
        Phone12 d2 = new Phone12();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone12{

    public static synchronized void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第11种情况类似。

13、一个静态、无Synchronized修饰的方法，一个非静态、Synchronized修饰的方法，一个资源类对象
public class LockTest13 {
    public static void main(String[] args) throws InterruptedException {

        Phone13 d = new Phone13();
        new Thread(()->{
            d.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone13{

    public static void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

sendSms方法是普通的方法，而call方法有Synchronized修饰，所以两个线程不用相互等待，线程二会直接执行call方法。

14、一个静态、无Synchronized修饰的方法，一个非静态、Synchronized修饰的方法，两个资源类对象
public class LockTest14 {
    public static void main(String[] args) throws InterruptedException {

        Phone14 d1 = new Phone14();
        Phone14 d2 = new Phone14();

        new Thread(()->{
            d1.sendSms();
        }).start();

        //加大第一个匿名对象先执行sendSms方法的概率
        Thread.sleep(100);

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

class Phone14{

    public static void sendSms() {
        try {
            //延长打印“发短信”的时间
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("发短信");
    }

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

结果：

打电话
发短信

与第13种情况类似。

微淡
关注
〖Python语法进阶篇④〗 - 进程池与进程锁
易编橙 · 终身成长社群，相遇已是上上签！
04-09 4万+
NICE！大家好，在上一章节，我们学习了 multiprocessing 模块 的关于进程的创建与进场常用的方法的相关知识。 通过在一个主进程下创建多个子进程可以帮助我们加速程序的运行，并且提高工作效率。不过上一章节文末我们也说过进程的问题，由于每一个进程都会消耗 `CPU 与 内存` 资源，这样就不能无限的创建进程的问题，因为会造成内存不足或者死机的情况。
〖Python语法进阶篇⑦〗- 线程池与GIL全局锁
热门推荐
易编橙 · 终身成长社群，相遇已是上上签！
04-12 4万+
上一章节我们学习了线程的创建和常用方法，发现它的创建和使用与进程的创建、使用几乎是一样的，只是模块的使用有所区别而已。今天来学习一下线程池的创建与全局锁。线程池的创建于进程池的原理是相同的；关于GIL全局锁，暂时没有代码上的练习，而是对其概念进行一个简单的启蒙。接下来让我们进入正题，开始今天的学习。
MySQL 8 锁表问题排查总结
zhouzhiwengang的专栏
03-10 3581
如果需要过滤用户/db/commond 等相关信息，也可以使用information_schema.processlist 表信息。Table_locks_waited： 指的是不能立即获取表级锁而需要等待的次数，如果数量大，说明锁等待多，有锁争用情况。温馨提示： debug会将状态信息生成到mysql的错误文件，一般锁的信息都会保存在最后几行。Table_locks_immediate： 指的是能够立即获得表级锁的次数。也可以通过mysqladmin 指令打印processlist 进程信息。
基于stm32f103C8T6的智能门锁设计
tycodehh的博客
07-03 5475
本博客介绍了如何基于stm32f103c8t6进行智能门锁的设计，实现了按键解锁、RFID解锁、指纹解锁三种解锁方式，另附带了蓝牙解锁代码，感兴趣的读者可以自行调试。
redis---分布式锁存在的问题及解决方案（Redisson）
池海
04-01 1万+
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.setNx2.set NX NP3.锁超时问题3.1过期时间如何设置3.2锁的续签4.增加锁的可重入性2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人
redis——相关问题汇总
少说，多做。
10-16 2万+
什么是redis？ Redis 本质上是一个 Key-Value 类型的内存数据库， 整个数据库加载在内存当中进行操作， 定期通过异步操作把数据库数据 flush 到硬盘上进行保存。 因为是纯内存操作， Redis 的性能非常出色， 每秒可以处理超过 10 万次读写操作， 是已知性能 最快的 Key-Value DB。 Redis 的出色之处不仅仅是性能， Redis 最大的魅力是支持保存...
MySQL锁汇总，一文搞懂InnoDB所有的锁
秃了也弱了
07-20 2125
锁住的不是record一行记录，也不是column字段，那么InnoDB的行锁锁住的到底是什么呢？在上面三个案例中，我们分析一下它们的差异在哪里，这三张表结构的什么区别导致了加锁行为的差异？答案就是索引。InnoDB的行锁，就是通过锁住索引来实现的。我们准备一张测试表t2，表中有一个主键索引，有四条数据，主键id分别是1、4、7、10。因为我们用主键索引加锁，我们这里的划分标准就是主键索引的值。这些数据库里面存在的主键值，我们把它叫做Record，记录，那么我们这里就有4个Record。
owncloud/nextcloud解决文件锁问题
crazysnail_1986的博客
10-18 5482
```sql 在这里插入代码片 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全...
mysql表字段长度扩容分析--MySQL什么情况下拓展字段长度会锁表？
RAXCL的博客
04-06 754
占位长度byte变化，或者新增字段，会导致数据重写，从而导致主从延迟。
华为应用锁退出立即锁_华为应用锁退出不立即上锁
weixin_35397235的博客
12-30 5117
大家好，我是智能客服时间君，上述问题将由我为大家进行解答。华为应用锁退出不立即上锁的原因可能是设置的问题，或者是需要按电源键锁屏后，应用锁才能生效。华为技术有限公司是一家生产销售通信设备的民营通信科技公司，主要创始人任正非，成立于1987年，总部位于深圳。1996年华为开始进入大独联体市场；1998年将市场拓展到中国主要城市并把触角探向欧美；2003年与3Com合作成立合资公司；2010年首次入围...
2021-2025年中国智能门锁行业三四线城市市场拓展战略研究报告.pdf
07-20
8. 三四线城市市场机遇：三四线城市人口回流、消费潜力上升、新型城镇化推动等因素为智能门锁提供了新的市场机会。同时，三四线城市消费者行为分析显示，收入提高推动消费升级，消费者对本地企业和品牌的认可度较高...
单片机按键调频程序设计高级应用与拓展：解锁更多可能
[单片机按键调频程序设计高级应用与拓展：解锁更多可能](https://img.36krcdn.com/hsossms/20230425/v2_52dae8943ae24d43a9273203c33e95fb@000000_oswg312181oswg1080oswg588_img_000?x-oss-process=image/format,...
JDK1.0主要特性
最新发布
FoolRabbit的专栏
10-06 229
JDK1.0主要特性。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 465
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
java将word转pdf
紫月7575的博客
09-30 556
java将word转pdf
spring-boot 整合 mybatis
m0_72168501的博客
09-29 564
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 812
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1290
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1114
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值