多线程在项目中的实践

系统管理员 2022-05-22 04:09 259阅读 0赞

## 第一种方式 ##

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到。