Java线程池

1.     线程池

为什么需要线程池，其实线程池和数据库连接池一样，都是为了节省线程的创建和关闭的时间。在并发的线程数量很多，并且每个线程都是执行一个时间很短的任务就结束了，的频繁创建线程就会大大降低系统的效率，因为频繁的创建和销毁线程需要时间。

 

Java中通过Executors提供四种线程池，分别为:

1.      newCachedThreadPool:创建一个可缓存线程池，如果线程池长度超过处理需求，可灵活回收空闲线程，如无回收，则创建线程。

2.      newFixedThreadPool:创建一个定长线程池，可控制线程最大并发数，超过的线程会在队列中等待。

3.      newScheduledThreadPool:创建一个定长线程池，支持定时及周期性任务执行。

newSingleThreadExecutor:创建一个单线程化的线程池，他只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO)执行。

(1) newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

package com.wpl.executors;

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

public class CachedThreadPool {
	
	public static void main(String[] args) {
		
		ExecutorService cached=Executors.newCachedThreadPool();
		for(int i=0;i<10;i++)
		{
			final int index=i;
			try {
				Thread.sleep(index*1000);
				
			} catch (Exception e) {
				e.printStackTrace();
			}
			
			
			cached.execute(new Runnable() {
				
				@Override
				public void run() {
					System.out.println(index);
					
				}
			});
			
		}

	}
	
}

(2) newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

package com.wpl.executors;

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

public class FixedThreadPool {

	public static void main(String[] args) {
		
		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) {
						
						e.printStackTrace();
					}
					
				}
			});
			
			
		}
		
	}
	
}

(3)  newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

package com.wpl.executors;

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

public class ScheduledThreadPool {

	public static void main(String[] args) {
		
		ExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(5);
		for(int i=0;i<10;i++)
		{
			scheduleThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("delay 3 seconds!");
					try {
						Thread.sleep(3000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}

		
		
	}
	
}

(4) newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

package com.wpl.executors;

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

public class SingleThreadExecutor {

	public static void main(String[] args) {
		
		ExecutorService singleThreadExecutor=Executors.newSingleThreadExecutor();
		for(int i=0;i<10;i++)
		{
			final int index=i;
			singleThreadExecutor.execute(new Runnable() {
				
				@Override
				public void run() {
					
					try {
						Thread.sleep(2000);
						System.out.println(index);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}
			});
			
		}	
	}
	
}