import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
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;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.junit.Test;

public class JavaExecutor {

	public static class ThreadOne implements Runnable {

		@Override
		public void run() {
			System.out.println("I'm " + Thread.currentThread().getName());
		}

	}

	public static class ThreadTwo implements Callable<String> {
		private int id;

		public ThreadTwo(int id) {
			this.id = id;
		}

		@Override
		public String call() throws Exception {
			String name = Thread.currentThread().getName();
			System.out.println(name + " is called");
			return name + " result is " + id;
		}

	}

	public static class MyThread implements Runnable {
		@Override
		public void run() {
			System.out.println(Thread.currentThread().getName() + " 正在执行。。。");
		}
	}

	@Test
	public void testRunTask() {
		ExecutorService executorService = Executors.newFixedThreadPool(5);
		for (int i = 0; i < 5; i++) {
			// 执行Runnable任务，无返回值
			executorService.execute(new ThreadOne());
			System.out.println(i + 11);
		}
		executorService.shutdown();
	}

	@Test
	public void testCallTask() throws InterruptedException, ExecutionException {
		List<Future<String>> list = new ArrayList<>();
		ExecutorService executorService = Executors.newCachedThreadPool();
		for (int i = 0; i < 20; i++) {
			// 执行Callable任务，并将结果保存在future中
			Future<String> future = executorService.submit(new ThreadTwo(i + 1));
			list.add(future);
		}
		for (Future<String> future : list) {
			// Future返回如果没有完成，则一直循环等待，直到Future返回完成
			while (!future.isDone()) {
			}
			// 输出各个线程（任务）执行的结果
			System.out.println(future.get());
		}
		// 启动一次顺序关闭，执行以前提交的任务，不接受新任务
		executorService.shutdown();
	}

	@Test
	public void testSelfThreadPool() {
		// 创建等待队列
		BlockingQueue<Runnable> bqueue = new ArrayBlockingQueue<Runnable>(20);
		// 创建线程池，池中保存的线程数为3，允许的最大线程数为5
		ThreadPoolExecutor pool = new ThreadPoolExecutor(3, 5, 50, TimeUnit.MILLISECONDS, bqueue);
		// 创建七个任务
		Runnable t1 = new MyThread();
		Runnable t2 = new MyThread();
		Runnable t3 = new MyThread();
		Runnable t4 = new MyThread();
		Runnable t5 = new MyThread();
		Runnable t6 = new MyThread();
		Runnable t7 = new MyThread();
		// 每个任务会在一个线程上执行
		pool.execute(t1);
		pool.execute(t2);
		pool.execute(t3);
		pool.execute(t4);
		pool.execute(t5);
		pool.execute(t6);
		pool.execute(t7);
		// 关闭线程池
		pool.shutdown();
	}
}