多线程在项目中的实践

第一种方式

1. 新建线程池
2. 新建Future
3. 执行

ExecutorService threadPool = Executors.newFixedThreadPool(5);
List<Future<Map<String, String>>> futures = new ArrayList<Future<Map<String, String>>>();
final Map<String, String> maps = new HashMap<String, String>();
for(int i = 0; i< 3; i++){
	Future<Map<String, String>> future = threadPool.submit(
		new Callable<Map<String, String>>() {
			public Map<String, String> call() throws Exception {
				try {
					return doSthReturnMap();
				} catch (Exception e) {
					return null;
				}
			};
		}
	);
	futures.add(future);
}

几种常用线程池的新建方法:

newCachedThreadPool

创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());

其构造方法实现如上所示，其中corePoolSize为0，maximumPoolSize为Integer最大值，其中阻塞队列使用的是SynchronousQueue。SynchronousQueue的存储空间为0，当把这种队列传给线程池之后，任务只能交给线程执行，不能存储在队列中。可以认为SynchronousQueue是一个刚创建出来就是满的阻塞队列并且永远都是满的。假如线程池中的线程个数未达到最大值，则每次往线程池提交任务，则它要么被空闲worker线程取出执行，要么被新创建的worker线程取出来执行。
这种类型的线程池特点是：
工作线程的创建数量几乎没有限制(数目为Interger. MAX_VALUE), 这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程。
在使用CachedThreadPool时，一定要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪（OOM）。饱和策略是ThreadPoolExecutor.AbortPolicy，即放弃执行，提交的线程一调用submit()就会接收到RejectedExecutionException异常。

newFixedThreadPool

创建一个指定工作线程数量的线程池。每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

new ThreadPoolExecutor(nThreads, nThreads,0L, TimeUnit.MILLISECONDS,
     new LinkedBlockingQueue<Runnable>());

FixedThreadPool的corePoolSize和maximumPoolSize相等。阻塞队列使用LinkedBlockingQueue，
队列的存储空间没有限制。使用这种队列的线程池，worker线程的个数达到corePoolSize之后不再增加，新的任务全部都存入队列，所以maximumPoolSize参数不会产生实质性的作用。这种队列适合任务之间无依赖关系的场景，也可以用于对突然增长的高并发请求进行平滑处理或削峰。

FixedThreadPool是一个典型且优秀的线程池，它具有线程池提高程序效率和节省创建线程时所耗的开销的优点。但是，在线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源。

newScheduleThreadPool

创建一个定长的线程池，而且支持定时的以及周期性的任务执行，支持定时及周期性任务执行。

new DelegatedScheduledExecutorService
            (new ScheduledThreadPoolExecutor(1));

newSingleThreadExecutor

创建一个单线程化的Executor，即只创建唯一的工作者线程来执行任务，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。如果这个线程异常结束，会有另一个取代它，保证顺序执行。单工作线程最大的特点是可保证顺序地执行各个任务，并且在任意给定的时间不会有多个线程是活动的。

new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));

第二种方式

通过CountDownLatch实现多线程结果的统一。

public class Test {
     public static void main(String[] args) {   
         final CountDownLatch latch = new CountDownLatch(2);
 
         new Thread(){
             public void run() {
                 try {
                    Thread.sleep(3000);
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
 
         new Thread(){
             public void run() {
                 try {
                     Thread.sleep(3000);
                     latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();
         try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

使用CountDownLatch进行异步转同步操作，每个线程退出前必须调用countDown方法，线程执行代码注意catch异常，确保countDown方法被执行到，避免主线程无法执行至await方法，直到超时才返回结果。 说明：注意，子线程抛出异常堆栈，不能在主线程try-catch到。