java多线程处理（java.util.concurrent）

最近看了一些多线程处理的代码，将所用的的内容和看到的资料整理了一下，如下：

java.util.concurrent 包
Executor ：具体Runnable任务的执行者。
ExecutorService ：一个线程池管理者，其实现类有多种，我会介绍一部分。我们能把Runnable,Callable提交到池中让其调度。
Future ：是与Runnable,Callable进行交互的接口，比如一个线程执行结束后取返回的结果等等，还提供了cancel终止线程。

 

Executors主要方法说明

newFixedThreadPool（固定大小线程池）
创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程（只有要请求的过来，就会在一个队列里等待执行）。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。

newCachedThreadPool（无界线程池，可以进行自动线程回收）
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。对于执行很多短期异步任务的程序而言，这些线程池通常可提高程序性能。调用 execute 将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。因此，长时间保持空闲的线程池不会使用任何资源。注意，可以使用 ThreadPoolExecutor 构造方法创建具有类似属性但细节不同（例如超时参数）的线程池。

newSingleThreadExecutor（单个后台线程）
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。（注意，如果因为在关闭前的执行期间出现失败而终止了此单个线程，那么如果需要，一个新线程将代替它执行后续的任务）。可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。与其他等效的 newFixedThreadPool(1) 不同，可保证无需重新配置此方法所返回的执行程序即可使用其他的线程。

这些方法返回的都是ExecutorService对象，这个对象可以理解为就是一个线程池。
这个线程池的功能还是比较完善的。可以提交任务submit()可以结束线程池shutdown()。

示例代码：

import java.util.ArrayDeque;
import java.util.Deque;
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 ExecutorTest {

	// =============== 测试1（start） ===============
	// 实现Runnable接口
	private class MyRunnable implements Runnable {

		private int index = 0;

		public MyRunnable(int i) {
			this.index = i;
		}

		@Override
		public void run() {
			try {
				System.out.println("thread [" + this.index + "] start....");
				Thread.sleep((int) (Math.random() * 3000));
				System.out.println("thread [" + this.index + "] end.");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

	// 通过ExecutorService调用多线程
	public void doExecutorService_excute() {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		for (int i = 1; i <= 10; i++) {
			executorService.execute(new MyRunnable(i));
		}
		executorService.shutdown();
	}

	// =============== 测试1（end） ===============

	// =============== 测试2（start） ===============
	// 实现
	private class MyCallable implements Callable<String> {
		private int index = 0;

		public MyCallable(int i) {
			this.index = i;
		}

		@Override
		public String call() throws Exception {
			System.out.println("thread [" + this.index + "] start....");
			Thread.sleep((int) (Math.random() * 3000));
			return "thread [" + this.index + "] end.";
		}
	}
	// 通过ExecutorService调用多线程
	public void doExecutorService_submit() throws InterruptedException, ExecutionException {
		ExecutorService executorService = Executors.newFixedThreadPool(3);
		Deque<Future<?>> futures = new ArrayDeque<Future<?>>();
		for (int i = 1; i <= 10; i++) {
			futures.add(executorService.submit(new MyCallable(i)));
		}
		System.out.println("show return str:");
		for (Future<?> future : futures) {
			System.out.println(future.get().toString());
		}
		executorService.shutdown();
	}
	// =============== 测试2（end） ===============

	//执行测试
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		//new ExecutorTest().doExecutorService_excute();
		new ExecutorTest().doExecutorService_submit();
	}
}