Java线程池的使用

在开发过程中，我们有时需要频繁创建多个线程进行运算的时候，每次都new出一个新的Thread对象并不能有效地利用资源，同时可能造成由于线程缺乏统一管理，无限制创建新线程，占用过多资源导致线程死锁问题。在这样的情况下我们就可以使用Java的线程池来管理、调度线程。

线程池的的优点在于三点：

一，能够复用存在的线程，减少创建、销毁线程的操作，减少进行对应操作的开销；

二、能够有效控制并发数量，提高系统资源利用率，避免过多资源竞争，避免拥堵；

三、提供定式执行、定期执行、单线程、并发数控制等。

Java提供的线程池有4种：newFixedThreadPool、newScheduledThradPool、newCachedThreadPool、newSingleThreadExecutor。

创建线程池，可以通过Executors的对应方法来实现：

newFixedThreadPool：创建一个指定长度的线程池，线程最大并发数量不超过线程池长度，如果超出则等待其他线程执行完毕。

public class ExecutorDemo {
	
	public static void main(String[] args) {
		ExecutorService executorService=Executors.newFixedThreadPool(4);
		for(int i=0;i<8;i++){
			executorService.submit(new ExecRunnalbe());
		}
		executorService.shutdown();
	}
	
}

Executors.newFixedThreadPool(4)创建了一个长度为4的线程池，并且返回一个ExecutorService对象，用于对线程池的调度，通过submit方法向线程池的线程注入Runnable或者Callable。执行之后的结果：

pool-1-thread-2正在运行
pool-1-thread-1正在运行
pool-1-thread-3正在运行
pool-1-thread-2正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-2正在运行
pool-1-thread-4正在运行

可以看出，就算当前线程需要执行的线程有8个，实际并发执行的线程只有4个，线程空闲之后会被复用。

newScheduledThread：创建一个指定长度的线程池，允许周期性执行，支持定时执行。

public class ExecutorDemo {
	public static void main(String[] args) {
		ScheduledExecutorService schedService=Executors.newScheduledThreadPool(3);
		schedService.scheduleAtFixedRate(new ExecRunnalbe(),1,3,TimeUnit.SECONDS);
	}
	
}

Executors.newScheduledThreadPool(3)方法创建了一个长度为3的线程池，并且返回一个ScheduledExecutorService对象，可以通过该对象注入任务Runnable。scheduleAtFixedRate方法声明如下：

•	scheduleAtFixedRate
•	ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
•	                                       long initialDelay,
•	                                       long period,
                                       TimeUnit unit)

可以看出，第一个参数为需要执行的Runnable，第二个参数是延迟时间，第三个参数为任务周期，第四个参数为时间单位。

运行之后程序会一直执行Runnable的任务，输出结果如下：

pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-2正在运行
pool-1-thread-2正在运行
pool-1-thread-3正在运行
pool-1-thread-1正在运行
pool-1-thread-2正在运行
pool-1-thread-3正在运行
....

上述代码中创建的线程池长度为3，所以线程池中始终最多只有三个线程运行，并且在执行shutdown方法之前（上面的代码没有），程序会周期性地执行线程。

newCacheThreadPool：创建一个可缓冲线程池，如果存在空闲的线程，复用空闲线程，否则创建新线程。

public class ExecutorDemo {

	
	public static void main(String[] args) {
		ExecutorService cacheService=Executors.newCachedThreadPool();
		for(int i=0;i<8;i++){
			if(i==6){
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			cacheService.submit(new ExecRunnalbe());
		}
		cacheService.shutdown();
		
	}
	
}

上述程序中，当i不等于6之前，由于不断需要新线程，所以程线程池会不断创建线程来满足需求，当i等于6时，由于主线程休眠1秒，子线程执行完毕之后空闲，休眠结束之后线程池中有空闲的线程则复用线程，故输出结果：

pool-1-thread-2正在运行
pool-1-thread-6正在运行
pool-1-thread-4正在运行
pool-1-thread-3正在运行
pool-1-thread-1正在运行
pool-1-thread-5正在运行
pool-1-thread-5正在运行
pool-1-thread-6正在运行

可以明显看出线程pool-1-thread-5和pool-1-thread-6被复用。

newSingleThreadExecutor：创建一个单线程的线程池，其保证任务按指定顺序执行。

public class ExecutorDemo {
	
	public static void main(String[] args) {
		ExecutorService executorService=Executors.newSingleThreadExecutor();
		for(int i=0;i<8;i++){
			executorService.submit(new ExecRunnalbe());
		}
		executorService.shutdown();  //关闭线程池
	}
	
}

输出结果：

pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行
pool-1-thread-1正在运行

可以看出线程池中始终只有唯一一个线程执行。

ExecRunnable类：

class ExecRunnalbe implements Runnable{
	
	@Override
	public void run(){
		System.out.println(Thread.currentThread().getName()+"正在运行");
	}
	
}