Linux学习之路-DNS原理-BIND配置详解

线程经常需要协调它们的活动，最常用的协调方法是保护块。这样的块是以轮询一个条件开始，这个条件值必须是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.