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

maximumPoolSize：此参数的价值在于当coresize线程数达到最大，并且workQueue达到最大，此时正在执行的线程数小于coresize，就会创建新的线程去执行，直到线程数小于maximumPoolSize；

当使用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())队列添加完毕后此方法会立即结束。

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