線程通信的方法

程序在使用多線程執(zhí)行任務(wù)時(shí)白群，經(jīng)常需要線程之間協(xié)同工作竟痰。此時(shí)签钩，我們需要了解線程通信的手段。

線程通信大致分為以下四類(lèi)：

• 文件共享
• 網(wǎng)絡(luò)共享
• 共享變量
• JDK提供的線程協(xié)調(diào)API

本文主要研究第四類(lèi)坏快，如何使用JDK提供的API正確地阻塞铅檩、喚醒目標(biāo)線程。

Thread#suspend()和Thread#resume()

Thread#suspend()：掛起目標(biāo)線程不再繼續(xù)執(zhí)行莽鸿，直到它被resume()喚醒昧旨。

Thread#resume()：如果目標(biāo)線程已被掛起，那么喚醒目標(biāo)線程并允許它繼續(xù)執(zhí)行祥得。

舉個(gè)栗子:

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("沒(méi)有包子兔沃，進(jìn)入等待");
                    // 掛起當(dāng)前線程
                    Thread.currentThread().suspend();
                }
                System.out.println("買(mǎi)到包子，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 喚醒目標(biāo)線程
        thread.resume();
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendResume();
    }    
}

運(yùn)行main()方法级及，控制臺(tái)輸出如下：

沒(méi)有包子乒疏，進(jìn)入等待
包子做好了
買(mǎi)到包子，回家

suspend()和resume()幫助我們?cè)谶m當(dāng)?shù)臅r(shí)候阻塞和喚醒線程饮焦，成功地模擬了顧客在包子店買(mǎi)包子的情景怕吴。

但是，這對(duì)API在JDK1.2之后被棄用县踢，原因是它們特別容易形成死鎖转绷。

如果目標(biāo)線程持有監(jiān)視器鎖，在調(diào)用suspend()掛起目標(biāo)線程時(shí)并不會(huì)釋放這把鎖殿雪。此時(shí)暇咆，如果其他線程在調(diào)用目標(biāo)線程的resume()方法之前也要先獲取這把鎖，死鎖就產(chǎn)生了。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    // 會(huì)死鎖的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("沒(méi)有包子爸业，進(jìn)入等待");
                    // 當(dāng)前線程拿到鎖其骄，然后掛起
                    synchronized (lock) {
                        Thread.currentThread().suspend();
                    }
                }
                System.out.println("買(mǎi)到包子，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 爭(zhēng)取到鎖以后再喚醒目標(biāo)線程
        synchronized (lock) { // 此處會(huì)一直BLOCKED
            System.out.println("包子做好了");
            thread.resume();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendResumeDeadLock();
    }    
}

運(yùn)行main()方法扯旷，程序無(wú)法退出拯爽，控制臺(tái)輸出如下：

沒(méi)有包子，進(jìn)入等待

喚醒目標(biāo)線程的條件已經(jīng)滿足（包子做好了）钧忽，但是拿不到鎖毯炮，就無(wú)法喚醒目標(biāo)線程，程序就這樣被“凍結(jié)”耸黑。

即使在不涉及監(jiān)視器鎖的情況下使用suspend()和resume()桃煎，如果調(diào)用順序不當(dāng)，線程也可能永遠(yuǎn)掛起大刊。

public class ThreadCommunication {

    private static volatile Object steamedStuffedBun;

    // 會(huì)永遠(yuǎn)掛起的suspend/resume
    private static void suspendForever() throws InterruptedException {
        Thread thread = new Thread(new Runnable() {
            public void run() {
                while (steamedStuffedBun == null) {
                    try {
                        // 睡眠一段時(shí)間为迈，讓resume()方法先執(zhí)行
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("沒(méi)有包子，進(jìn)入等待");
                    // 掛起當(dāng)前線程
                    Thread.currentThread().suspend();
                }
                System.out.println("買(mǎi)到包子缺菌，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 喚醒目標(biāo)線程（此時(shí)線程還未掛起）
        thread.resume();
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        suspendForever();
    }    
}

運(yùn)行main()方法葫辐，程序無(wú)法退出，控制臺(tái)輸出如下：

包子做好了
沒(méi)有包子伴郁，進(jìn)入等待

上面的例子中耿战，resume()在suspend()之前被調(diào)用，目標(biāo)線程被掛起之后焊傅，沒(méi)有線程來(lái)調(diào)用resume()喚醒它剂陡，就會(huì)永遠(yuǎn)掛起。

既然Thread#suspend()和Thread#resume()已經(jīng)被棄用租冠，那就讓我們來(lái)看看它們的替代方法吧鹏倘。

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

調(diào)用以下方法時(shí)，當(dāng)前線程必須是對(duì)象監(jiān)視器鎖的持有者顽爹。

Object#wait()：將當(dāng)前線程放入對(duì)象監(jiān)視器鎖的等待集合纤泵，釋放對(duì)象的監(jiān)視器鎖，線程不再被操作系統(tǒng)調(diào)度镜粤，進(jìn)入等待直到被喚醒或中斷捏题，然后再次競(jìng)爭(zhēng)獲得對(duì)象的監(jiān)視器鎖，恢復(fù)執(zhí)行肉渴。

Object#notify()：?jiǎn)拘褜?duì)象監(jiān)視器鎖等待集合中的任意一個(gè)線程公荧。

Object#notifyAll()：?jiǎn)拘褜?duì)象監(jiān)視器鎖等待集合中的所有線程。

因此同规，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("沒(méi)有包子窟社，進(jìn)入等待");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("買(mǎi)到包子，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 通知目標(biāo)線程
        synchronized (lock) {
            System.out.println("包子做好了");
            lock.notify();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        waitNotify();
    }    
}

運(yùn)行main()方法绪钥，控制臺(tái)輸出如下：

沒(méi)有包子灿里，進(jìn)入等待
包子做好了
買(mǎi)到包子，回家

wait()/notify幫助我們成功地買(mǎi)到了包子程腹。

與suspend()/resume()相似匣吊，wait()/notify()如果調(diào)用順序不當(dāng)，也會(huì)造成線程無(wú)法被喚醒：

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 {
                        // 睡眠一段時(shí)間寸潦，讓notify()先執(zhí)行
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (lock) {
                        try {
                            System.out.println("沒(méi)有包子色鸳，進(jìn)入等待");
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                System.out.println("買(mǎi)到包子，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 通知目標(biāo)線程
        synchronized (lock) {
            System.out.println("包子做好了");
            lock.notify();
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        waitForever();
    }    
}

運(yùn)行main()方法见转，程序無(wú)法退出命雀，控制臺(tái)輸出如下：

包子做好了
沒(méi)有包子，進(jìn)入等待

目標(biāo)線程的notify()方法先于wait()方法被調(diào)用池户，導(dǎo)致wait()方法被調(diào)用后沒(méi)有線程來(lái)喚醒它咏雌，就會(huì)一直處于WAITING狀態(tài)。

LockSupport#park()和LockSupport#unpark()

與wait()/notify()不同校焦，park()/unpark()調(diào)用時(shí)線程不用獲取對(duì)象的監(jiān)視器鎖。

LockSupport#park()：禁止當(dāng)前線程進(jìn)行線程調(diào)度统倒，直到許可證可用寨典。如果當(dāng)前許可證可用，那么消費(fèi)該許可證房匆，本地調(diào)用立刻返回耸成。

LockSupport#unpark()：如果目標(biāo)線程許可證不可用，則為其提供許可證浴鸿。否則井氢，目標(biāo)線程的下一次park()調(diào)用不會(huì)阻塞。

可以看出岳链，park()與unpark()為線程維護(hù)了一個(gè)許可證花竞，該許可證只有可用/不可用兩種狀態(tài)（默認(rèn)不可用）。unpark()將許可證置為可用掸哑。而park()在許可證不可用的時(shí)候阻塞约急，在許可證可用的時(shí)候消費(fèi)該許可證（將其置為不可用）然后立即返回。因此苗分，park()能否從阻塞中恢復(fù)與park()/unpark()的調(diào)用順序無(wú)關(guān)厌蔽。

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("沒(méi)有包子，進(jìn)入等待");
                    // 掛起當(dāng)前線程
                    LockSupport.park();
                }
                System.out.println("買(mǎi)到包子摔癣，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        System.out.println("包子做好了");
        // 喚醒目標(biāo)線程
        LockSupport.unpark(thread);
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        parkUnpark();
    }  
}

運(yùn)行main()方法奴饮，控制臺(tái)輸出如下：

沒(méi)有包子纬向，進(jìn)入等待
包子做好了
買(mǎi)到包子，回家

雖然park()/unpark()沒(méi)有調(diào)用順序的要求戴卜，但是如果在調(diào)用park()時(shí)逾条，當(dāng)前線程已經(jīng)持有了對(duì)象的監(jiān)視器鎖，park()不會(huì)釋放該鎖叉瘩。此時(shí)膳帕，如果在調(diào)用unpark()前也需要獲取對(duì)象的監(jiān)視器鎖，就會(huì)死鎖薇缅。

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("沒(méi)有包子危彩，進(jìn)入等待");
                        // 掛起當(dāng)前線程，但是不會(huì)釋放鎖
                        LockSupport.park();
                    }
                }
                System.out.println("買(mǎi)到包子泳桦，回家");
            }
        });
        thread.start();
        // 3s后生產(chǎn)一個(gè)包子
        Thread.sleep(3000);
        steamedStuffedBun = new Object();
        // 先拿到鎖汤徽，再喚醒目標(biāo)線程
        // 但是鎖現(xiàn)在被park()線程持有，此處一直BLOCKED灸撰，死鎖了
        synchronized (lock) {
            System.out.println("包子做好了");
            LockSupport.unpark(thread);
        }
        thread.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        parkUnparkDeadLock();
    }  
}

注意：wait()和park()都有可能被偽喚醒谒府，建議在循環(huán)中檢查等待/掛起條件，防止程序在不滿足結(jié)束條件的情況下退出浮毯。