java并发包学习笔记2-Future与CompletableFuture

实现一个Runnable接口，传入线程池可以通过多线程运行。

public class MyTask implements Runnable{
	private int id;
	
	public MyTask() {
	}
	
	public MyTask(int id) {
		this.id = id;
	}
	@Override
	public void run() {
		try {
			Thread.sleep(100);
			System.out.println("id = " + this.id);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class FixedThreadPoolTest {

	public static void main(String[] args) {
		ExecutorService es = Executors.newFixedThreadPool(4);
		for (int i = 0; i < 8; i++) {
			es.submit(new MyTask(i));
		}
		es.shutdown();
	}
}

但是Runnable接口的run方法没有返回值。如果想运行多线程时得到返回值，可以实现一个Callable接口，然后通过Future获得返回值。

import java.util.concurrent.Callable;

public class MyCallable implements Callable<String>{

	@Override
	public String call() throws Exception {
		Thread.sleep(2000);
		return String.valueOf(Math.random());
	}
}

/**
 * 实现Callable接口可以有返回值
 * Future可以获取线程池返回结果，但会阻塞
 * @author Administrator
 *
 */
public class FutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		ExecutorService es = Executors.newFixedThreadPool(1);
		Future<String> future = es.submit(new MyCallable());
		long start = System.currentTimeMillis();
		System.out.println("value = " + future.get());
		long end = System.currentTimeMillis();
		System.out.println("Time is " + (end - start));
		es.shutdown();
	}

}

通过Future获得线程返回值，主线程会被堵塞。使用CompletableFuture可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

public class CompletableFutureTest {

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		// 创建异步执行任务:
		CompletableFuture<String> future1 = CompletableFuture.supplyAsync(new MySupplier());
		//成功执行第二个任务
		CompletableFuture<String> future2 = future1.thenApplyAsync(new MyFunction1());
		// 如果执行成功:
		future2.thenAccept(new MyConsumer());
		// 如果执行异常:
        future2.exceptionally(new MyFunction2());
        // 主线程不要立刻结束，否则CompletableFuture默认使用的线程池会立刻关闭:
		Thread.sleep(3000);
		
	}

}

class MySupplier implements Supplier<String> {

	@Override
	public String get() {
		System.out.println("MySupplier get!");
		return "Hello";
	}	
}

class MyFunction1 implements Function<String, String> {

	@Override
	public String apply(String t) {
		System.out.println("MyFunction1 apply!");
		return t + " world!";
	}	
}

class MyFunction2 implements Function<Throwable, String> {

	@Override
	public String apply(Throwable t) {
		System.out.println("MyFunction2 apply!");
		t.printStackTrace();
		return null;
	}	
}

class MyConsumer implements Consumer<String> {

	@Override
	public void accept(String t) {
		System.out.println("MyConsumer accept!");
		System.out.println(t);
	}	
}

运行结果如下：

MySupplier get!
MyFunction1 apply!
MyConsumer accept!
Hello world!