자바 스 레 드 탱크 의 테스트 와 분석

package cn.smallbug.jdk.concurrent.exe;

import java.io.Serializable;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.ThreadPoolExecutor.DiscardPolicy;
import java.util.concurrent.TimeUnit;

import org.junit.Before;
import org.junit.Test;

public class TestThreadPoolExecutor {

	private ThreadPoolExecutor pool = null;

	@Before
	public void before() {
		this.pool = new ThreadPoolExecutor(//
				/**
				 * corePoolSize（        ）：<br />
				 *             ，               ，
				 *                         ，                         。
				 *          prestartAllCoreThreads  ，                 。
				 */
				10,
				/**
				 * maximumPoolSize（       ）：<br />
				 *              。      ，                ，                。
				 *                             。
				 */
				20,
				/**
				 * keepAliveTime（        ）：<br />
				 *            ，       。
				 */
				1000,
				/**
				 * TimeUnit（           ）:<br />
				 *   ：<br />
				 * <ul>
				 * <li>    （DAYS）</li>
				 * <li>  （HOURS）</li>
				 * <li>  （MINUTES）</li>
				 * <li>  (MILLISECONDS)</li>
				 * <li>  (MICROSECONDS,       )</li>
				 * <li>   (NANOSECONDS,       )</li>
				 * </ul>
				 */
				TimeUnit.MILLISECONDS, //            1000ms，
				/**
				 * runnableTaskQueue（    ）：<br />
				 *                 。            :
				 * <ul>
				 * <li><b>ArrayBlockingQueue：</b>                ，    
				 * FIFO（    ）         。</li>
				 * <li><b>LinkedBlockingQueue：</b>             ，    FIFO （    ）
				 *     ，        ArrayBlockingQueue。      Executors.
				 * newFixedThreadPool()       。</li>
				 * <li><b>SynchronousQueue：</b>
				 *             。                     ，
				 *               ，        LinkedBlockingQueue，      Executors.
				 * newCachedThreadPool       。</li>
				 * <li><b>PriorityBlockingQueue：</b>              。</li>
				 * </ul>
				 */
				new ArrayBlockingQueue<Runnable>(100),
				/**
				 * ThreadFactory：<br />
				 *            ，                           ，Debug           。
				 */
				// new CreateThread(),
				/**
				 * RejectedExecutionHandler（    ）：<br />
				 *           ，           ，                  。
				 *           AbortPolicy，              。   JDK1.5       
				 * <ul>
				 * <li>CallerRunsPolicy：              。</li>
				 * <li>DiscardOldestPolicy：            ，       。</li>
				 * <li>DiscardPolicy：   ，   。</li>
				 * <li>                RejectedExecutionHandler       。
				 *                 。</li>
				 * </ul>
				 */
				new DiscardPolicy()//
		);
	}

	/**
	 *                execute      
	 * 
	 * @timestamp Mar 19, 2016 3:08:56 PM
	 */
	@Test
	public void testExecute() {
		pool.execute(new Runnable() {

			@Override
			public void run() {
				System.out.println(2 + 2);
			}

		});
	}

	/**
	 *                execute      
	 * 
	 * @timestamp Mar 19, 2016 3:11:21 PM
	 */
	@Test
	public void testSubmit() {
		int i = 100;
		while (i-- > 0) {
			pool.submit(//
					new Callable<Serializable>() {

						@Override
						public Serializable call() throws Exception {
							return 2 + 2;
						}
					}//
			);
		}
		Future<Serializable> result = pool.submit(//
				new Callable<Serializable>() {

					@Override
					public Serializable call() throws Exception {
						return 2 + 2;
					}
				}//
		);
		Serializable s = null;
		try {
			s = (int) result.get();
		} catch (InterruptedException e) {
			//       
			e.printStackTrace();
		} catch (ExecutionException e) {
			//           
			e.printStackTrace();
		} finally {
			stastic(pool);
			/**
			 * 1、          SHUTDOWN  <br />
			 * 2、                 
			 */
			pool.shutdown();
			/**
			 * 1、          STOP<br />
			 * 2、           <br />
			 * 3、       interrupt       （                 ）<br />
			 * 4、           
			 */
			// pool.shutdownNow();
			/**
			 *                  ，isShutdown      true<br />
			 *            ,          ，    isTerminaed     true<br />
			 *     shutdown      ，           ，     shutdownNow
			 */
		}
		System.out.println(s);

	}

	/**
	 *                <br />
	 * beforeExecute <br />
	 * afterExecute <br />
	 * terminated <br />
	 *   ，        ，                。            ，              。
	 * 
	 * @timestamp Mar 19, 2016 3:37:29 PM
	 * @param pool2
	 */
	private void stastic(ThreadPoolExecutor pool) {
		System.out.println("current cpu num -> " + Runtime.getRuntime().availableProcessors());
		System.out.println("             -> " + pool.getTaskCount());
		System.out.println("                 。     taskCount -> " + pool.getCompletedTaskCount());
		System.out.println("                -> " + pool.getLargestPoolSize());
		System.out.println("        。          ，           ，           -> " + pool.getPoolSize());
		System.out.println("         -> " + pool.getActiveCount());
	}

	/**
	 *         
	 * 
	 * @timestamp Mar 19, 2016 3:01:24 PM
	 * @author smallbug
	 */
	class CreateThread implements ThreadFactory {
		@Override
		public Thread newThread(Runnable r) {
			return new Thread() {
				@Override
				public void run() {
					System.out.println(1 + 1);
				}
			};
		}

	}
}

           
 
 

우선 스 레 드 탱크 는 기본 스 레 드 탱크 가 가득 찼 는 지 판단 합 니까?가득 차지 않 았 습 니 다. 작업 스 레 드 를 만들어 서 작업 을 수행 합 니 다.가득 차 면 다음 절차 로 들어간다.

그 다음 에 스 레 드 탱크 는 작업 대기 열 이 가득 찼 는 지 판단 합 니까?가득 차지 않 으 면 새로 제출 한 작업 을 작업 대기 열 에 저장 합 니 다.가득 차 면 다음 절차 로 들어간다.

마지막 스 레 드 탱크 는 전체 스 레 드 탱크 가 가득 찼 는 지 판단 합 니까?가득 차지 않 으 면 새로운 작업 스 레 드 를 만들어 임 무 를 수행 하고 가득 차 면 포화 전략 에 맡 겨 이 임 무 를 처리 합 니 다.

참고 블 로그: 동시 다발 (3) 자바 스 레 드 탱크 의 분석 과 사용 에 대해 이야기 합 니 다.