Java并发编程原理与实战十一：锁重入&自旋锁&死锁

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量82 收藏
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/pony1223/p/9375206.html
版权

一、锁重入

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        b();
    }

    public synchronized void b(){
        System.out.println("b");
    }

    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                Demo demo = new Demo();
                demo.a();
            }
        }).start();
    }
}

运行结果：

a
b

以上结果说明，线程A在释放方法a的同步锁之前，是可以重新获得b方法的同步锁的。同一个线程拿到同一个对象的锁，它是可以进入另一个同步方法的，这就是锁的重入。以上代码仅仅是同一个线程在一个同步方法中去成功调用另一个同步方法，并且，锁的是同一个实例。那么，不同的线程拿同一把对象去加锁，会怎样进行呢？

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        //Demo demo1 = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.b();
            }
        }).start();
    }
}

运行结果：

a
b

虽然以上运行结果还是a b，但是，由于锁的是同一个实例，所以，在输出a之后，要等待5s才会输出b。若将以上代码修改为如下，锁的不是同一个实例：

package com.roocon.thread.t6;

public class Demo {
    /*
    当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个
    同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？
     */
    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        Demo demo1 = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo1.b();
            }
        }).start();
    }
}

运行结果：

a
b

a b几乎是同时输出的。

以上两个代码说明，如果多个线程同时去执行同步方法，如果锁的是同一个实例，那么必须等当前这个同步方法释放锁后，才可以去获取另一个同步锁方法。

而如果锁的不是同一个实例，那么，两个同步方法几乎是可以同时执行。有了以上基础，那么再来理解以下代码，就很简单了。

复制代码 
package com.roocon.thread.t6;

public class Demo {

    public synchronized void a(){
        System.out.println("a");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("print b()");
        b();
    }

    public synchronized void b(){
        System.out.println("b");
        try {
            Thread.sleep(8000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Demo demo = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.b();
            }
        }).start();
    }
}
复制代码

运行结果：

a
print b()
b
b

以上结果，先输出a，过了5s后再输出print b()  b，再过了8s输出b，也就是，由于锁的是同一个实例，所以，只有线程1当a方法调用完毕后，线程2才可以获取该实例锁进入b方法。

 

二、自旋锁

自旋锁，自己在不停的旋转，旋的是CPU的时间片，也就是空转CPU。当另外一个线程没有执行结束时，它一直在自旋等待。它会一直等待另外的线程执行完毕。

复制代码 
package com.roocon.thread.t6;

public class Demo2 {
    //多个线程执行完毕后，输出，全部执行完毕
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        System.out.println("全部执行完毕");
    }
}
复制代码

运行结果：

全部执行完毕
Thread-0开始执行...
Thread-1开始执行...
Thread-1执行完毕了
Thread-0执行完毕了

以上结果明显，主线程执行结束后，其他线程还在继续执行。那么，怎么解决这个问题呢？

加入条件判断，如果最后只剩下主线程了，则打印。

复制代码 
package com.roocon.thread.t6;

public class Demo2 {
    //多个线程执行完毕后，输出，全部执行完毕
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        if (Thread.activeCount()==1) {
            System.out.println("全部执行完毕");
        }
    }
}
复制代码

运行结果：

Thread-0开始执行...
Thread-1开始执行...
Thread-0执行完毕了
Thread-1执行完毕了

为什么不输出“全部执行完毕"呢？因为，以上代码是并行执行的，在执行if语句时，Thread.activeCount()根本就不等于1。所以呢，我们让它在不等于1的时候，也就是除了主线程还有别的线程时，让它自旋等待。自旋完毕后，再去执行输出”全部执行完毕“，达到想要的效果。

复制代码 
package com.roocon.thread.t6;

import java.util.Random;

public class Demo2 {
    //多个线程执行完毕后，输出，全部执行完毕
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "开始执行...");
                try {
                    Thread.sleep(new Random().nextInt(2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "执行完毕了");
            }
        }).start();
        while (Thread.activeCount() != 1) {//其实在实际应用中，不能这样去判断线程的个数。全部执行完毕不一定会被正确输出。
　　　　　　//自旋等待
        }
        System.out.println("全部执行完毕");

    }
}
复制代码

运行结果：

Thread-0开始执行...
Thread-1开始执行...
Thread-1执行完毕了
Thread-0执行完毕了
全部执行完毕

以上代码只能说是模拟自旋等待过程。

 

三、模拟死锁

复制代码 
package com.roocon.thread.t6;

public class Demo3 {
    private Object obj1 = new Object();
    private Object obj2 = new Object();

    public void a(){
        synchronized (obj1){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj2){
                System.out.println("a");
            }
        }
    }

    public void b(){
        synchronized (obj2){
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (obj1){
                System.out.println("b");
            }
        }
    }

    public static void main(String[] args) {
        Demo3 demo3 = new Demo3();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo3.a();
            }
        }).start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo3.b();
            }
        }).start();
    }

}
复制代码

运行结果：

控制台一直在运行，但是无任何输出。

通过命令检测是否真的发生了死锁：

点击线程，检测死锁：

 

参考资料：

《java并发编程与实战》龙果学院

转载于:https://www.cnblogs.com/pony1223/p/9375206.html

weixin_30666943
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
龙果 java并发编程原理实战
01-26
龙果 java并发编程原理实战 第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四...
Java并发编程原理与实战
08-14
理解自旋锁，死锁与重入锁.mp4 深入理解volatile原理与使用.mp4 JDK5提供的原子类的操作以及实现原理.mp4 Lock接口认识与使用.mp4 手动实现一个可重入锁.mp4 AbstractQueuedSynchronizer(AQS)详解.mp4 使用AQS重写...
java并发编程实战-17-理解自旋锁-死锁-重入锁----二周目
qq_28764557的博客
09-16 148
重入锁： synchronized加到方法上锁的就是当前类的实例。 package com.roocon.thread.t6; public class Demo { public synchronized void a () { System.out.println("a"); // b(); try { Thread.sleep(1000); } cat...
java死锁 自旋锁_关于java:Java-并发编程AQS-的自旋锁
weixin_32401763的博客
02-27 108
互斥锁在AQS的互斥锁与共享锁中曾经做了具体介绍，一个锁一次只能由一个线程持有，其它线程则无奈取得，除非已持有锁的线程开释了该锁。这里为什么提互斥锁呢？其实互斥锁和自旋锁都是实现同步的计划，最终实现的成果都是雷同的，但它们对未取得锁的线程的解决形式却是不同的。对于互斥锁，当某个线程占有锁后，另外一个线程将进入阻塞状态。与互斥锁相似，自旋锁保障了公共数据在任意时刻最多只能由一条线程获取应用，不同的是...
5-理解自旋锁，重入锁
weixin_40663800的博客
09-27 269
重入锁 重入锁，也就是锁重入，什么意思呢？之前我们用到的synchronized就是一个重入锁。那么，什么是重入锁呢？ 先说非重入锁，我们知道，当多个线程来访问一个方法的时候，比如说这个方法上已经加了一个synchronized，多个线程来进行访问的时候，那么，显然，当一个线程拿到我们的锁之后，那么，其他的线程就需要等待竞争锁，那么，当第一个线程执行完毕释放了这个锁之后，那么，其他的线程才能够...
java 自旋锁（可重入且无死锁）
I_will_try的博客
10-31 552
java自旋锁 的实现原理：如果自旋锁被另外一个线程对象持有，那么当前获取锁的线程将陷入while循环等待，直到那个持有自旋锁的线程对象释放它所持有的自旋锁，那么那些想要获取该自旋锁的线程对象 将会有一个获得该自旋锁。   基于他这种原理，等待的时候，并不释放cpu时间片，相比synchronized  wait()操作，减小了释放，重新获取的消耗。 该自旋锁适用于，当前线程竞争不强烈的时候使用
java重入锁 自旋锁_Java并发编程原理与实战十一：锁重入&自旋锁&死锁
weixin_28869849的博客
02-26 101
一、锁重入packagecom.roocon.thread.t6;public classDemo {/*当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？*/public synchronized voida(){System.out.println("a");b();}p...
java死锁 自旋锁_Java并发编程原理与实战十一：锁重入&自旋锁&死锁
weixin_34185033的博客
02-27 69
一、锁重入packagecom.roocon.thread.t6;public classDemo {/*当第一个线程A拿到当前实例锁后，进入a方法，那么，线程A还能拿到被当前实例所加锁的另一个同步方法b吗？是不是只有当线程A释放了a方法的同步锁后，才可以去获取b方法的同步锁呢？*/public synchronized voida(){System.out.println("a");b();}p...
java并发编程原理与实战_Java并发编程原理与实战二十：线程安全性问题简单总结...
weixin_39595430的博客
02-22 46
•偏向锁Java偏向锁(Biased Locking)是Java6引入的一项多线程优化。偏向锁，顾名思义，它会偏向于第一个访问锁的线程，如果在运行过程中，同步锁只有一个线程访问，不存在多线程争用的情况，则线程是不需要触发同步的，这种情况下，就会给线程加一个偏向锁。如果在运行过程中，遇到了其他线程抢占锁，则持有偏向锁的线程会被挂起，JVM会消除它身上的偏向锁，将锁恢复到标准的轻量级锁。•轻量级锁轻量...
并发编程实战4-自旋锁，死锁，以及锁重入详解
SoundSlow的博客
04-09 713
锁重入：也叫做递归锁 某个线程获得一个已经由它自己持有的锁对象，那么这个请求就会成功，即重入 重入是对本线程来说，即本线程多资源可以多次加锁进入，而不会出现阻塞 在JAVA环境下 ReentrantLock 和synchronized 都是可重入锁 场景：比如数据库中，用户名和密码保存在本地txt文件中，则登录验证方法和更新密码方法都应该被加synchronized，那么当更新密码的时候需要验...
java并发实战视频教程,Java并发编程原理与实战视频教程 共63课
weixin_39606361的博客
03-13 73
021527nhnwqa7a42w25aa4.jpg (40.44 KB, 下载次数: 12)2019-2-22 17:11 上传课程目录:第1节你真的了解并发吗？ 00:27:48分钟第2节理解多线程与并发的之间的联系与区别 00:11:59分钟第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 00:13:03分钟第4节学习并发的四个阶段并推荐学习并发的资料 00:...
Java 并发编程原理与实战视频
02-25
java并发编程原理实战 第2节理解多线程与并发的之间的联系与区别 [免费观看] 00:11:59分钟 | 第3节解析多线程与多进程的联系以及上下文切换所导致资源浪费问题 [免费观看] 00:13:03分钟 | 第4节学习并发的四个...
龙果java并发编程完整视频
01-18
第17节理解自旋锁，死锁与重入锁00:24:58分钟 | 第18节深入理解volatile原理与使用00:28:30分钟 | 第19节JDK5提供的原子类的操作以及实现原理00:27:10分钟 | 第20节Lock接口认识与使用00:19:54分钟 | 第21节手动...
配置Java开发环境
最新发布
Broken_x的博客
07-10 625
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 223
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1123
在 Java 中，可以通过多种方法将一个Object转换为Integer。
java占位符替换五种方式
weixin_61478518的博客
07-08 278
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 2191
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
并发编程，学习手记.pdf
01-19
并发编程是现代软件开发中的关键技能，尤其是在Java领域，它涉及到多个复杂的概念和技术。本文档是一个Java学习者整理的并发编程笔记，旨在提供一个全面的学习指南。以下是部分内容的详细解读： 1. **并发编程基础...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值