Java线程池ExecutorService时让主线程等待子线程完成后继续处理

素颜马尾好姑娘i 2022-01-27 21:17 750阅读 0赞

# **更多线程知识访问 [www.itkc8.com][]** #

线程池工具类：

import java.util.concurrent.\*;

public class CommonThreadPool \{  
    private static ExecutorService exec = new ThreadPoolExecutor(50, 100, 0L,  
        TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(10000),  
        new ThreadPoolExecutor.CallerRunsPolicy());

public static void execute(Runnable command) \{  
        exec.execute(command);  
    \}

// 子线程执行结束future.get()返回null，若没有执行完毕，主线程将会阻塞等待  
    public static Future submit(Runnable command) \{ return exec.submit(command); \}  
    // 子线程中的返回值可以从返回的future中获取：future.get();  
    public static Future submit(Callable command) \{  
        return exec.submit(command);  
    \}  
\}  
  
测试类：

import java.util.ArrayList;  
import java.util.List;  
import java.util.concurrent.ExecutionException;  
import java.util.concurrent.Future;

public class ThreadTest \{

@Test  
    public void ThreadTest() \{

List<Future> futureList = new ArrayList<>();  
        for(int i = 0; i < 4; i++) \{  
            int finalI = i;  
            Future future = CommonThreadPool.submit(() -> \{  
                try \{  
                    System.out.println(finalI + "    我执行了。。。");  
                    Thread.sleep(5000L);  
                    System.out.println(finalI + "    我执行完了。。。");

\} catch (InterruptedException e) \{  
                    e.printStackTrace();  
                \}  
            \});  
            futureList.add(future);  
        \}

//主线程处理其他工作,让子线程异步去执行.  
        mainThreadOtherWork();  
        System.out.println("now waiting sub thread done.");  
        //主线程其他工作完毕,等待子线程的结束, 调用future.get()系列的方法即可。  
        //

try \{  
            for (Future future : futureList) \{  
                System.out.println(future.get());  
            \}  
        \} catch (InterruptedException | ExecutionException e) \{  
            e.printStackTrace();  
        \}  
        try \{  
            System.out.println("处理一.");  
            Thread.sleep(1000);  
            System.out.println("处理二.");  
            Thread.sleep(1000);  
            System.out.println("处理三.");  
            Thread.sleep(1000);  
            System.out.println("处理四.");  
            Thread.sleep(1000);  
            System.out.println("所有处理完成.");

\} catch (InterruptedException e) \{  
            e.printStackTrace();  
        \}  
    \}

private static void mainThreadOtherWork() \{  
        System.out.println("主线程开始工作");  
        try \{  
            Thread.sleep(2000L);  
        \} catch (InterruptedException e) \{  
            e.printStackTrace();  
        \}  
        System.out.println("主线程干完了");  
    \}

\}  
  
执行结果：

主线程开始工作  
0    我执行了。。。  
2    我执行了。。。  
3    我执行了。。。  
1    我执行了。。。  
主线程干完了  
等待子线程执行.  
2    我执行完了。。。  
3    我执行完了。。。  
1    我执行完了。。。  
0    我执行完了。。。  
null  
null  
null  
null  
处理一.  
处理二.  
处理三.  
处理四.  
所有处理完成.

[www.itkc8.com]: http://www.itkc8.com