疑问和练习：并发

问题：
1 你能传一个线程对象给Executor.execute吗？这样的调用有意义吗？
回到：Thread实现了Runnable接口。所以你可以传递一个Thread的实例给Executor.execute。可是，使用Thread 对象这种方式是没有意义的。如果一个对象直接从Thread实例化，它的run方法不会做任何事情。你可以用一个有用的run方法定义Thread的子类。但是这样的类实现的功能，executor不会使用。
练习：

1 编译并运行BadThreads.java

public class BadThreads {

static String message;

private static class CorrectorThread
extends Thread {

public void run() {
try {
sleep(1000);
} catch (InterruptedException e) {}
// Key statement 1:
message = "Mares do eat oats.";
}
}

public static void main(String args[])
throws InterruptedException {

(new CorrectorThread()).start();
message = "Mares do not eat oats.";
Thread.sleep(2000);
// Key statement 2:
System.out.println(message);
}
}

这个应用程序应该打印出Mares do eat oats.是否保证总是这样做了？如果不是，为什么？改变两次调用Sleep的调用的参数是否有用？你如何保证所有对message的改变对主线程可见。

这个程序几乎总是打印出 "Mares do eat oats."信息。但是不能保证。因为无法保证Key statement 1和Key statement 2之间的happens-before关系。记住happens-before关系涉及到可见性，而不是序列。

有两种方式保证对message的变化将对主线程可见。

1 在主线程中，保留一个CorrectorThread 实例的引用。涉及到message之前在这个实例上调用invoke方法。
2 用同步方法在对象中封装message。只有这个方法可以涉及到message。

这两种技术建立了必要的happens-before关系，使message的变化可见。

第三种方式是简单的将message声明为volatile。这保证了任何对message的写入（就像key statement 1）与后续的对其的读出操作（像key statement 2）之间有happens-before关系。但是它不能保证Keystatement 1 简单地在Key statement 2之前发生。虽然可能顺序的发生，但是因为调度的不确定性和为止的睡眠粒度，那不被保证。



2 修改保护块中的生产者-消费者例子使用一个标准库类代替Drop类。

方案：java.util.concurrent.BlockingQueue接口定义了get方法如果队列是空的就阻塞，一个put方法如果队列满了就阻塞。这些与Drop类中操作同样高效---除非Drop不是一个队列。可是，有另一种方式查看Drop：是一个容量为0的队列。因为队列中没有空间，每个get阻塞直到调用响应的take并且每个take阻塞直到调用相应的get。有一个阻塞队列的实现，清晰的显示了这中行为： java.util.concurrent.SynchronousQueue.

BlockingQueue几乎是Drop的插入式替代。生产者中BlockingQueue的主要问题是put和get方法抛出InterruptedException。这意味着存在的try上升了一个级别。

import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class Producer implements Runnable {
private BlockingQueue<String> drop;

public Producer(BlockingQueue<String> 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();

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

Consumer类中相应的改变：

import java.util.Random;
import java.util.concurrent.BlockingQueue;

public class Consumer implements Runnable {
private BlockingQueue<String> drop;

public Consumer(BlockingQueue<String> drop) {
this.drop = drop;
}

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

对于 ProducerConsumerExample，我们简单的改变了drop对象的声明：

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;

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