java线程池的自带监控，线程池返回值的控制

当使用java线程池的时候，返回值类型用future<T> 来接收，比如：

Future<String> future = fixedThreadPool.submit(new Thread());返回的结果必须由线程执行完毕后才会返回，我们可以利用这一点进行线程堵塞，监控线程的结束时间。

package com.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class TestDemo9 {

    ExecutorService indes = Executors.newCachedThreadPool();
     public static ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

    public static void main(String[] args) {
        try {
            new TestDemo9().test();
        } catch (Exception e) {
            System.out.println("有错误");
        }
        System.out.println("此进程执行结束");

    }

    public void test() throws Exception{

        List<Future<String>> list = new ArrayList<>();

        for(int i = 0; i < 10 ; i ++) {

             Future<String> future = indes.submit(new TestDemo9().new Test9(i));

             list.add(future);

        }
        System.out.println("加入队列结束");

        /*for(Future<String> fu : list) {
                System.out.println(fu.get());
                if(fu.get().equals("future集合7")) {
                    System.out.println("7此时的线程已经执行结束了");
                    break;
                }
        }*/

        //System.out.println(fixedThreadPool.isTerminated());
        //list.clear();
        //System.out.println("size"+list.size());

        //fixedThreadPool.shutdown();
        System.out.println("集合打印结束");
        //System.out.println(fixedThreadPool.isShutdown());

    }

    class Test9 implements Callable<String>{

        private int count;

        public Test9(int count) {
            this.count = count;
        }

        @Override
        public String call() throws Exception {
            if(count == 1) {
                System.out.println("第一进程开始运行");
            }
            //Thread.sleep(5000);
            //List<Future<String>> fut = new ArrayList<>();
             Future<String> f = TestDemo10.fixedThreadPool.submit(new Test10(count));

            String s = "future集合";
            System.out.println("执行"+count);
            s = s+count;

            if(count == 1) {
                 System.out.println(f.get());
                 System.out.println("1!!!!!执行结束");
             }

            return s;
        }
    }

class Test10 implements Callable<String>{

        private int count;

        public Test10(int count) {
            this.count = count;
        }

        @Override
        public String call() throws Exception {
            if(count == 1) {
                System.out.println("开始执行1111111");
            }
            Thread.sleep(5000);
            String s = "future集合";
            System.out.println(count);
            s = s+count;
            if(count == 1) {
                System.out.println("1开始睡觉 5秒钟");
                Thread.sleep(5000);
                System.out.println("1 睡觉完毕，");
            }
            System.out.println(count+"执行结束");
            return s;
        }
    }

}

如测试代码所示，线程没有执行完毕，会通过System.out.println(f.get());进行堵塞，此方法不会结束，利用这一点可以监控线程的执行时间。

如果去掉System.out.println(f.get())队列添加完毕后此方法会立即结束。

个人测试，希望大神指点！

原文地址：https://www.cnblogs.com/doudouyu/p/9448124.html