线程池

public class a {
public void A() {
// 创建一个线程池
ExecutorService executorService = Executors.newFixedThreadPool(10);
executorService.execute(new MyRunnable());
}

class MyRunnable implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
}
}
}

public class ThreadManager {

private static ThreadProxyPool threadProxyPool;
private static Object object = new Object();

public static ThreadProxyPool getThreadProxyPool() {
synchronized (object) {
if (threadProxyPool == null) {
threadProxyPool = new ThreadProxyPool(10, 10, 5L);
}
return threadProxyPool;
}
}

public static class ThreadProxyPool {
private ThreadPoolExecutor threadPoolExecutor;
private int corePoolSize;
private int maximumPoolSize;
private long keepAliveTime;

public ThreadProxyPool(int corePoolSize, int maximumPoolSize, long keepAliveTime) {
this.corePoolSize = corePoolSize;
this.maximumPoolSize = maximumPoolSize;
this.keepAliveTime = keepAliveTime;
}

public void execute(Runnable runnable) {
if (runnable == null) {
return;
}
if (threadPoolExecutor == null || threadPoolExecutor.isShutdown()) {
threadPoolExecutor = new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), Executors.defaultThreadFactory(),
new AbortPolicy());
}

threadPoolExecutor.execute(runnable);
}

public void cancel(Runnable runnable) {
if (runnable != null && !threadPoolExecutor.isShutdown()) {
threadPoolExecutor.getQueue().remove(runnable);
}
}
}

}