Executors.newCachedThreadPool

public class ThreadExcecutor {
    private static     ExecutorService ex=Executors.newCachedThreadPool();
    public static void main(String[] args) {
          for(int i=0;i<1000;i++){
            ex.execute(new Runnable(){
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("ThreadName="+Thread.currentThread().getName());
                }
                
            });
        }
        ex.shutdown();
    }
}

 

这种方式，每遇到一个 任务，都会创建一个线程来处理。
当处理第4个任务时，如果处理第一个任务的线程已经返回，则会循环使用第一个线程，而不会创建新的线程，否则新建Thread。

创建一个缓存，将线程缓存起来。自动终止并且移除60s没有使用的线程。如果池中有可用的线程，就取，没有就建。

用武之地：生存期短的任务，因此不适用于面向连接的任务。

 

private static ExecutorService exFix=Executors.newFixedThreadPool(100);

newCachedThreadPool 有可能会因为任务量很大，导致无限制创建Thread导致 内存满；相比之下，newFixedThreadPool(int) 解决了这个隐患；

 

package com.java.threadPool;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class Ch09_Executor {
    
   private static void doTest(ExecutorService threadPool) {
           for(int i = 1; i < 5; i++) {
            final int taskID = i;  
            threadPool.execute(new Runnable() {  
                @Override
                public void run() {  
                    for(int i = 1; i < 5; i++) {  
                        try { 
                            Thread.sleep(200);// 为了测试出效果，让每次任务执行都需要一定时间  
                        } catch (InterruptedException e) {  
                            e.printStackTrace();  
                        }  
                        System.out.println("第" + taskID + "次任务的第" + i + "次执行");  
                    }  
                }  
            });  
        }  
        threadPool.shutdown();// 任务执行完毕，关闭线程池  
   }
    
    public static void main(String[] args) {
        // 创建可以容纳3个线程的线程池
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        
        // 线程池的大小会根据执行的任务数动态分配
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        
            // 创建单个线程的线程池，如果当前线程在执行任务时突然中断，则会创建一个新的线程替代它继续执行任务  
        ExecutorService singleThreadPool = Executors.newSingleThreadExecutor();
        
        // 效果类似于Timer定时器
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);
        
        doTest(fixedThreadPool);
//        run(cachedThreadPool);
//        run(singleThreadPool);
//        run(scheduledThreadPool);
    }

}