Java：线程池

1. 线程池的概念：

线程池就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。

2、线程池的工作机制

• 在线程池的编程模式下，任务是提交给整个线程池，而不是 直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
• 一个任务执行完成,再从任务队列中取最前面的任务开始执行
• 如果队列中没有等待进程,线程池的这个资源处于等待状态
• 当一个新任务需要运行时,如果此时线程池中还有空闲线程时,可以直接开始运行，否则需要进入等待队列

3、使用线程池的原因

• 减少了创建和销毁线程的次数,因为线程池中的每个线程都可以被重复使用
• 可以根据系统的承受能力,调整线程池中的线程数量,防止因为消耗过多的内存,导致服务器死机
  (每个线程需要大概1MB内存,线程开的越多,消耗内存越大,最后导致死机)

4、线程池的使用

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors。

ExecutorService：真正的线程池接口。
常见子类：ThreadPoolExecutor

• void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行Runnable
• Future submit(Callable task)：执行任务，有返回值，一般又来执行Callable
• void shutdown() ：关闭连接池
• Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
• Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
• Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
• Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
• Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。

5、几种常见线程池

（1）可缓存线程池：如果线程池长度超过处理需要,可以灵活回收空闲线程，若没有可以回收的,则新建线程,线程池规模不存在限制,数量不固定。

public class NewCachedThreadPoolTest {
	public static void main(String[] args) {
		ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
		for (int i = 0; i < 10; i++) {
			// 执行任务,传入了Runnable接口的匿名内部类,或者是它的实现类对象
			cachedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
						try {
							Thread.sleep(1000);
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
						System.out.println(Thread.currentThread().getName());
				}
			});
		}
		// 关闭线程池
		cachedThreadPool.shutdown();
	}
}

（2）固定长度的线程池：可控制线程最大并发数，超出此数量的线程,会在队列中等待。

public class NewFixedThreadPoolTest {
	public static void main(String[] args) {
		ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
		for (int i = 0; i < 10; i++) {
			// 执行任务,传入了Runnable的匿名内部类,也可以是实现类对象
			fixedThreadPool.execute(new Runnable() {
				@Override
				public void run() {
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println(Thread.currentThread().getName());
				}
			});
		}
		// 关闭线程池
		fixedThreadPool.shutdown();
	}
}

（3）固定长度线程池,支持定时及周期性执行任务。

	/**
	 * 延迟执行
	 */
	public static void test1() {
		// 创建池子,并指定数量5
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		// 1 执行的任务, 2 延迟时间 , 3 延迟时间的单位
		scheduledThreadPool.schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println("延迟3秒再执行");
			}
		}, 3, TimeUnit.SECONDS);

		// 关闭池子 
		scheduledThreadPool.shutdown();
	}

	/**
	 * 延迟并间隔执行
	 */
	public static void test2() {
		// 创建池子,并指定数量5
		ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
		// 执行
		// 1 执行的任务, 2 延迟时间 , 3, 时间间隔 , 4 延迟时间的单位
		scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
			@Override
			public void run() {
				System.out.println("延迟5秒再执行,并且每2秒执行一次");
			}
		}, 5, 2, TimeUnit.SECONDS);
	}

（4）单线程线程池：只创建一个线程,如果这个线程因为异常结束,那么会有一个新的线程来替代他。该线程保证所有的任务的执行顺序,按照任务的提交顺序执行,谁先来谁先执行，适用于一个一个任务执行的情况。

public class NewSingletThreadExecutor {
	public static void main(String[] args) {
		// 创建池子
		ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
		// 一次性创建10个请求
		for (int i = 0; i < 10; i++) {
			final int index = i;
			System.out.println("创建 "+i+" 次");
			// 只能依次执行
			singleThreadExecutor.execute(new Runnable() {
				@Override
				public void run() {
					try {
						Thread.sleep(1000);
						System.out.println(Thread.currentThread().getName()+" : "+index);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			});
		}
	}
}