Java并发编程原理与实战十一：锁重入&自旋锁&死锁
一、锁重入
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并发编程与实战》龙果学院
Java并发编程原理与实战十一：锁重入&自旋锁&死锁的更多相关文章
- Java并发编程原理与实战五：创建线程的多种方式
一.继承Thread类 public class Demo1 extends Thread { public Demo1(String name) { super(name); } @Override ...
- Java并发编程原理与实战四十二：锁与volatile的内存语义
锁与volatile的内存语义 1.锁的内存语义 2.volatile内存语义 3.synchronized内存语义 4.Lock与synchronized的区别 5.ReentrantLock源码实 ...
- Java并发编程原理与实战三十一:Future&FutureTask 浅析
一.Futrue模式有什么用?------>正所谓技术来源与生活,这里举个栗子.在家里,我们都有煮菜的经验.(如果没有的话,你们还怎样来泡女朋友呢?你懂得).现在女票要你煮四菜一汤,这汤是鸡汤, ...
- Java并发编程原理与实战二十一：线程通信wait¬ify&join
wait和notify wait和notify可以实现线程之间的通信,当一个线程执行不满足条件时可以调用wait方法将线程置为等待状态,当另一个线程执行到等待线程可以执行的条件时,调用notify可以 ...
- Java并发编程原理与实战十五：手动实现一个可重入锁
package com.roocon.thread.ta1; public class Sequence { private MyLock lock = new MyLock(); private ...
- Java并发编程原理与实战十：单例问题与线程安全性深入解析
单例模式我想这个设计模式大家都很熟悉,如果不熟悉的可以看我写的设计模式系列然后再来看本文.单例模式通常可以分为:饿汉式和懒汉式,那么分别和线程安全是否有关呢? 一.饿汉式 先看代码: package ...
- Java并发编程原理与实战九：synchronized的原理与使用
一.理论层面 内置锁与互斥锁 修饰普通方法.修饰静态方法.修饰代码块 package com.roocon.thread.t3; public class Sequence { private sta ...
- Java并发编程原理与实战三十三:同步容器与并发容器
1.什么叫容器? ----->数组,对象,集合等等都是容器. 2.什么叫同步容器? ----->Vector,ArrayList,HashMap等等. 3.在多线程环境下,为什么不 ...
- Java并发编程原理与实战二十五：ThreadLocal线程局部变量的使用和原理
1.什么是ThreadLocal ThreadLocal顾名思义是线程局部变量.这种变量和普通的变量不同,这种变量在每个线程中通过get和set方法访问, 每个线程有自己独立的变量副本.线程局部变量不 ...
随机推荐
- 团队作业4——第一次项目冲刺（Alpha版本）2017.11.16
1.当天站立式会议照片 本次会议在5号公寓3楼召开,本次会议内容:①:熟悉每个人想做的模块.②:根据老师的要求将项目划分成一系列小任务.③:在上次会议内容完成的基础上增加新的任务. 2.每个人的工作 ...
- C++派生类构造函数调用顺序（详解）
我们来看下面一段代码: class B1 { public: B1(int i) {cout<<"constructing B1 "<<i<<e ...
- Sprint2的每日更新
按照以下过程进行 ProductBacklog:继续向下细化 Sprint 计划会议:确定此次冲刺要完成的目标 Sprint Backlog:新的冲刺要完成的内容 任务认领 Sprint周期 看板:一 ...
- 操作系统 cmd mini OS
#include <stdio.h>#include <stdlib.h>#include <string.h> void word(char *a){ if(st ...
- Beta阶段DAY3
一.提供当天站立式会议照片一张 二.每个人的工作 1.讨论项目每个成员的昨天进展 刘阳航:尝试改进UI,美化界面. 林庭亦:调整难度设置. 郑子熙:尝试改进UI,美化界面. 陈文俊:调整难度设置. 2 ...
- python基础（三）python数据类型
一.数据类型 计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值.但是,计算机能处理的远不止数值,还可以处理文本.图形.音频.视频.网页等各种各样的数据,不同的数据,需 ...
- Appium 服务关键字（转）
来源: https://github.com/appium/appium/blob/master/docs/cn/writing-running-appium/caps.cn.md#appium-服务 ...
- 使用 oracle pipelined 返回一个结果集；
1.使用 create or replace package refcursor_pkg is -- Author : mr.yang -- Created : 5/14/2017 5:13:42 P ...
- CentOS下Neo4j安装教程
本文记录一下在CentOS 6.7上,安装neo4j图数据库,本文安装的版本为neo4j-community-2.3.9-unix.tar.gz. 下载Neo4j安装包 使用wget命令获取Neo4j ...
- （转）web性能优化
前端是庞大的,包括 HTML. CSS. Javascript.Image .Flash等等各种各样的资源.前端优化是复杂的,针对方方面面的资源都有不同的方式.那么,前端优化的目的是什么 ? 1. 从 ...