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

--------------------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、常见的线程相关类的关系图:



 

 

猜你喜欢

转载自raising.iteye.com/blog/2415270

相关文章