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[n];
		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[n];
		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[n];
		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