线程的状态转换流程:
死锁
- 定义:在多线程编程中(两个或两个以上的线程),因为资源抢占而造成资源无限等待的问题
- 线程和锁的关系 —— 1 对 多:一个线程可以拥有多把锁;而一把锁只能被一个线程拥有
排查死锁的工具:
- 1、jconsole
- 2、jvisualvm
- 3、jmc
手写一个死锁的关键步骤:
- 1、获取锁A
- 2、线程休眠
- 3、获取锁B
package Thread;
/**
* 实现一个死锁
* */
public class ThreadDemo16 {
public static void main(String[] args) {
// 定义两把锁,在java中任何对象都可以作为一把锁
Object lockA = new Object();
Object lockB = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized(lockA){
System.out.println("线程1得到了锁A");
try {
// 休眠一秒,让另一个线程先获得锁B
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1等待获取锁B");
synchronized(lockB){
System.out.println("线程1得到了锁B");
}
}
}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized(lockB){
System.out.println("线程2得到了锁B");
try {
// 休眠一秒,让另一个线程能够获取到锁A
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程2等待获取锁A");
synchronized (lockA){
System.out.println("线程1获取到了锁A");
}
}
}
}, "t2");
t2.start();
}
}
造成死锁的四个条件(同时满足):
- 1、互斥条件 —— 一个资源只能被一个线程持有,当被一个线程持有之后,就不能被其他线程持有了
- 2、请求拥有条件 —— 一个线程已经持有一个资源之后,又试图请求另一个资源
- 3、不可剥夺条件 —— 一个资源在被一个线程持有后,如果这个线程不释放此资源,那么其他线程不能强制获得此资源
- 4、环路等待条件 —— 多个线程在获取资源时形成了一个环形链
如何解决死锁问题?
从以下两个条件入手,修改以下条件的任意一个:
- 1、请求拥有条件
- 2、环路等待条件(最容易实现)
—— 控制获取锁的有序性(破坏了环路等待条件)
package Thread;
/**
* 实现一个死锁
* */
public class ThreadDemo17 {
public static void main(String[] args) {
// 定义两把锁,在java中任何对象都可以作为一把锁
Object lockA = new Object();
Object lockB = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized(lockA){
System.out.println("线程1得到了锁A");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1等待获取锁B");
synchronized(lockB){
System.out.println("线程1得到了锁B");
}
}
}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
synchronized(lockA){
System.out.println("线程2得到了锁A");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程2等待获取锁B");
synchronized (lockB){
System.out.println("线程1获取到了锁B");
}
}
}
}, "t2");
t2.start();
}
}
线程等待
sleep 休眠缺点:必须传递一个明确的结束数据(结束时间)。
wait(休眠)/notify(唤醒)/notifyAll(唤醒全部) —— 线程的通讯机制
线程通讯机制:一个线程的动作可以让另一个线程感知到就叫做县城通讯。
wait为什么要加锁?
- wait在使用的时候需要释放锁,在释放锁之前必须要有一把锁,所以他要加锁
wait为什么要释放锁?
- 因为wait默认是不传任何值的,当不传递任何值的时候表示永久等待,这样就会造成一把锁被一个县城遗址持有,为了避免这种问题出现,所以在使用wait时一定要释放锁
package Thread;
/**
* 使用线程的通讯机制
* */
public class ThreadDemo18 {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程1,执行进入线程方法");
// wait的使用是必选要加锁的
// 如果不加锁,会出现监视器异常
synchronized (lock) {
try {
// 线程休眠
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("线程1,执行完成");
}
}, "t1");
t1.start();
// 使用notify进行线程唤醒
Thread.sleep(1000);
System.out.println("主线程开始唤醒线程1");
synchronized (lock) {
lock.notify();
}
}
}
wait/notify/notifyAll 使用注意事项:
- 1、在使用以上方法时,必须加锁
- 2、加锁对象 和 wait/notify/notifyAll的 对象锁 必须保持一致
- 3、一组wait和 notify/notifyAll 必须是同一对象
- 4、notifyAll只能唤醒当前对象的所有等待线程
Thread.sleep(0) 和 Object.lock(0) 的区别:
- 1、 sleep 它是 Thread 的静态方法;而lock 是 Object 的方法
- 2、sleep(0) 立即触发一次 CPU资源的抢占;lock(0)的含义是永久的等待
wait 和 sleep 的联系:
- 相同点:
1、都可以让当前线程休眠;
2、都必须要处理一个Intcrrupt异常 - 不同点:
1、wait 来自于 Object 中的一个方法;而 sleep 来自于 Thread
2、传参不同,wait可以没有参数,而sleep必须有一个大于等于0的参数
3、wait使用时必须要加锁,sleep使用时不用加锁
4、wait默认不传参的情况下会进入WAITING状态,但有参数情况下会进入TIME_WAITTING状态,而 sleep 会进入 TIME_WAITTING 状态
5、wait使用时会释放锁,而sleep不会释放锁(如何证明?)
package Thread;
/**
* 证明:wait使用时会释放锁
* **/
public class ThreadDemo19 {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock){
System.out.println("线程1拥有了锁lockl");
try {
lock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
t1.start();
Thread.sleep(1000);
// 主线程试图获取锁,如果主线程可以获取到锁,说明wait方法已经将锁释放掉了
synchronized (lock){
System.out.println("主线程获取到lock锁");
}
}
}
package Thread;
/**
* 证明:sleep不会释放锁
* **/
public class ThreadDemo20 {
public static void main(String[] args) throws InterruptedException {
Object lock = new Object();
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
synchronized (lock){
System.out.println("线程1拥有了锁lockl");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程1执行完成,释放锁lock");
}
}
});
t1.start();
Thread.sleep(1000);
// 主线程试图获取锁,如果主线程可以获取到锁,说明wait方法已经将锁释放掉了
synchronized (lock){
System.out.println("主线程获取到lock锁");
}
}
}
为什么wait为放在 Object 中,而不放在 Thread中?
- wait 必须要加锁和释放锁,而锁又是属于对象级别而非线程级别(线程和锁是一对多的关系,也就是说一个线程可以拥有多把锁),所以把 wait 放在 Object 中
因为wait/notifyAll 唤醒线程是随机的,所以java提供一种新的唤醒线程的方法:LockSupport
// 线程休眠
LockSupport.park(); // 线程会进入WATTING状态(没有明确结束时间的状态)
// 并且不用声明异常
// 线程唤醒
LockSupport.unpark(所要唤醒的线程)
wait 和 lockSupport区别:
- 相同点:
1、两个都可以让线程进行休眠
2、二者都可以传参或者不传参,并且二者线程状态也是一致的 - 不同点:
1、wait不需要配合synchronized一起使用(必须加锁),而LockSupport不需要加锁
2、wait只能唤醒全部和随机的一个线程,而LockSuport可以唤醒指定的线程