JAVA_线程池（一）

JAVA_线程池（1）
1 java.util.concurrent 线程池
  实现 一个可阻塞的 线程池,如果队列中的个数>20 则阻塞当前的 的put 线程 也就是  newFixedThreadPool.execute(Runnable);

import java.util.concurrent.ExecutorService;
	import java.util.concurrent.LinkedBlockingQueue;
	import java.util.concurrent.ThreadPoolExecutor;
	import java.util.concurrent.TimeUnit;

	public class ExecutorsEx {
	    /**
	     * @param threadSize
	     * @return
	     */
	    /*
	     * public static ExecutorService newFixedThreadPool(int
	     * threadSize) { return new ThreadPoolExecutor(threadSize,
	     * threadSize, 0L, TimeUnit.MILLISECONDS, new
	     * LinkedBlockingQueue<Runnable>(20)); }
	     */

	    /**
	     * @param threadSize
	     * @return
	     */
	    public static ExecutorService newFixedThreadPool(int threadSize) {
	        return new ThreadPoolExecutor(threadSize, threadSize, 0L, TimeUnit.MILLISECONDS,
	        		//20 is LinkedBlockingQueue size
	                new LinkedBlockingQueue<Runnable>(20) {

	                    private static final long serialVersionUID = -9028058603126367678L;

	                    @Override
	                    public boolean offer(Runnable e) {
	                        try {
	                            put(e);
	                            return true;
	                        } catch (InterruptedException ie) {
	                            Thread.currentThread().interrupt();
	                        }
	                        return false;
	                    }
	                });
	    }
	}

2 自己实现 Runnable 接口 实现需要线程执行的逻辑

 public static void main(String[] args) {
        ExecutorService newFixedThreadPool = ExecutorsEx.newFixedThreadPool(3);
        for (int i = 0; i <= 10; i++) {
            final int j = i;
            System.out.println("start to enqueue:" + j);
            newFixedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    System.out.println("start runnable:" + j);
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("end runnable:" + j);
                }
            });
            System.out.println("finish enqueue:" + j);
        }
        newFixedThreadPool.shutdown();
        try {
            newFixedThreadPool.awaitTermination(1, TimeUnit.HOURS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }