java 线程池的使用

java 在处理大批量的任务时可以通过线程池的方式进行处理，jdk自带线程池使用。

 CachedThreadPool线程池的核心线程数默认为0，最大线程数量几乎无限制  适合高并发，短任务
 FixedThreadPool线程数量固定，可以更好的控制并发量，任务过多可能会造成任务队列堆积，甚至耗尽系统资源 适合稳定并发，长任务
ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)可以定义线程数，最大线程数，空闲时间，线程创建工厂，阻塞队列等，

package test;

import java.util.concurrent.ArrayBlockingQueue;
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;

/**
 * CachedThreadPool线程池的核心线程数默认为0，最大线程数量几乎无限制  适合高并发，短任务
 * FixedThreadPool线程数量固定，可以更好的控制并发量，任务过多可能会造成任务队列堆积，甚至耗尽系统资源 适合稳定并发，长任务
 * ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler)
 * 可以定义线程数，最大线程数，空闲时间，阻塞队列等，
 * 
 * 
 * 
 */
public class ThreadPoolTest {

	public static void main(String[] args) {
		//CachedPoolTest();
		//FixedThreadPoolTest();
		ThreadPoolExecutorTest();
		
	}
	private static void ThreadPoolExecutorTest() {
		/**
		 * 如果核心线程池已经满了，且工作队列ArrayBlockingQueue未满，则不会自动创建新的线程。
		 * 只有 核心线程池满了，工作队列也满了，才会去创建新的线程。
		 * 虽然线程数没有达到maximumPoolSize 线程池也不会无限制的创建线程，系统cpu资源紧张内存紧张则不会创建新线程
		 */
		ExecutorService executorService = new ThreadPoolExecutor(10, 100, 10, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(100),new RejectedExecutionHandler() {
			@Override
			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
				System.out.println("reject "+r.toString());
			}
		} );
//创建任务添加到队列
		for (int i = 0; i < 230; i++) {
			final int taskid = i+1;
			Runnable task = new Runnable() {
				@Override
				public void run() {
						double d = 1.0/(taskid-2);
						System.err.println("Executing task "+ taskid);
						try {
							TimeUnit.SECONDS.sleep(1);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						Thread.currentThread().interrupt();
				}
			};
//提交任务到线程池
			executorService.submit(task);
		}
		
	}
	
	
	private static void FixedThreadPoolTest() {
		ExecutorService executorService = Executors.newFixedThreadPool(10);
//创建任务添加到队列
		for (int i = 0; i < 50; i++) {
			final int taskid = i+1;
			Runnable task = new Runnable() {
				@Override
				public void run() {
						double d = 1.0/(taskid-2);
						System.err.println(d);
						System.err.println("Executing task "+ taskid);
						try {
							TimeUnit.SECONDS.sleep(1);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						Thread.currentThread().interrupt();
				}
			};
//提交任务到线程池
			executorService.submit(task);
			
		}
		executorService.shutdown();
	}
	private static void CachedPoolTest() {
		ExecutorService executorService = Executors.newCachedThreadPool();
//创建任务添加到队列
		for (int i = 0; i < 50000; i++) {
			final int taskid = i+1;
			Runnable task = new Runnable() {
				@Override
				public void run() {
						double d = 1.0/(taskid-2);
						System.err.println(d);
						System.err.println("Executing task "+ taskid);
						try {
							TimeUnit.SECONDS.sleep(1);
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						Thread.currentThread().interrupt();
				}
			};
//提交任务到线程池
			executorService.submit(task);
			
		}
		executorService.shutdown();
	}
}