Java学习day098 并发（八）（执行器：线程池、预定执行、控制任务组、Fork-Join框架、可完成Future）
使用的教材是java核心技术卷1，我将跟着这本书的章节同时配合视频资源来进行学习基础java知识。
day098 并发（八）（执行器：线程池、预定执行、控制任务组、Fork-Join框架、可完成Future）
构建一个新的线程是有一定代价的，因为涉及与操作系统的交互。如果程序中创建了大量的生命期很短的线程，应该使用线程池（thread pool)。一个线程池中包含许多准备运行的空闲线程。将Runnable对象交给线程池，就会有一个线程调用run方法。当run方法退出时，线程不会死亡，而是在池中准备为下一个请求提供服务。
另一个使用线程池的理由是减少并发线程的数目。创建大量线程会大大降低性能甚至使虚拟机崩溃。如果有一个会创建许多线程的算法，应该使用一个线程数“固定的”线程池以限制并发线程的总数。
执行器（Executor)类有许多静态工厂方法用来构建线程池，下表中对这些方法进行了汇总。
1.线程池
newCachedThreadPool方法构建了一个线程池，对于每个任务，如果有空闲线程可用，立即让它执行任务，如果没有可用的空闲线程，则创建一个新线程。newFixedThreadPool方法构建一个具有固定大小的线程池。如果提交的任务数多于空闲的线程数，那么把得不到服务的任务放置到队列中。当其他任务完成以后再运行它们。newSingleThreadExecutor是一个退化了的大小为1的线程池：由一个线程执行提交的任务，一个接着一个。这3个方法返回实现了ExecutorService接口的ThreadPoolExecutor类的对象。
可用下面的方法之一将一个Runnable对象或Callable对象提交给ExecutorService:
Futuresubmit(Runnable task)
Futuresubmit(Runnable task, T result)
Futuresubmit(Callable task) 该池会在方便的时候尽早执行提交的任务。调用submit时，会得到一个Future对象，可用来查询该任务的状态。
第一个submit方法返回一个奇怪样子的Future。可以使用这样一个对象来调用isDone、cancel或isCancelled。但是，get方法在完成的时候只是简单地返回null。
第二个版本的Submit也提交一个Runnable，并且Future的get方法在完成的时候返回指定的result对象。
第三个版本的Submit提交一个Callable,并且返回的Future对象将在计算结果准备好的时候得到它。
当用完一个线程池的时候，调用shutdown。该方法启动该池的关闭序列。被关闭的执行器不再接受新的任务。当所有任务都完成以后，线程池中的线程死亡。另一种方法是调用shutdownNow。该池取消尚未开始的所有任务并试图中断正在运行的线程。下面总结了在使用连接池时应该做的事：
1)调用Executors类中静态的方法newCachedThreadPool或newFixedThreadPool。
2)调用submit提交Runnable或Callable对象。
3)如果想要取消一个任务，或如果提交Callable对象，那就要保存好返回的Future对象。
4)当不再提交任何任务时，调用shutdown。
例如，前面的程序例子产生了大量的生命期很短的线程，每个目录产生一个线程。下面的的程序使用了一个线程池来运行任务。出于信息方面的考虑，这个程序打印出执行中池中最大的线程数。但是不能通过ExecutorService这个接口得到这一信息。因此，必须将该pool对象强制转换为ThreadPoolExecutor类对象。
/**
*@author zzehao
*/
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
public class ThreadPoolTest
{
public static void main(String[] args)
{
try(Scanner in = new Scanner(System.in))
{
System.out.print("Enter base directory (e.g. /opt/jdkl.8.0/src): ");
String directory = in.nextLine();
System.out.print("Enter keyword (e.g. volatile): ");
String keyword= in.nextLine();
ExecutorService pool = Executors.newCachedThreadPool();
MatchCounter counter = new MatchCounter(new File(directory), keyword,pool);
Future result = pool.submit(counter);
try
{
System.out.println(result.get()+ " matching files.");
}
catch (ExecutionException e)
{
e.printStackTrace();
}
catch (InterruptedException e)
{
}
pool.shutdown();
int largestPoolSize = ((ThreadPoolExecutor) pool).getLargestPoolSize();
System.out.println("largest pool size=" + largestPoolSize);
}
}
}
//This task counts the files in a directory and its subdirectories that contain a given keyword.
class MatchCounter implements Callable
{
private File directory;
private String keyword;
private ExecutorService pool;
private int count;
//Constructs a MatchCounter.
public MatchCounter(File directory, String keyword, ExecutorService pool)
{
this.directory = directory;
this.keyword = keyword;
this.pool = pool;
}
public Integer call()
{
int count = 0;
try
{
File[] files =directory.listFiles();
List> results = new ArrayList<>();
for (File file : files)
{
if (file.isDirectory())
{
MatchCounter counter = new MatchCounter(file, keyword,pool);
Future result = pool.submit(counter);
results.add(result);
}
else
{
if (search(file))
count++;
}
}
for (Future result : results)
{
try
{
count += result.get();
}
catch (ExecutionException e)
{
e.printStackTrace();
}
}
}
catch (InterruptedException e)
{
}
return count;
}
//Searches a file for a given keyword.
public boolean search(File file)
{
try
{
try (Scanner in = new Scanner(file, "UTF-8"))
{
boolean found = false;
while (!found && in.hasNextLine())
{
String line = in.nextLine();
if (line.contains(keyword))
found = true;
}
return found;
}
}
catch (IOException e)
{
return false;
}
}
} 运行的结果是（自行输入）：
2.预定执行
ScheduledExecutorService接口具有为预定执行（ScheduledExecution)或重复执行任务而设计的方法。它是一种允许使用线程池机制的java.util.Timer的泛化。Executors类的newScheduledThreadPool和newSingleThreadScheduledExecutor方法将返回实现了Scheduled¬ExecutorService接口的对象。
可以预定Runnable或Callable在初始的延迟之后只运行一次。也可以预定一个Runnable对象周期性地运行。详细内容见API文档。
3.控制任务组
了解了如何将一个执行器服务作为线程池使用，以提高执行任务的效率。有时，使用执行器有更有实际意义的原因，控制一组相关任务。例如，可以在执行器中使用shutdownNow方法取消所有的任务。
invokeAny方法提交所有对象到一个Callable对象的集合中，并返回某个已经完成了的任务的结果。无法知道返回的究竟是哪个任务的结果，也许是最先完成的那个任务的结果。对于搜索问题，如果你愿意接受任何一种解决方案的话，你就可以使用这个方法。例如，假定你需要对一个大整数进行因数分解计算来解码RSA密码。可以提交很多任务，每一个任务使用不同范围内的数来进行分解。只要其中一个任务得到了答案，计算就可以停止了。
invokeAll方法提交所有对象到一个Callable对象的集合中，并返回一个Future对象的列表，代表所有任务的解决方案。当计算结果可获得时，可以像下面这样对结果进行处理：
List> tasks = . ..;
List> results = executor.invokeAll(tasks);
for (Future result : results)
processFurther(result.get()); 这个方法的缺点是如果第一个任务恰巧花去了很多时间，则可能不得不进行等待。将结果按可获得的顺序保存起来更有实际意义。可以用ExecutorCompletionService来进行排列。
用常规的方法获得一个执行器。然后，构建一个ExecutorCompletionService，提交任务给完成服务（completionservice)。该服务管理Future对象的阻塞队列，其中包含已经提交的任务的执行结果（当这些结果成为可用时)。这样一来，相比前面的计算，一个更有效的组织形式如下：
ExecutorCompletionService service = new ExecutorCompletionServiceo(executor):
for (Callable task : tasks) service.submit(task);
for (int i = 0; i < tasks.size();i++)
processFurther(service.take().get()); 
4.Fork-Join框架
有些应用使用了大量线程，但其中大多数都是空闲的。举例来说，一个Web服务器可能会为每个连接分别使用一个线程。另外一些应用可能对每个处理器内核分别使用一个线程，来完成计算密集型任务，如图像或视频处理。JavaSE7中新引入了fork-join框架，专门用来支持后一类应用。假设有一个处理任务，它可以很自然地分解为子任务，如下所示：
if (problemSize < threshold)
solve problem directly
else
{
break problem into subproblems
recursively solveeach subproblem
combine the results
}图像处理就是这样一个例子。要增强一个图像，可以变换上半部分和下部部分。如果有足够多空闲的处理器，这些操作可以并行运行。（除了分解为两部分外，还需要做一些额外的工作，不过这属于技术细节，我们不做讨论)。
在这里，我们将讨论一个更简单的例子。假设想统计一个数组中有多少个元素满足某个特定的属性。可以将这个数组一分为二，分别对这两部分进行统计，再将结果相加。
要采用框架可用的一种方式完成这种递归计算，需要提供一个扩展RecursiveTask
public Counter(double[] values,int from,int to,DoublePredicate filter)
{
this.values = values;
this.from = from;
this.to = to;
this.filter = filter;
}
protected Integer compute()
{
if(to - from < THRESHOLD)
{
int count = 0;
for (int i = from;i < to;i++)
{
if (filter.test(values[i]))
count++;
}
return count;
}
else
{
int mid = (from + to)/2;
Counter first = new Counter(values, from, mid, filter);
Counter second = new Counter(values, mid, to, filter);
invokeAll(first, second);
return first.join()+second.join();
}
}在这里，invokeAll方法接收到很多任务并阻塞，直到所有这些任务都已经完成。join方法将生成结果。我们对每个子任务应用了join,并返回其总和。
下面是完整的代码。在后台，fork-join框架使用了一种有效的智能方法来平衡可用线程的工作负载，这种方法称为工作密取（workstealing)。每个工作线程都有一个双端队列(deque)来完成任务。一个工作线程将子任务压人其双端队列的队头。（只有一个线程可以访问队头，所以不需要加锁。）一个工作线程空闲时，它会从另一个双端队列的队尾“密取”一个任务。由于大的子任务都在队尾，这种密取很少出现。
/**
*@author zzehao
*/
import java.util.concurrent.*;
import java.util.function.*;
//This program demonstrates the fork-join framework.
public class ForkJoinTest
{
public static void main(String[] args)
{
final int SIZE = 10000000;
double[] numbers = new double[SIZE];
for(int i=0;i < SIZE;i++)
numbers[i] = Math.random();
Counter counter = new Counter(numbers,0,numbers.length,x -> x > 0.5);
ForkJoinPool pool = new ForkJoinPool();
pool.invoke(counter);
System.out.println(counter.join());
}
}
class Counter extends RecursiveTask
{
public static final int THRESHOLD = 1000;
private double[] values;
private int from;
private int to;
private DoublePredicate filter;
public Counter(double[] values,int from,int to,DoublePredicate filter)
{
this.values = values;
this.from = from;
this.to = to;
this.filter = filter;
}
protected Integer compute()
{
if(to - from < THRESHOLD)
{
int count = 0;
for (int i = from;i < to;i++)
{
if (filter.test(values[i]))
count++;
}
return count;
}
else
{
int mid = (from + to)/2;
Counter first = new Counter(values, from, mid, filter);
Counter second = new Counter(values, mid, to, filter);
invokeAll(first, second);
return first.join()+second.join();
}
}
}
运行的结果是:
5.可完成Future
处理非阻塞调用的传统方法是使用事件处理器，程序员为任务完成之后要出现的动作注册一个处理器。当然，如果下一个动作也是异步的，在它之后的下一个动作会在一个不同的事件处理器中。尽管程序员会认为“先做步骤1,然后是步骤2,再完成步骤3”，但实际上程序逻辑会分散到不同的处理器中。如果必须增加错误处理，情况会更糟糕。假设步骤2是“用户登录”。可能需要重复这个步骤，因为用户输入凭据时可能会出错。要尝试在一组事件处理器中实现这样一个控制流，或者想要理解所实现的这样一组事件处理器，会很有难度。
JavaSE8的CompletableFuture类提供了一种候选方法。与事件处理器不同，“可完成future"可以“组合”（composed)。
例如，假设我们希望从一个Web页面抽取所有链接来建立一个网络爬虫。下面假设有这样一个方法：
public void CorapletableFuture
Web页面可用时这会生成这个页面的文本。如果方法：
public static List
生成一个HTML页面中的URL，可以调度当页面可用时再调用这个方法：
ConipletableFuture
CompletableFuture
thenApply方法不会阻塞。它会返回另一个fiiture。第一个fiiture完成时，其结果会提供给getLinks方法，这个方法的返回值就是最终的结果。
利用可完成fiiture，可以指定你希望做什么，以及希望以什么顺序执行这些工作。当然，这不会立即发生，不过重要的是所有代码都放在一处。
从概念上讲，CompletableFuture是一个简单API,不过有很多不同方法来组合可完成fiiture。下面先来看处理单个fiiture的方法（如表所示)。（对于这里所示的每个方法，还有两个Async形式，不过这里没有给出，其中一种形式使用一个共享ForkJoinPool，另一种形式有一个Executor参数)。在这个表中，使用了简写记法来表示复杂的函数式接口，这里会把Function写为T->U。当然这并不是真正的Java类型。
你已经见过thenApply方法。以下调用：
CompletableFuture future.thenApply(f);
CompletableFuture future.thenApplyAsync(f);
会返回一个future,可用时会对future的结果应用f。第二个调用会在另一个线程中运行f。
thenCompose方法没有取函数T->U,而是取函数T->CompletableFuture。这听上去相当抽象，不过实际上也很A然。考虑从一个给定URL读取一个Web页面的动作。不用提供方法：
public String blockingReadPage(URL url)
更精巧的做法是让方法返回一个future:
public CompletableFuture
现在，假设我们还有一个方法可以从用户输入得到URL,这可能从一个对话框得到，而在用户点击OK按钮之前不会得到答案。这也是将来的一个事件：
public CompletableFuture
这里我们有两个函数T->CompletableFuture和U->CompletableFuture
表中的第3个方法强调了目前为止一直忽略的另一个方面：失败（failure)。CompletableFuture中拋出一个异常时，会捕获这个异常并在调用get方法时包装在一个受查异常ExecutionException中。不过，可能get永远也不会被调用。要处理异常，可以使用handle方法。调用指定的函数时要提供结果（如果没有则为null)和异常（如果没有则为null),这种情况下就有意义了。
其余的方法结果都为void，通常用在处理管线的最后。下面来看组合多个future的方法。
前3个方法并行运行一个CompletableFuture
接下来3个方法并行运行两个CompletableFuture
最后的静态allOf和anyOf方法取一组可完成fiiture(数目可变)，并生成一个CompletableFuture