Java并发编程 —— 死锁问题、线程等待

线程的状态转换流程：

---

死锁

• 定义：在多线程编程中（两个或两个以上的线程），因为资源抢占而造成资源无限等待的问题
• 线程和锁的关系 —— 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可以唤醒指定的线程