线程通信的方法

线程通信的方法

程序在使用多线程执行任务时，经常需要线程之间协同工作。此时，我们需要了解线程通信的手段。

线程通信大致分为以下四类：

• 文件共享
• 网络共享
• 共享变量
• JDK提供的线程协调API

本文主要研究第四类，如何使用JDK提供的API正确地阻塞、唤醒目标线程。

Thread#suspend()和Thread#resume()

Thread#suspend()：挂起目标线程不再继续执行，直到它被resume()唤醒。

Thread#resume()：如果目标线程已被挂起，那么唤醒目标线程并允许它继续执行。

举个栗子:

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    // 正常的suspend/resume
    private static void suspendResume() throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    System.out.println("没有包子，进入等待");
                    // 挂起当前线程
                    Thread.currentThread().suspend();
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 唤醒目标线程
        thread.resume();
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendResume();
    }    
}

运行main()方法，控制台输出如下：

没有包子，进入等待
包子做好了
买到包子，回家

suspend()和resume()帮助我们在适当的时候阻塞和唤醒线程，成功地模拟了顾客在包子店买包子的情景。

但是，这对API在JDK1.2之后被弃用，原因是它们特别容易形成死锁。

如果目标线程持有监视器锁，在调用suspend()挂起目标线程时并不会释放这把锁。此时，如果其他线程在调用目标线程的resume()方法之前也要先获取这把锁，死锁就产生了。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    // 会死锁的suspend/resume
    private static void suspendResumeDeadLock() throws InterruptedException {
        final Object lock = new Object();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    System.out.println("没有包子，进入等待");
                    // 当前线程拿到锁，然后挂起
                    synchronized (lock) {
                        Thread.currentThread().suspend();
                    }
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 争取到锁以后再唤醒目标线程
        synchronized (lock) { // 此处会一直BLOCKED
            System.out.println("包子做好了");
            thread.resume();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendResumeDeadLock();
    }    
}

运行main()方法，程序无法退出，控制台输出如下：

没有包子，进入等待

唤醒目标线程的条件已经满足（包子做好了），但是拿不到锁，就无法唤醒目标线程，程序就这样被“冻结”。

即使在不涉及监视器锁的情况下使用suspend()和resume()，如果调用顺序不当，线程也可能永远挂起。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    // 会永远挂起的suspend/resume
    private static void suspendForever() throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    try {
                        // 睡眠一段时间，让resume()方法先执行
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("没有包子，进入等待");
                    // 挂起当前线程
                    Thread.currentThread().suspend();
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 唤醒目标线程（此时线程还未挂起）
        thread.resume();
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendForever();
    }    
}

运行main()方法，程序无法退出，控制台输出如下：

包子做好了
没有包子，进入等待

上面的例子中，resume()在suspend()之前被调用，目标线程被挂起之后，没有线程来调用resume()唤醒它，就会永远挂起。

既然Thread#suspend()和Thread#resume()已经被弃用，那就让我们来看看它们的替代方法吧。

Object#wait()和Object#notify()/Object#notifyAll()

调用以下方法时，当前线程必须是对象监视器锁的持有者。

Object#wait()：将当前线程放入对象监视器锁的等待集合，释放对象的监视器锁，线程不再被操作系统调度，进入等待直到被唤醒或中断，然后再次竞争获得对象的监视器锁，恢复执行。

Object#notify()：唤醒对象监视器锁等待集合中的任意一个线程。

Object#notifyAll()：唤醒对象监视器锁等待集合中的所有线程。

因此，wait()/notify()只适用于线程持有锁的情境下。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    private static void waitNotify() throws InterruptedException {
        final Object lock = new Object();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    synchronized (lock) {
                        try {
                            System.out.println("没有包子，进入等待");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 通知目标线程
        synchronized (lock) {
            System.out.println("包子做好了");
            lock.notify();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        waitNotify();
    }    
}

运行main()方法，控制台输出如下：

没有包子，进入等待
包子做好了
买到包子，回家

wait()/notify帮助我们成功地买到了包子。

与suspend()/resume()相似，wait()/notify()如果调用顺序不当，也会造成线程无法被唤醒：

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    private static void waitForever() throws InterruptedException {
        final Object lock = new Object();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    try {
                        // 睡眠一段时间，让notify()先执行
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock) {
                        try {
                            System.out.println("没有包子，进入等待");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 通知目标线程
        synchronized (lock) {
            System.out.println("包子做好了");
            lock.notify();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        waitForever();
    }    
}

运行main()方法，程序无法退出，控制台输出如下：

包子做好了
没有包子，进入等待

目标线程的notify()方法先于wait()方法被调用，导致wait()方法被调用后没有线程来唤醒它，就会一直处于WAITING状态。

LockSupport#park()和LockSupport#unpark()

与wait()/notify()不同，park()/unpark()调用时线程不用获取对象的监视器锁。

LockSupport#park()：禁止当前线程进行线程调度，直到许可证可用。如果当前许可证可用，那么消费该许可证，本地调用立刻返回。

LockSupport#unpark()：如果目标线程许可证不可用，则为其提供许可证。否则，目标线程的下一次park()调用不会阻塞。

可以看出，park()与unpark()为线程维护了一个许可证，该许可证只有可用/不可用两种状态（默认不可用）。unpark()将许可证置为可用。而park()在许可证不可用的时候阻塞，在许可证可用的时候消费该许可证（将其置为不可用）然后立即返回。因此，park()能否从阻塞中恢复与park()/unpark()的调用顺序无关。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    private static void parkUnpark() throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    System.out.println("没有包子，进入等待");
                    // 挂起当前线程
                    LockSupport.park();
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 唤醒目标线程
        LockSupport.unpark(thread);
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        parkUnpark();
    }  
}

运行main()方法，控制台输出如下：

没有包子，进入等待
包子做好了
买到包子，回家

虽然park()/unpark()没有调用顺序的要求，但是如果在调用park()时，当前线程已经持有了对象的监视器锁，park()不会释放该锁。此时，如果在调用unpark()前也需要获取对象的监视器锁，就会死锁。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    private static void parkUnparkDeadLock() throws InterruptedException {
        final Object lock = new Object();
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    synchronized (lock) {
                        System.out.println("没有包子，进入等待");
                        // 挂起当前线程，但是不会释放锁
                        LockSupport.park();
                    }
                }
                System.out.println("买到包子，回家");
            }
        });
        thread.start();
        // 3s后生产一个包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 先拿到锁，再唤醒目标线程
        // 但是锁现在被park()线程持有，此处一直BLOCKED，死锁了
        synchronized (lock) {
            System.out.println("包子做好了");
            LockSupport.unpark(thread);
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        parkUnparkDeadLock();
    }  
}

注意：wait()和park()都有可能被伪唤醒，建议在循环中检查等待/挂起条件，防止程序在不满足结束条件的情况下退出。