创建线程池的四种方式

创建线程池的方式有四种方式，分别是newCatchThreadPool、newFixedThreadPool、newScheduleThreadPool、newSingleThreadExecutor。以下四种方式的案例实现

1.newCatchTreadPool

特点：可以创建一个可以缓存的线程池

public static void newCachedThreadPool() {
		// 创建一个课缓存的线程池，如果线程池长度超过处理需要，可以灵活回收空闲线程，没回收的话就新建线程
		ExecutorService threadpoolService = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			final int index = i;
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				// TODO: handle exception
				e.printStackTrace();
			}
			threadpoolService.execute(new Runnable() {

				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println(index);
				}
			});
		}
	}

2.newFixedThread

特点：可以创建一个定长的线程池，可控制最大并发数，超出的线程进行队列等待

public static void newFixedThreadPool(){
		//运行的效果就是，3个数字三个数字进行输出
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			 final int index = i;  
	            fixedThreadPool.execute(new Runnable() {  
	                public void run() {  
	                    try {  
	                    	System.out.println(Thread.currentThread()+","+index);
	                        Thread.sleep(1000);
	                    } catch (InterruptedException e) {  
	                        e.printStackTrace();  
	                    }  
	                }
	            });
		}
	}

3.newScheduleThreadPool

特点：可以创建定长的、支持定时任务，周期任务执行

public static void newScheduledThreadPool() {
		 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		 for (int i = 0; i < 10; i++) {
			final int index = i;
			scheduledThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					try {
						Thread.sleep(1000);
						System.out.println(Thread.currentThread() + ","+index);
					} catch (Exception e) {
						// TODO: handle exception
						e.printStackTrace();
					}
					System.out.println("delay 3 seconds---->"+index);
				}
			});
		}
	}

4.newsingleExecutor

特点：创建一个单线程池，它只会用唯一的工作线程来执行任务，保证保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

public static void newSingleThreadExecutor() {
		ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
		for (int i = 0; i < 10; i++) {
			final int index = i;
			singleThreadExecutor.execute(new Runnable() {
				public void run() {
					try {
						System.out.println(index);
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
	}