jdk 自带线程池 jdk自带线程池实例详解

public class FixedThreadPool { 
  public static void main(String[] args) { 
    ExecutorService pool = Executors.newFixedThreadPool(5);// 创建一个固定大小为5的线程池 
    for (int i = 0; i < 10; i++) { 
      pool.submit(new MyThread()); 
    } 
    pool.shutdown(); 
  } 
} 
public class MyThread extends Thread { 
  @Override 
  public void run() { 
    System.out.println(Thread.currentThread().getName() + "正在执行。。。"); 
  } 
} 

public class SingleThreadPool { 
  public static void main(String[] args) {  
    ExecutorService pool=Executors.newSingleThreadExecutor();//创建一个单线程池  
    for(int i=0;i<100;i++){  
      pool.submit(new MyThread());  
    }  
    pool.shutdown();  
  } 
} 

public class ScheduledThreadPool { 
  public static void main(String[] args) {  
    ScheduledExecutorService pool=Executors.newScheduledThreadPool(6);  
    for(int i=0;i<10000;i++){  
      pool.submit(new MyThread());  
    }  
      
    pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);  
    pool.schedule(new MyThread(), 1000, TimeUnit.MILLISECONDS);  
    pool.shutdown();  
  }  
} 

public class CachedThreadPool { 
  public static void main(String[] args) {  
    ExecutorService pool=Executors.newCachedThreadPool();  
    for(int i=0;i<100;i++){  
      pool.submit(new MyThread());  
    }  
    pool.shutdown();  
  }  
} 

public class Executors { 
  public static ExecutorService newFixedThreadPool(int nThreads) { 
    return new ThreadPoolExecutor(nThreads, nThreads, 
                   0L, TimeUnit.MILLISECONDS, 
                   new LinkedBlockingQueue<Runnable>()); 
} 
  public static ExecutorService newSingleThreadExecutor() { 
    return new FinalizableDelegatedExecutorService 
      (new ThreadPoolExecutor(1, 1, 
                  0L, TimeUnit.MILLISECONDS, 
                  new LinkedBlockingQueue<Runnable>())); 
  } 
} 

public ThreadPoolExecutor(int corePoolSize, 
               int maximumPoolSize, 
               long keepAliveTime, 
               TimeUnit unit, 
               BlockingQueue<Runnable> workQueue, 
               ThreadFactory threadFactory, 
               RejectedExecutionHandler handler) { 
    if (corePoolSize < 0 || 
      maximumPoolSize <= 0 || 
      maximumPoolSize < corePoolSize || 
      keepAliveTime < 0) 
      throw new IllegalArgumentException(); 
    if (workQueue == null || threadFactory == null || handler == null) 
      throw new NullPointerException(); 
    this.corePoolSize = corePoolSize; 
    this.maximumPoolSize = maximumPoolSize; 
    this.workQueue = workQueue; 
    this.keepAliveTime = unit.toNanos(keepAliveTime); 
    this.threadFactory = threadFactory; 
    this.handler = handler; 
  } 

public enum TimeUnit { 
  NANOSECONDS { 
    // keepAliveTime以纳秒为单位 
  }, 
  MICROSECONDS { 
    // keepAliveTime以微秒为单位 
  }, 
  MILLISECONDS { 
    // keepAliveTime以毫秒为单位 
  }, 
  SECONDS { 
    // keepAliveTime以秒为单位 
  }, 
  MINUTES { 
    // keepAliveTime以分钟为单位 
  }, 
  HOURS { 
    // keepAliveTime以小时为单位 
  }, 
  DAYS { 
    // keepAliveTime以天为单位 
  }; 

private boolean addIfUnderCorePoolSize(Runnable firstTask) { 
    Thread t = null; 
    final ReentrantLock mainLock = this.mainLock; 
    mainLock.lock(); 
    try { 
      if (poolSize < corePoolSize && runState == RUNNING) 
        t = addThread(firstTask); 
    } finally { 
      mainLock.unlock(); 
    } 
    if (t == null) 
      return false; 
    t.start(); 
    return true; 
} 

private boolean addIfUnderMaximumPoolSize(Runnable firstTask) { 
    Thread t = null; 
    final ReentrantLock mainLock = this.mainLock; 
    mainLock.lock(); 
    try { 
      if (poolSize < maximumPoolSize && runState == RUNNING) 
        t = addThread(firstTask); 
    } finally { 
      mainLock.unlock(); 
    } 
    if (t == null) 
      return false; 
    t.start(); 
    return true; 
} 

public ArrayBlockingQueue(int capacity) { 
    this(capacity, false); 
  } 
  public ArrayBlockingQueue(int capacity, boolean fair) { 
    if (capacity <= 0) 
      throw new IllegalArgumentException(); 
    this.items = (E[]) new Object[capacity]; 
    lock = new ReentrantLock(fair); 
    notEmpty = lock.newCondition(); 
    notFull = lock.newCondition(); 
} 
  public ArrayBlockingQueue(int capacity, boolean fair, 
               Collection<? extends E> c) { 
    this(capacity, fair); 
    if (capacity < c.size()) 
      throw new IllegalArgumentException(); 
    for (Iterator<? extends E> it = c.iterator(); it.hasNext();) 
      add(it.next()); 
  } 

public static class AbortPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates an <tt>AbortPolicy</tt>. 
     */ 
    public AbortPolicy() { } 
    /** 
     * Always throws RejectedExecutionException. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     * @throws RejectedExecutionException always. 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      throw new RejectedExecutionException(); //抛异常 
    } 
  } 

public static class DiscardPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>DiscardPolicy</tt>. 
     */ 
    public DiscardPolicy() { } 
    /** 
     * Does nothing, which has the effect of discarding task r. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
    } // 直接拒绝，但不做任何操作 
  } 

public static class CallerRunsPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>CallerRunsPolicy</tt>. 
     */ 
    public CallerRunsPolicy() { } 
    /** 
     * Executes task r in the caller's thread, unless the executor 
     * has been shut down, in which case the task is discarded. 
     * @param r the runnable task requested to be executed 
     * @param e the executor attempting to execute this task 
     */ 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      if (!e.isShutdown()) { 
        r.run(); // 直接执行任务 
      } 
    } 
  } 

public static class DiscardOldestPolicy implements RejectedExecutionHandler { 
    /** 
     * Creates a <tt>DiscardOldestPolicy</tt> for the given executor. 
     */ 
    public DiscardOldestPolicy() { } 
    public void rejectedExecution(Runnable r, ThreadPoolExecutor e) { 
      if (!e.isShutdown()) { 
        e.getQueue().poll(); // 丢弃队列中的第一个任务 
        e.execute(r); // 执行新任务 
      } 
    } 
}