多线程：如何确定所有任务都执行完成了？

--------------------20180502更新-----------------------------

今天学习到了一个比较强大的类：ExecutorCompletionService，它是将 Executor和BlockQueue结合的jdk类，其实现的主要目的是：提交任务线程，每一个线程任务直线完成后，将返回值放在阻塞队列中，然后可以通过阻塞队列的take()方法返回 对应线程的执行结果！！

所以还可以这样写：

 

ExecutorCompletionService<String> completionService = new ExecutorCompletionService(Executors.newFixedThreadPool(5));
        for(int i=0; i<10; i++) {
            int j = i;
            completionService.submit(()-> Thread.currentThread().getName() + "------>" + j);
        }

        try {
            for(int i=0; i<10; i++) {
                Future<String> future = completionService.take();
                if(future != null) {
                    String str = future.get();
                    System.out.println(str);
                }
            }


        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("---------->结束");

 同样可以达到阻塞的效果！（注：其中有用到jdk1.8的lambda表达式~）

---------------------------------------------------------------------------------------------------------

 

之前我有写过一篇博客，是关于多线程写同一个sheet文件的。类似的场景很多，当我们想用多线程提高效率时，面临的关键问题就是线程安全和确定所有任务都完成。线程安全的问题那篇博客有说，就是确保对公共资源的写操作是安全的，比如List的add操作采用synchronized来包装或直接采用线程安全的集合；Sheet的addRow加锁等… 而本篇的重点是“如何确保所有任务都完成，才能进行下一步？”。

 

先来看现象：

 

public static void m() {
    for(int i=0; i<10; i++) {
      int j = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          System.out.println(Thread.currentThread().getName() + "------>" + j);
        }
      }).start();
    }

    System.out.println("---------->结束");
  }

 这段代码创建了10个线程，每个线程的任务会打印当前线程的名字，运行后发现可能出现以下结果（顺序不一定是下面这样）：

 

Thread-1------>1
---------->结束

Thread-0------>0
Thread-2------>2
Thread-4------>4
Thread-3------>3
Thread-5------>5
Thread-6------>6
Thread-7------>7
Thread-8------>8
Thread-9------>9

会发现“---------->结束”没有在所有线程都运行完就打印出来了，映射到实际场景就是用多线程去帮我们干活，还没干完呢就直接下一步了，如此的话没有实际意义（除非这个多线程的任务是异步的，其他逻辑不需要等待它完成才能进行）。

 

我们知道，多线程执行任务可以用原始的线程提交（上述代码），也可以用线程池（比较推荐这种方式，便于对线程进行管理）。为了解决上述问题，可以用CountDownLatch计数器，计数器的初始大小要跟任务数的大小一致（跟线程数无关），每执行一次任务，计数器减一（countDown），await()方法会一直阻塞主线程，直到计数器的值减为0，才会释放锁，如此便可以达到确保所有任务都完成才继续下一步的效果。

 

先用原始线程结合计数器的方式来试试效果：

 

public static void m1() {
    CountDownLatch latch = new CountDownLatch(10);
    for(int i=0; i<10; i++) {
      int j = i;
      new Thread(new Runnable() {
        @Override
        public void run() {
          System.out.println(Thread.currentThread().getName() + "------>" + j);
          latch.countDown();
        }
      }).start();
    }
    try {
      latch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("---------->结束");
  }

 无论运行多少次，会发现"---------->结束"始终会在多线程所有任务都执行完毕后打印，比如某次结果：

 

Thread-0------>0
Thread-1------>1
Thread-2------>2
Thread-3------>3
Thread-4------>4
Thread-7------>7
Thread-8------>8
Thread-9------>9
Thread-5------>5
Thread-6------>6
---------->结束

 

再用线程池结合计数器的方式来尝试：

 

public static void m2() {
    CountDownLatch latch = new CountDownLatch(10);
    ExecutorService es = Executors.newFixedThreadPool(5);
    for(int i=0; i<10; i++) {
      int j = i;
      es.submit(new Runnable() {
        @Override
        public void run() {
          System.out.println(Thread.currentThread().getName() + "------>" + j);
          latch.countDown();
        }
      });
    }
    try {
      latch.await();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
    System.out.println("---------->结束");
  }

 同样地，无论运行多少次，"---------->结束"都会在所有任务都完成以后再进行！比如某次打印结果为：

pool-1-thread-2------>1
pool-1-thread-2------>5
pool-1-thread-3------>2
pool-1-thread-1------>0
pool-1-thread-1------>8
pool-1-thread-1------>9
pool-1-thread-3------>7
pool-1-thread-4------>3
pool-1-thread-2------>6
pool-1-thread-5------>4
---------->结束

 

这充分印证了CountDownLatch计数器的强大！下面我们再看一个比较容易忽略的方式：

 

public static void m3() {
    ExecutorService es = Executors.newFixedThreadPool(5);

    List<Future<String>> list = new ArrayList<>();
    for(int i=0; i<10; i++) {
      int j = i;
      Future<String> future = es.submit(new Callable<String>() {
        @Override
        public String call() throws Exception {
          return Thread.currentThread().getName() + "------>" + j;
        }
      });
      list.add(future);
    }

    try {
      for(Future<String> future : list) {
        System.out.println(future.get());
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (ExecutionException e) {
      e.printStackTrace();
    }

    System.out.println("---------->结束");
  }

 Callable不用多说，它可以表示一个有返回值的线程，Future则用于接收返回的结果。Future的get方法具有阻塞作用，它会一直阻塞直至获取到结果。Callable&Future一般都是结合线程池来使用。

运行多次，也会发现"---------->结束"总是在最后运行的，同样达到了目的。

 

说到线程池管理线程，需要注意的是比如：

 

Executors.newFixedThreadPool(40)

 

实际上是new了一个corePoolSize=maximumPoolSize的特殊情况的线程池：

 

public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
                                  new LinkedBlockingQueue<Runnable>());
}

 

Executors提供的静态方法创建线程池，内部都是去构造一个ThreadPoolExecutor，只是不同类型的线程池，

 

corePoolSize和maximumPoolSize的大小关系不同，还有采用的任务队列的类型也不同。

 

 

 

关于多线程和线程池的一些知识补充，见以下手工笔记：

 

1.一些多线程的基本概念：

 

 

 

2、线程池类型以及提交线程的过程：

 

 

3、常见的线程相关类的关系图：