多线程知识点总结（3）

线程池

基本线程池应用

JDK自带线程池Executor接口，子接口是ExecutorService，最常用的实现是ThreadPoolExecutor：

private static void testExecutor(){
        //实例化一个ThreadPoolExecutor线程池，包含5条线程
        //corePoolSize和maximumPoolSize均为5，keepAliveTime为0，默认workQueue为LinkedBlockingQueue
        ExecutorService service = Executors.newFixedThreadPool(5);
        
        //放入两个任务
        service.submit(()->{
           for(int i = 0; i<10; i++){
               try {
                   System.out.println("第一个任务："+":"+i);
                   Thread.sleep(500);
               }catch (Exception e){
                   e.printStackTrace();
               }
           }
        });
        service.submit(()->{
            for(int i = 0; i<10; i++){
                try {
                    System.out.println("第二个任务："+":"+i);
                    Thread.sleep(500);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });
        
        //主线程来判断线程池中所有任务是否已经完成
        while (!service.isTerminated()){
            System.out.println("主线程等待中......");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

在这个例子中，corePoolSize、maximumPoolSize和keepAliveTime都没刻意设置：

• corePoolSize：线程池中常驻的线程数量，不会被销毁
• maximumPoolSize：最大线程数量，如果加入的任务数量超过了常驻线程数量，则新建额外的线程来满足需求，直到达到最大数量后进入阻塞状态
• keepAliveTime：创建的额外线程进入闲置状态后的允许等待时间，超过这个时间则销毁
• 默认的阻塞容器为LinkedBlockingQueue

返回异步任务结果

若需要获得异步任务的执行结果，则需要启用Future和Callable接口：

private static void testFuture(){
        //继续创建5个线程的线程池
        ExecutorService service = Executors.newFixedThreadPool(5);

        //通过Callable和Future来获取异步任务执行结果
        Future<String> future1 = service.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                for(int i = 0; i<10; i++){
                    System.out.println("第一个任务");
                }
                return "第一个任务执行完成！";
            }
        });
        try {
            //异步任务执行完后再由Future返回执行结果
            //Future的get方法是一个持续等待的阻塞方法
            System.out.println(future1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }