Java线程池

线程池的概念：

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

线程池的工作机制

1、在线程池的编程模式下，任务是提交给整个线程池，而不是直接提交给某个线程，线程池在拿到任务后，就在内部寻找是否有空闲的线程，如果有，则将任务交给某个空闲的线程。
2、一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务。

使用线程池的原因：

多线程运行时间，系统不断的启动和关闭新线程，成本非常高，会过渡消耗系统资源，以及过渡切换线程的危险，从而可能导致系统资源的崩溃。这时，线程池就是最好的选择了。

四种常见的线程池详解

线程池的返回值ExecutorService简介：

ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程

具体的4种常用的线程池实现：（返回值都是ExecutorService）

1、Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，缓存型池子通常用于执行一些生存期很短的异步型任务
代码案例

public static void main(String[] args) throws InterruptedException {
 	//实例化线程池
 	ExecutorService executorService = Executors.newCachedThreadPool();
 	//循环
 	for (int i = 0; i < 10; i++) {
		 //睡一秒
 		Thread.sleep(1000);
 		//给线程池分配线程任务
 		executorService.execute(new Runnable() {
 			@Override
 			public void run() {
 			//输入当前线程的名称
 				String name = Thread.currentThread().getName();
 				System.out.println(name);
			 }
	 	});
	 }
 }

线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程

2、Executors.newFixedThreadPool(int n)：这个实例会复用 固定数量的线程 处理一个 共享的无边界队列 。如果当所有线程都是活动时，有多余的任务被提交过来，那么它会一直在队列中等待直到有线程可用。如果任何线程在执行过程中因为错误而中止，新的线程会替代它的位置来执行后续的任务。

public static void main(String[] args) throws InterruptedException {
     //定长线程池类
     ExecutorService executorService = Executors.newFixedThreadPool(3);
     //循环
     for (int i = 0; i < 10; i++) {
         //执行一个线程
         executorService.execute(new Runnable() {
             @Override
             public void run() {
             //输出当前线程名称
                 System.out.println(Thread.currentThread().getName());
                 try {
                 //睡两秒
                     Thread.sleep(2000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
         });
     }
 }

因为线程池大小为3，每个任务输出打印结果后sleep 2秒，所以每两秒打印3个结果。

3、 Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行

延迟执行示例代码：

public static void main(String[] args) throws InterruptedException {
     //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
     ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
     //延迟1秒执行
     scheduledThreadPool.schedule(new Runnable() {
         public void run() {
             System.out.println("延迟1秒执行");
         }
     }, 1, TimeUnit.SECONDS);
 }

定期执行示例代码：

public static void main(String[] args) throws InterruptedException {
     //创建一个定长线程池，支持定时及周期性任务执行——定期执行
     ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
     //延迟1秒后每3秒执行一次
     scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
         public void run() {
             System.out.println("延迟1秒后每3秒执行一次");
         }
     }, 1, 3, TimeUnit.SECONDS);
 }

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

public static void main(String[] args) throws InterruptedException {
     //创建一个单线程化的线程池
     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(Thread.currentThread().getName() + "正在被执行,打印的值是:" + index);
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
     	});
     }
 }