ThinkingInJava——并发之Thread,Executor,Callable

一 Thread类

将Runnable对象转换为工作任务的传统方式是把它提交给一个Thread构造器，调用Thread对象的start()方法为该线程执行必需的初始化操作，然后调用Runnable的run()方法，以便在这个新线程中启动任务。start()方法调用后会立即返回当前线程，而由其它线程去执行run()方法。

练习1：实现一个Runnable。在run()内部打印一个消息，然后调用yield()。重复这个操作三次，然后从run中返回。在构造器中放置一条启动消息，并且放置一条在任务终止时的关闭消息。使用线程创建大量的这种任务并驱动他们。

public class TestExcOne {
public static void main(String[] args) {
for(int i=0;i<3;i++){
new Thread(new ExcOne()).start();
}
}
}
class ExcOne implements Runnable{
private static int taskCount=0;
private final int id=taskCount++;
public ExcOne(){
System.out.println("任务启动"+id);
}
public void run(){
System.out.println("任务"+id+"打印消息1");
Thread.yield();
System.out.println("任务"+id+"打印消息2");
Thread.yield();
System.out.println("任务"+id+"打印消息3");
Thread.yield();
System.out.println("任务"+id+"关闭");
}
}

输出：

任务启动0

任务启动1

任务0打印消息1

任务0打印消息2

任务0打印消息3

任务启动2

任务0关闭

任务1打印消息1

任务1打印消息2

任务1打印消息3

任务1关闭

任务2打印消息1

任务2打印消息2

任务2打印消息3

任务2关闭

练习2：遵循generic/Fibonacci.java的形式，创建一个任务，它可以产生由n个斐波那契数字组成的序列，其中n是通过任务的构造器而提供的，使用线程创建大量这样的任务并驱动他们。

import java.util.Arrays;
public class TestExcTwo {
public static void main(String[] args) {
for(int i=1;i<10;i++){
new Thread(new ExcTwo(i)).start();
}
}
}

class ExcTwo implements Runnable{
private final int n;
public ExcTwo(int n) {
this.n=n;
}

private int[] getFib(int n){
int[] arr=new int
;
if(n==1){
arr[0]=1;
return arr;
}
if(n==2){
arr[0]=1;
arr[1]=1;
return arr;
}
arr[0]=1;arr[1]=1;
for(int i=2;i<n;i++){
arr[i]=arr[i-1]+arr[i-2];
}
return arr;
}
@Override
public void run() {
System.out.println(Arrays.toString(getFib(n)));
}
}

输出：

[1]

[1, 1, 2]

[1, 1, 2, 3, 5]

[1, 1]

[1, 1, 2, 3]

[1, 1, 2, 3, 5, 8]

[1, 1, 2, 3, 5, 8, 13]

[1, 1, 2, 3, 5, 8, 13, 21]

[1, 1, 2, 3, 5, 8, 13, 21, 34]

二 Executor

Executor允许你管理异步任务的执行，而无须显示地管理线程的声明周期。

练习3：使用不同的执行器重复练习1

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestExcThree {
public static void main(String[] args) {
ExecutorService exec=Executors.newCachedThreadPool();
//ExecutorService exec=Executors.newFixedThreadPool(1);
//ExecutorService exec=Executors.newSingleThreadExecutor();
for(int i=0;i<10;i++){
exec.execute(new ExcOne());
}
exec.shutdown();
}
}
class ExcOne implements Runnable{
private static int taskCount=0;
private final int id=taskCount++;
public ExcOne(){
System.out.println("任务启动"+id);
}
public void run(){
System.out.println("任务"+id+"打印消息1");
Thread.yield();
System.out.println("任务"+id+"打印消息2");
Thread.yield();
System.out.println("任务"+id+"打印消息3");
Thread.yield();
System.out.println("任务"+id+"关闭");
}
}

练习4：使用不同的执行器重复练习2

import java.util.Arrays;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class TestExcFour {
public static void main(String[] args) {
ExecutorService exec=Executors.newCachedThreadPool();
//ExecutorService exec=Executors.newFixedThreadPool(10);
//ExecutorService exec=Executors.newSingleThreadExecutor();
for(int i=1;i<10;i++){
exec.execute(new ExcTwo(i));
}
exec.shutdown();
}
}

class ExcTwo implements Runnable{
private final int n;
public ExcTwo(int n) {
this.n=n;
}

private int[] getFib(int n){
int[] arr=new int
;
if(n==1){
arr[0]=1;
return arr;
}
if(n==2){
arr[0]=1;
arr[1]=1;
return arr;
}
arr[0]=1;arr[1]=1;
for(int i=2;i<n;i++){
arr[i]=arr[i-1]+arr[i-2];
}
return arr;
}
@Override
public void run() {
System.out.println(Arrays.toString(getFib(n)));
}
}

3.1 CachedThreadPool

创建与所需数量相同的线程，然后在它回收旧线程时停止创建新线程，它是合理的Executor的首选，输出如下：

[1]

[1, 1]

[1, 1, 2, 3]

[1, 1, 2, 3, 5, 8]

[1, 1, 2]

[1, 1, 2, 3, 5]

[1, 1, 2, 3, 5, 8, 13]

[1, 1, 2, 3, 5, 8, 13, 21]

[1, 1, 2, 3, 5, 8, 13, 21, 34]

3.2 FixedThreadPool

创建固定数量的线程，输出如下：

[1]

[1, 1, 2, 3, 5]

[1, 1, 2, 3, 5, 8, 13, 21, 34]

[1, 1, 2]

[1, 1, 2, 3, 5, 8, 13]

[1, 1, 2, 3]

[1, 1, 2, 3, 5, 8, 13, 21]

[1, 1]

[1, 1, 2, 3, 5, 8]

3.3 SingleThreadExecutor

所有向SingleThreadExecutor提交的多个任务排队执行，所有任务使用相同线程，输出如下：

[1]

[1, 1]

[1, 1, 2]

[1, 1, 2, 3]

[1, 1, 2, 3, 5]

[1, 1, 2, 3, 5, 8]

[1, 1, 2, 3, 5, 8, 13]

[1, 1, 2, 3, 5, 8, 13, 21]

[1, 1, 2, 3, 5, 8, 13, 21, 34]

三 Future

Runnable是执行工作的独立任务，但是它不返回任何值。实现Callable接口的call()方法而不是Runable接口，在任务完成时能够返回一个值，必须使用ExecutorService.submit()方法调用实现Callable接口的实例，submit()方法会产生Future对象，它用Callable返回结果的特定类型进行了参数化，通过Future的get()方法获取返回值。

练习5：修改练习2，使得所有斐波那契数字的数值总和的任务称为Callable。创建多个任务并显示结果

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class TestExcFive {
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService exec=Executors.newCachedThreadPool();
List<Future<Integer>> res=new ArrayList<>();
for(int i=1;i<10;i++){
res.add(exec.submit(new ExcFive(i)));
}
exec.shutdown();
for(Future<Integer> fs: res){
System.out.println(fs.get());
}
}
}

class ExcFive implements Callable<Integer>{
private final int n;
public ExcFive(int n) {
this.n=n;
}

private int[] getFib(int n){
int[] arr=new int
;
if(n==1){
arr[0]=1;
return arr;
}
if(n==2){
arr[0]=1;
arr[1]=1;
return arr;
}
arr[0]=1;arr[1]=1;
for(int i=2;i<n;i++){
arr[i]=arr[i-1]+arr[i-2];
}
return arr;
}
@Override
public Integer call( ) throws Exception {
int sum=0;
int[] arr=getFib(n);
for(int i=0;i<n;i++){
sum+=arr[i];
}
return sum;
}
}

输出：

1

2

4

7

12

20

33

54

88