JAVA线程池

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;


public class T {
	public static void main(String[] args) {
		//cachedThreadPool();
		//fixedThreadPool();
		//scheduledThreadPool();
		singleThreadExecutor();
	}
	
	/**
	 * newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
	 */
	private static void cachedThreadPool(){
		ExecutorService cacheExecutorService = Executors.newCachedThreadPool();
		
		for (int i = 0; i < 10; i++) {
			final int index = i;
			
			try {
				Thread.sleep(index * 1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			
			cacheExecutorService.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(index);
				}
			});
		}
	}
	
	/**
	 * newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
	 */
	private static void fixedThreadPool () {
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		
		for (int i = 0; i < 10; i++) {
			final int index = i;
			
			fixedThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					try {
						System.out.println(index);
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}
	
	/**
	 * 创建一个定长线程池，支持定时及周期性任务执行。
	 */
	private static void scheduledThreadPool() {
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		
		//延迟3s执行
		scheduledThreadPool.schedule(new Runnable() {
			
			@Override
			public void run() {
				System.out.println("delay 3 seconds");
				
			}
		}, 3, TimeUnit.SECONDS);
		
		
		//表示延迟1秒后每3秒执行一次。
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
			 
		    @Override
		    public void run() {
		        System.out.println("delay 1 seconds, and excute every 3 seconds");
		    }
		}, 1, 3, TimeUnit.SECONDS);
	}
	
	
	/**
	 * newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
	 */
	private static void singleThreadExecutor() {
		ExecutorService singleThreadExecutorService  =Executors.newSingleThreadExecutor();
		
		for (int i = 0; i < 10; i++) {
			final int index  = i;
			
			singleThreadExecutorService.execute(new Runnable() {
				
				@Override
				public void run() {
					try {
						System.out.println(index);
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
			});
		}
	}
	
}

转载于:https://my.oschina.net/wvliang/blog/396865