線程通常必須協(xié)調(diào)他們的操作，最常見的協(xié)調(diào)用法是守護(hù)阻塞，這樣的阻塞首先輪詢一個(gè)條件，該條件必須為真，然后阻塞才能繼續(xù)，要正確執(zhí)行此操作，需要執(zhí)行許多步驟。

例如，假設(shè)guardedJoy是一個(gè)方法，在另一個(gè)線程設(shè)置了共享變量joy之前，該方法不能繼續(xù)，理論上，這種方法可以簡單地循環(huán)直到滿足條件，但該循環(huán)是浪費(fèi)的，因?yàn)樗诘却龝r(shí)持續(xù)執(zhí)行。

public void guardedJoy() {
    // Simple loop guard. Wastes
    // processor time. Don"t do this!
    while(!joy) {}
    System.out.println("Joy has been achieved!");
}

更有效的守護(hù)是調(diào)用Object.wait來掛起當(dāng)前線程，在另一個(gè)線程發(fā)出可能發(fā)生某些特殊事件的通知之前，wait的調(diào)用不會(huì)返回 — 盡管不一定是這個(gè)線程正在等待的事件：

public synchronized void guardedJoy() {
    // This guard only loops once for each special event, which may not
    // be the event we"re waiting for.
    while(!joy) {
        try {
            wait();
        } catch (InterruptedException e) {}
    }
    System.out.println("Joy and efficiency have been achieved!");
}

始終在測試等待條件的循環(huán)內(nèi)調(diào)用wait，不要假設(shè)中斷是針對(duì)你正在等待的特定條件，或者條件仍然是true。

像許多暫停執(zhí)行的方法一樣，wait會(huì)拋出InterruptedException，在這個(gè)例子中，我們可以忽略該異常 — 我們只關(guān)心joy的值。

為什么這個(gè)版本的guardedJoy是同步的？假設(shè)d是我們用來調(diào)用wait的對(duì)象，當(dāng)一個(gè)線程調(diào)用d.wait時(shí)，它必須擁有d的固有鎖 — 否則拋出一個(gè)錯(cuò)誤，在同步方法中調(diào)用wait是獲取固有鎖的一種簡單方法。

當(dāng)調(diào)用wait時(shí)，線程釋放鎖并暫停執(zhí)行，在將來的某個(gè)時(shí)間，另一個(gè)線程將獲取相同的鎖并調(diào)用Object.notifyAll，通知等待該鎖的所有線程發(fā)生了重要的事情：

public synchronized notifyJoy() {
    joy = true;
    notifyAll();
}

在第二個(gè)線程釋放鎖之后的一段時(shí)間，第一個(gè)線程重新獲取鎖并通過從調(diào)用wait的返回來恢復(fù)。

還有第二種通知方法notify，它喚醒單個(gè)線程，因?yàn)?b>notify不允許你指定被喚醒的線程，所以它僅在大規(guī)模并行應(yīng)用程序中有用 — 也就是說，具有大量線程的程序，都做類似的事，在這樣的應(yīng)用程序中，你不關(guān)心哪個(gè)線程被喚醒。

讓我們使用守護(hù)阻塞來創(chuàng)建生產(chǎn)者—消費(fèi)者應(yīng)用程序，這種應(yīng)用程序在兩個(gè)線程之間共享數(shù)據(jù)：創(chuàng)建數(shù)據(jù)的生產(chǎn)者和使用數(shù)據(jù)的消費(fèi)者。兩個(gè)線程使用共享對(duì)象進(jìn)行通信，協(xié)調(diào)至關(guān)重要：消費(fèi)者線程在生產(chǎn)者線程交付之前不得嘗試檢索數(shù)據(jù)，如果消費(fèi)者未檢索到舊數(shù)據(jù)，則生產(chǎn)者線程不得嘗試傳遞新數(shù)據(jù)。

在此示例中，數(shù)據(jù)是一系列文本消息，通過Drop類型的對(duì)象共享：

public class Drop {
    // Message sent from producer
    // to consumer.
    private String message;
    // True if consumer should wait
    // for producer to send message,
    // false if producer should wait for
    // consumer to retrieve message.
    private boolean empty = true;

    public synchronized String take() {
        // Wait until message is
        // available.
        while (empty) {
            try {
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = true;
        // Notify producer that
        // status has changed.
        notifyAll();
        return message;
    }

    public synchronized void put(String message) {
        // Wait until message has
        // been retrieved.
        while (!empty) {
            try { 
                wait();
            } catch (InterruptedException e) {}
        }
        // Toggle status.
        empty = false;
        // Store message.
        this.message = message;
        // Notify consumer that status
        // has changed.
        notifyAll();
    }
}

Producer中定義的生產(chǎn)者線程發(fā)送一系列熟悉的消息，字符串“DONE”表示已發(fā)送所有消息，為了模擬真實(shí)世界應(yīng)用程序的不可預(yù)測性，生產(chǎn)者線程在消息發(fā)送之間暫停隨機(jī)間隔。

import java.util.Random;

public class Producer implements Runnable {
    private Drop drop;

    public Producer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        String importantInfo[] = {
            "Mares eat oats",
            "Does eat oats",
            "Little lambs eat ivy",
            "A kid will eat ivy too"
        };
        Random random = new Random();

        for (int i = 0;
             i < importantInfo.length;
             i++) {
            drop.put(importantInfo[i]);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
        drop.put("DONE");
    }
}

在Consumer中定義的消費(fèi)者線程只是檢索消息并將其打印出來，直到它檢索到“DONE”字符串，該線程也會(huì)暫停隨機(jī)間隔。

import java.util.Random;

public class Consumer implements Runnable {
    private Drop drop;

    public Consumer(Drop drop) {
        this.drop = drop;
    }

    public void run() {
        Random random = new Random();
        for (String message = drop.take();
             ! message.equals("DONE");
             message = drop.take()) {
            System.out.format("MESSAGE RECEIVED: %s%n", message);
            try {
                Thread.sleep(random.nextInt(5000));
            } catch (InterruptedException e) {}
        }
    }
}

最后，這是在ProducerConsumerExample中定義的主線程，它啟動(dòng)生產(chǎn)者和消費(fèi)者線程。

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Drop drop = new Drop();
        (new Thread(new Producer(drop))).start();
        (new Thread(new Consumer(drop))).start();
    }
}

Drop類是為了演示守護(hù)阻塞而編寫的，為了避免重新造輪子，在嘗試編寫自己的數(shù)據(jù)共享對(duì)象之前，檢查Java集合框架中的現(xiàn)有數(shù)據(jù)結(jié)構(gòu)。