package com.sondon.mayi.jpool; 
 
import java.util.concurrent.ArrayBlockingQueue; 
import java.util.concurrent.Callable; 
import java.util.concurrent.ExecutionException; 
import java.util.concurrent.ExecutorService; 
import java.util.concurrent.Executors; 
import java.util.concurrent.ThreadPoolExecutor; 
import java.util.concurrent.TimeUnit; 
 
public class JPoolLearn { 
 
 private static int produceTaskSleepTime = 3; 
 private static int produceTaskMaxNumber = 20; 
  
 public void testThreadPoolExecutor(){ 
  /* 
   * ThreadPoolExecutor( 
   * int corePoolSize, //線程池維護線程的最少數(shù)量 
   * int maximumPoolSize, //線程池維護線程的最大數(shù)量 
   * long keepAliveTime, //線程池維護線程所允許的空閑時間 
   * TimeUnit unit, //線程池維護線程所允許的空閑時間的單位 
   * BlockingQueue<Runnable> workQueue, //線程池所使用的緩沖隊列 
   * RejectedExecutionHandler handler //線程池對拒絕任務的處理策略 ) 
   */ 
  ThreadPoolExecutor threadPool = new ThreadPoolExecutor( 
    5, 
    10, 
    3, 
    TimeUnit.SECONDS, 
    new ArrayBlockingQueue<Runnable>(10), 
    new ThreadPoolExecutor.DiscardOldestPolicy() 
    ); 
 
  for (int i = 1; i <= produceTaskMaxNumber; i++) { 
   try { 
    // 產(chǎn)生一個任務，并將其加入到線程池 
    String task = "task---" + i; 
    threadPool.execute(new ThreadPoolTask(task)); 
    System.out.println("activeCount :"+ threadPool.getActiveCount()); 
    // 便于觀察，等待一段時間 
    Thread.sleep(produceTaskSleepTime); 
   } catch (Exception e) { 
    e.printStackTrace(); 
   } 
  } 
   
  //查看當前的線程池狀況 
  while(true){ 
   try { 
    Thread.sleep(3000); 
    System.out.println("pool size :"+threadPool.getPoolSize());//線程池中線程數(shù)量 
    System.out.println("active count :"+threadPool.getActiveCount());//線程池中活動的線程數(shù)量 
   } catch (InterruptedException e) { 
    e.printStackTrace(); 
   } 
  } 
 } 
 
 /** 
  * 
  * @Author 蔡文鋒 
  * @Data_Time 2015年7月25日 下午4:06:28 
  * @Description { 測試不同線程池模式 } 
  */ 
 public void testNewCachedThreadPool(){ 
  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newCachedThreadPool(); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newFixedThreadPool(100); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newScheduledThreadPool(100); 
//  ThreadPoolExecutor threadPool=(ThreadPoolExecutor) Executors.newSingleThreadExecutor(); 
  try { 
  for (int i = 0; i < 100; i++) { 
   // 產(chǎn)生一個任務，并將其加入到線程池 
   String task = "task---" + i; 
   threadPool.execute(new ThreadPoolTask(task)); 
   System.out.println("activeCount :"); 
   // 便于觀察，等待一段時間 
   Thread.sleep(produceTaskSleepTime); 
    
   } 
  } catch (InterruptedException e) { 
   e.printStackTrace(); 
  } 
  //查看當前的線程池狀況 
  while(true){ 
   try { 
    Thread.sleep(3000); 
    System.out.println("pool size :"+threadPool.getPoolSize());//線程池中線程數(shù)量 
    System.out.println("active count :"+threadPool.getActiveCount());//線程池中活動的線程數(shù)量 
   } catch (InterruptedException e) { 
    e.printStackTrace(); 
   } 
  } 
 } 
  
 /** 
  * 
  * @Author 蔡文鋒 
  * @Data_Time 2015年7月25日 下午4:06:58 
  * @Description { 測試callable與runable方法的區(qū)別 } 
  */ 
 public void testNewCachedThreadPool_callable(){ 
  ExecutorService es=Executors.newFixedThreadPool(10); 
  try { 
    
//   String result=es.submit(new MyCallable<String>()).get(); 
//   System.out.println("callable result :"+result); 
    
   String result=(String) es.submit(new ThreadPoolTask("")).get(); 
   System.out.println("runable result :"+result); 
    
  } catch (InterruptedException | ExecutionException e) { 
   e.printStackTrace(); 
  } 
 } 
  
  
 public static void main(String[] args) { 
  new JPoolLearn().testNewCachedThreadPool(); 
 } 
} 
 
 
 
/** 
 * 線程池執(zhí)行的任務 
 */ 
class ThreadPoolTask implements Runnable { 
 private static int consumeTaskSleepTime = 2000; 
 // 保存任務所需要的數(shù)據(jù) 
 private Object threadPoolTaskData; 
 
 ThreadPoolTask(Object tasks) { 
  this.threadPoolTaskData = tasks; 
 } 
 
 public void run() { 
  System.out.println("start .." + threadPoolTaskData); 
  try { 
   // Sleep 2秒 模擬耗時操作 
   Thread.sleep(consumeTaskSleepTime); 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
  threadPoolTaskData = null; 
 } 
 
 public Object getTask() { 
  return this.threadPoolTaskData; 
 } 
} 
 
/** 
 * 
 * @Project : JPool 
 * @Package : com.sondon.mayi.jpool 
 * @Class : MyCallable 
 * @param <T> 
 */ 
class MyCallable<T> implements Callable<T>{ 
  
 @Override 
 public T call() throws Exception { 
   System.out.println("開始執(zhí)行Callable"); 
   return (T) "測試callable接口"; 
  } 
}