Java等线程池中的任务执行完之后再执行主线程之后的逻辑

看网上说用countDownLatch或者线程池的awaitTermination方法，但是测试了一下awaitTermination不管用，不知道是我写的有问题还是咋的

方法一：使用CountDownLatch

package mulityThreadTest;


import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ConuntDownLatchTest2 {
    ThreadPoolExecutor threadPoolExecutor =
            new ThreadPoolExecutor(1, 10, 2L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(Integer.MAX_VALUE));

//    ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        ConuntDownLatchTest2 terminationTest = new ConuntDownLatchTest2();
        try {
            terminationTest.test();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    void test() throws InterruptedException {
        Integer taskCount = 100;
        CountDownLatch latch = new CountDownLatch(taskCount);
        for (int i = 0; i < taskCount; i++) {
            final Integer j = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("time:" + System.currentTimeMillis() + "  currentThread:" + Thread.currentThread().getName() + "  print j:" + j);
                    latch.countDown();
                }
            });

        }
        latch.await();
        System.out.println("main lacthCount:" + latch.getCount());

        System.out.println("all subTask finished");

    }
}

运行结果：

方法二：使用CompletableFuture

测试是没啥问题的，实际业务里不知道会不会有什么问题
每次都会重新new个对象…

package mulityThreadTest;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

public class CompletableFutureTest {
    ThreadPoolExecutor threadPoolExecutor =
            new ThreadPoolExecutor(1, 10, 2L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(Integer.MAX_VALUE));

//    ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        CompletableFutureTest terminationTest = new CompletableFutureTest();
        try {
            terminationTest.test();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    void test() throws InterruptedException {
        CompletableFuture future01 = null;
        for (int i = 0; i < 100; i++) {
            final Integer j = i;
            future01 = CompletableFuture.supplyAsync(new Supplier<Object>() {
                @Override
                public Object get() {
                    System.out.println("time:" + System.currentTimeMillis() + "  currentThread:" + Thread.currentThread().getName() + "  print j:" + j);
                    return null;
                }
            }, threadPoolExecutor);
        }

        CompletableFuture<Void> allOf = CompletableFuture.allOf(future01);

        try {
            Void unused = allOf.get();//等待所有结果完成
            System.out.println("all subTask finised");
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }


    }
}

运行结果：

三，使用threadPoolExecutor.awaitTermination测试

package mulityThreadTest;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class AwaitTerminationTest {
    ThreadPoolExecutor threadPoolExecutor =
            new ThreadPoolExecutor(1, 10, 2L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(Integer.MAX_VALUE));

//    ExecutorService threadPoolExecutor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        AwaitTerminationTest terminationTest = new AwaitTerminationTest();
        terminationTest.test();
    }

    void test() {
        for (int i = 0; i < 10; i++) {
            final Integer j = i;
            threadPoolExecutor.execute(new Runnable() {
                @Override
                public void run() {
                    System.out.println("time:" + System.currentTimeMillis() + "  currentThread:" + Thread.currentThread().getName() + "  print j:" + j);
                }
            });

        }
//        threadPoolExecutor.shutdown();
//        System.out.println("threadPoolExecutor.shutdown()");
//        if (threadPoolExecutor.isTerminated()){
//            System.out.println("threadPoolExecutor.isTerminated() allThread execute finised");
//        }

        try {

            if (threadPoolExecutor.awaitTermination(6, TimeUnit.SECONDS)) {
                System.out.println("time:" + System.currentTimeMillis() + "  threadPoolExecutor.awaitTermination allThread execute finised");
            } else {
                System.out.println("time:" + System.currentTimeMillis() + "  threadPoolExecutor.awaitTermination return false");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }


        while (true) {

        }
//        try {
//            Thread.sleep(2L);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        if (threadPoolExecutor.getCompletedTaskCount() == 0){
//            System.out.println("allThread execute finised");
//        }
    }
}

运行结果：

无论任务是否执行完毕，都需要等6秒之后输出threadPoolExecutor.awaitTermination return false，永远不会return true。所以使用awaitTermination 不管true还是false都没法用，不知道是不是我写的有问题…