Guarded Blocks 保护块

  线程经常需要协调它们的活动，最常用的协调方法是保护块。这样的块是以轮询一个条件开始，这个条件值必须是true，在块处理前。为了正确做到这样，有大量的步骤需要遵守。

  例如，guardedJoy 是一个方法，直到一个共享变量joy被另外一个线程设置了才会执行。这样的方法，理论上，简单的循环直到条件满足，但是了这样的循环是耗费的，因为它不断地在等待中执行。

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

   一种更有效的保护是调用object.wait来暂停当前线程。wait的调用不会返回直到领一个线程已经发不了一个通知，一些特殊的事件可能发生。虽然不是这个线程正在等待的事件：
  
   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) {}
    }
  

   注意：总是调用循环中的wait来测试正在等待的条件。不要假设中断（interrupt）是你正在等待的条件或者那个条件是true。

   像许多暂停执行的方法，wait会抛出InterruptedException。在这个例子中，我们能忽略这个异常，仅仅关注joy的值。

   为什么这个版本的guardedJoy是同步的？假设d是我们用来调用wait的对象。当一个线程调用d.wait，它必须拥有d的内在锁---否则将抛出一个错误。在一个同步方法中调用wait是一种简单的方式获取内在锁。

   当wait被调用，那个线程就释放锁并暂停执行。在不远的将来，另外一个线程将获取同样的锁并调用object.notifyAll，通知在这个锁上等待的所有线程，一些重要的事情发生了。
   public synchronized notifyJoy() {
    joy = true;
    notifyAll();
   }

    在第二个线程释放了锁后的一段时间，第一个线程重新获取锁并从wait的调用通过返回继续执行。

    注意：有第二个通知方法，notify，唤醒一个单一线程。因为notify不允许你指定要唤醒的线程，只有在大规模并行的应用程序中有用---即，程序中有大量的线程，所有的做那相似的工作。在这样的应用程序中，你不必在意哪个线程被唤醒。

    让我们使用保护块创建一个生产者--消费者应用程序。这类的应用在两个线程之间共享数据：生产者创建数据，消费者使用数据做一些事情。两个线程使用一个共享对象通信。协调就是必须的：在生产者传递数据前，消费者不必试着去获取它，并且生产者也不必试着去传递新的数据，如果消费者还没有获取旧的数据。

    在这个例子中，数据是一系列的文本信息，通过一个Drop的对象实现共享。

    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定义，发送一系列相似的信息。字符串”DONE“表明所有的消息已经发送了。为了模仿现实世界中不可预知的性质，生产者在消息之间以随机间隔暂停。

  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定义，简单地接受消息并打印出来，直到获取了”DONE“字符串。线程也以随机间隔暂停

  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 定义。启动了生产者和消费者线程。
 
  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();
    }
}

  注意: The Drop class was written in order to demonstrate guarded     blocks. To avoid re-inventing the wheel, examine the  existing data structures in the Java Collections Framework before    trying to code your own data-sharing objects. For more information,  refer to the Questions and Exercises section.