6.1  在线程中执行任务

在多线程开发中，要执行多线程任务，第一步是“找出任务边界”。

一个好的并发服务器是：大吞吐量，低响应时间。当系统过载的时候，只是性能降低而不会崩溃。

网络服务器为多线程提供了自然的任务边界：每一个客户端的请求。例如Web服务器、Mail服务器、文件服务器、EJB容器、数据库服务器都接受这种请求。各个客户端之间的请求应该是互补影响的。

单线程服务器

class SingleThreadWebServer {

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

ServerSocket socket = new ServerSocket(80);

while (true) {

Socket connection = socket.accept();

handleRequest(connection);

}

}

}

处理一个客户的连接时，其他连接只能等待。在成熟的商业化产品中，显然性能太差。实际上，在处理过程中，经常会发生I/O阻塞(网络read、write等)，由于是单线程，只要有阻塞，服务器就没有响应了。

多线程(每次创建新线程)

因此多线程是一个很自然的想法，一种简单的方法是，每一个客户端请求时，新建一个线程进行处理。原线程继续等待。

class ThreadPerTaskWebServer {

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

ServerSocket socket = new ServerSocket(80);

while (true) {

final Socket connection = socket.accept();

Runnable task = new Runnable() {

public void run() {

handleRequest(connection);

}

};

new Thread(task).start();

}

}

}

需要注意的是：task中的处理代码必须保证线程安全。

当用户请求不密集的时候，这种模型能很好的工作。但当大量用户并发连接(线程增多)的时候，性能会急剧下降甚至导致程序的崩溃：

1、线程的创建、销毁需要开销。特别是线程数量很多的时候，累积起来的开销很大。

2、资源消耗。过多线程会消耗大量内存，增加GC的负担。

3、健壮性。每个操作系统、JVM都有线程创建的极限，当超过这个极限的时候，一般就会OutofMemoryException。

总结：多线程可以通过并发计算的形式提升性能，但毫无限制的创建线程是不行的，最终会导致系统的崩溃。

6.2  Executor框架

单线程模型的并发性太差、响应时间太长。每次请求创建一个新线程的开销太大，很难进行资源管理。

为此JDK提供了Executor框架，以Task(Runnable)为基本单位，将任务的提交与任务的执行解耦。

Executor使用的是“生产者-消费者”模型。Task的提交是生产者，执行时消费者。

这种框架让并发控制与业务逻辑解耦，使用起来非常简单。

一个使用了固定100线程Executor的Web服务器。

class TaskExecutionWebServer {

private static final int NTHREADS = 100;

private static final Executor exec

= Executors.newFixedThreadPool(NTHREADS);

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

ServerSocket socket = new ServerSocket(80);

while (true) {

final Socket connection = socket.accept();

Runnable task = new Runnable() {

public void run() {

handleRequest(connection);

}

};

exec.execute(task);

}

}

}

6.2.2  Executor的策略

Executor的策略包括：

1、在哪个线程执行

2、什么顺序？(FIFO、LIFO、优先队列)

3、多少个任务可并发执行

4、多少个任务可以被放入队列等待执行

5、如果因为系统过载导致Task被拒绝，应该选择哪个Task，怎么通知用户？

6、执行完一个Task后应该做什么。

围绕这些问题，Executors提供了一系列子类，方便用户选择。

6.2.3  线程池

线程池，顾名思义拥有N个工作线程，以及一个工作队列。每一个线程的工作很简单：从队列中取出一个任务、执行、然后再等待下一个任务。

与每次都新建线程相比，线程池拥有诸多优势，最主要的是：可以避免反复创建、销毁线程的开销。通过合理的调整线程池大小，可以在性能和内存消耗之间达到一个平衡。

Execotors提供了很多线程池：

newFixedThreadPool，初始创建N个线程，如果中途有线程挂掉了，创建新的以维持N个的数量。

newCachedThreadPool，更自由的控制线程数量，当任务多的时候增多线程，少的时候减少线程。没有上下限。

newSingleThreadExecutor，纯单线程，保证任务是顺序执行的。

尽管FixedThreadPool限定了线程上限，但是若Task过多的话，还是有可能OutofMemoryException的。

6.2.4  Executor的生命周期

如果Executor没有被正确shutdown的话，可能会致使JVM无法退出。先来看一下Executor的生命周期吧。

为了加强生命周期管理(如程序关闭、异常结束)，JDK拓展出了ExecutorService接口：

public interface ExecutorService extends Executor {

void shutdown();

List shutdownNow();

boolean isShutdown();

boolean isTerminated();

boolean awaitTermination(long timeout, TimeUnit unit)

throws InterruptedException;

// ... additional convenience methods for task submission

}

ExecutorService有三种状态：running、shutdown、terminated。初始状态下，是Running的

shutdown() 优雅的关闭，不接受新Task，已经提交的Task将被执行完毕后，再关闭。

shutdownNow() 立即关闭，不再执行任何Task，并将Queue的没有执行的返回。

awaitTermination() 等待Executor到达terminated状态

isTerminated() 检查是否到达terminated状态

一个结合了shutdown的服务器实例如下：

class LifecycleWebServer {

private final ExecutorService exec = ...;

public void start() throws IOException {

ServerSocket socket = new ServerSocket(80);

while (!exec.isShutdown()) {

try {

final Socket conn = socket.accept();

exec.execute(new Runnable() {

public void run() { handleRequest(conn); }

});

} catch (RejectedExecutionException e) {

if (!exec.isShutdown())

log("task submission rejected", e);

}

}

}

public void stop() { exec.shutdown(); }

void handleRequest(Socket connection) {

Request req = readRequest(connection);

if (isShutdownRequest(req))

stop();

else

dispatchRequest(req);

}

}

6.2.5  延时和周期任务

在JDK5之前，通过Timer执行周期任务，或者延时任务。

JDK5之后ScheduledThreadPoolExecutor可担任Timer提供了更灵活的方法。

Timer的问题是：只能开一一个线程，如果频率是10ms一次，但是某Task是40ms(可以选择fixed rate或者fixeddelay，如果是前者的话)就可能导致任务丢失，后者的话就是任务少执行了。

ScheduledThreadPoolExecutor可以创建多个线程来解决这个问题。

另外一个问题是，如果Task抛出异常，Timer的线程就挂掉了，不会重启，相当于Timer被取消了。ScheduledThradPool可以解决这个问题。

因此JDK5后，应该首选ScheduledThreadPoolExecutor。

类似的还有DelayQueue，也可以使用。

6.3 找出可利用的并行

为了很好地利用Executor框架，需要把Task封装为Runnable。

对于C/S程序而言，任务边界很简单，就是一次Request/Response。更多的时候没有明确的定义。

以一个HTML网页渲染为例。

最基本的策略：单线程、先渲染文本，再下载、渲染图片：

public class SingleThreadRenderer {

void renderPage(CharSequence source) {

renderText(source);

List imageData = new ArrayList();

for (ImageInfo imageInfo : scanForImageInfo(source))

imageData.add(imageInfo.downloadImage());

for (ImageData data : imageData)

renderImage(data);

}

}

由于图片的下载速度受到网络影响，经常会I/O阻塞。因此CPU计算资源将被大量的闲置。

为了支持异步任务的返回，Executor还支持Future(一种Callable)。可以通过get异步获取结果。除了支持submit一个Future(Runnable之外)，默认提交Runnable也会返回一个Callale(get也会阻塞，只不过最终返回null)。

这种submit导致的发布时安全的。

使用Callable对程序进行改进：

public class FutureRenderer {

private final ExecutorService executor = ...;

void renderPage(CharSequence source) {

final List imageInfos = scanForImageInfo(source);

Callable> task =

new Callable>() {

public List call() {

List result

= new ArrayList();

for (ImageInfo imageInfo : imageInfos)

result.add(imageInfo.downloadImage());

return result;

}

};

Future> future = executor.submit(task);

renderText(source);

try {

List imageData = future.get();

for (ImageData data : imageData)

renderImage(data);

} catch (InterruptedException e) {

// Re-assert the thread's interrupted status

Thread.currentThread().interrupt();

// We don't need the result, so cancel the task too

future.cancel(true);

} catch (ExecutionException e) {

throw launderThrowable(e.getCause());

}

}

}

先开启线程提交图片下载，再渲染文字，最后等待异步的图片下载完成后，再渲染图片。在一定程度上减少了程序的响应时间。

BlockingQueue是一个非常有利的工具：

1、当多个Class共享一个线程池的时候，可以在Task执行完毕后将结果写入BlockingQueue。主线程从BQ中get，即使暂时没有也是异步的、线程安全的。

2、可以控制多个扔进Executors的异步任务的执行结果。

另外Future提供了一个带timeout的接口。用于有时间限制的完成指定任务。

V get(long timeout,TimeUnit unit)

Page renderPageWithAd() throws InterruptedException {

long endNanos = System.nanoTime() + TIME_BUDGET;

Future f = exec.submit(new FetchAdTask());

// Render the page while waiting for the ad

Page page = renderPageBody();

Ad ad;

try {

// Only wait for the remaining time budget

long timeLeft = endNanos - System.nanoTime();

ad = f.get(timeLeft, NANOSECONDS);

} catch (ExecutionException e) {

ad = DEFAULT_AD;

} catch (TimeoutException e) {

ad = DEFAULT_AD;

f.cancel(true);

}

page.setAd(ad);

return page;

}

Executors也提供了带时间版本的invokeAll，用于对一组提交的Future，并在指定时间内返回。