线程池的理解

package com.test.thread;

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.RejectedExecutionHandler;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestQ {

public static void main(String[] args) throws InterruptedException {    /**     * LinkedBlockingQueue 链表队列 Node head,tail;     * ArrayBlockingQueue 有界队列      * PriorityBlockingQueue 优先级队列 先获取优先级别高的     * SynchronousQueue  其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有     *      *      * 工作线程     * RejectedExecutionHandler //如果不能再放了 可以放到handler中的     *  四种策略 addWorker 失败时候     *     AbortPolicy  //抛出异常     *     CallerRunsPolicy //执行run     *     DiscardOldestPolicy //会继续丢进队列中，可能导致stack溢出 需要注意     *     DiscardPolicy  //不做任何处理的不执行     *          *          *     ExecutorService  service = Executors.newCachedThreadPool();            service.submit(); //submit提交的任何最后都会被转换为callable             //runnable通过封装后转换为callable             public FutureTask(Runnable runnable, V result) {                sync = new Sync(Executors.callable(runnable, result));                //通过RunnableAdapter 适配器模式            }            public FutureTask(Callable<V> callable) {                if (callable == null)                    throw new NullPointerException();                sync = new Sync(callable);            }     */    final ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(2);    TestQ t = new TestQ();

// t.testArrayQ(queue);
t.testPool(queue);
}

public void testPool(BlockingQueue<Runnable> queue){    /**     * public ThreadPoolExecutor(int corePoolSize,                          int maximumPoolSize,                          long keepAliveTime,                          TimeUnit unit,                          BlockingQueue<Runnable> workQueue,                          RejectedExecutionHandler handler) {    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,         Executors.defaultThreadFactory(), handler);}     */    RejectedEHandler handle = new RejectedEHandler();    ThreadPoolExecutor executor = new ThreadPoolExecutor(10,10,10L,TimeUnit.SECONDS,queue,handle);    for (int i = 0; i < 100; i++) {        executor.execute(new Runnable() {            @Override            public void run() {                System.out.println(Thread.currentThread().getId()+"---running");            }        });    }}public void testArrayQ(BlockingQueue<String> queue){    for (int j = 0; j < 10000; j++) {        Put put = new Put(queue,new Random().nextInt(10000)+"");        new Thread(put).start();    }    for (int j = 0; j < 500; j++) {        Take take = new Take(queue);        new Thread(take).start();    }    }}

class Take implements Runnable{
private BlockingQueue queue;
public Take(BlockingQueue queue){
this.queue = queue;
}
@Override
public void run() {
try {
System.out.println(“take:”+queue.take());
} catch (InterruptedException e) {
e.printStackTrace();
}
}

}

class Put implements Runnable{
private BlockingQueue queue;
private String msg;

public Put(BlockingQueue<String> queue,String msg){    this.queue = queue;    this.msg = msg;}@Overridepublic void run() {    try {        queue.put(msg);        System.out.println("put msg:"+msg);    } catch (InterruptedException e) {        e.printStackTrace();    }}

}
class RejectedEHandler implements RejectedExecutionHandler{
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.out.println(“handler running—>”+Thread.currentThread().getId());
if(!executor.isShutdown()){
executor.execute(r);
}
}

}