Java中的线程池

线程和进程的区别见另一篇博客。
关于java线程池，今年的秋招面试中遇到了这样的面试题：知道线程池吗？说说有哪些面试题？
在网上搜索了一些资料，找了一些这个问题的答案。

1. 实现多线程的三种方式

方式1：继承Thread类。

• 步骤

•  A:自定义类MyThread继承Thread类。
  

•  B:MyThread类里面重写run()?
   	为什么是run()方法呢?
  

不是类中的所有代码都需要被线程执行的。
而这个时候，为了区分哪些代码能够被线程执行，java提供了Thread类中的run()用来包含那些被线程执行的代码。

•  C:创建对象
  

•  D:启动线程
  

方式2：实现Runnable接口

• 步骤：

•  A:自定义类MyRunnable实现Runnable接口
  

•  B:重写run()方法
  

•  C:创建MyRunnable类的对象
  

•  D:创建Thread类的对象，并把C步骤的对象作为构造参数传递
  

方式3：线程池Executors类（带有s）

•  	A:创建一个线程池对象，控制要创建几个线程对象。
   	public static ExecutorService newFixedThreadPool(int nThreads)
  

•  B:这种线程池的线程可以执行：
   	可以执行Runnable对象或者Callable对象代表的线程
   	做一个类实现Runnable接口。
  

•  C:调用如下方法即可
   	Future<?> submit(Runnable task)
   	<T> Future<T> submit(Callable<T> task)
  

•  D:我就要结束，可以吗?
   	可以。
  

Callable:是带泛型的接口。
这里指定的泛型其实是call()方法的返回值类型。

面试题：run()和start()的区别?
run():仅仅是封装被线程执行的代码，直接调用是普通方法
start():首先启动了线程，然后再由jvm去调用该线程的run()方法。

2. 什么是线程池

线程池是一种多线程处理形式，处理过程中将任务添加队列，然后在创建线程后自动启动这些任务，每个线程都使用默认的堆栈大小，以默认的优先级运行，并处在多线程单元中，如果某个线程在托管代码中空闲，则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后辅助线程的数目永远不会超过最大值。超过最大值的线程可以排队，但他们要等到其他线程完成后才能启动。

java里面的线程池的顶级接口是Executor，Executor并不是一个线程池，而只是一个执行线程的工具，而真正的线程池是ExecutorService。

java中的有哪些线程池？
1.newCachedThreadPool 创建一个可缓存线程池程
2.newFixedThreadPool 创建一个定长线程池
3.newScheduledThreadPool 创建一个定长线程池
4.newSingleThreadExecutor 创建一个单线程化的线程池

2.1 newCachedThreadPool

newCachedThreadPool，是一种线程数量不定的线程池，并且其最大线程数为Integer.MAX_VALUE，这个数是很大的，一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。但是线程池中的空闲线程都有超时限制，这个超时时长是60秒，超过60秒闲置线程就会被回收。调用execute将重用以前构造的线程(如果线程可用)。这类线程池比较适合执行大量的耗时较少的任务，当整个线程池都处于闲置状态时，线程池中的线程都会超时被停止。

示例代码：

package test.sensen;

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

public class TestCachedThreadPool {
	public static void main(String[] args) {
		ExecutorService mCachedThreadPool = Executors.newCachedThreadPool();
		for(int i=0; i<7; i++) {
			final int index = i;
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			mCachedThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("第"+index+"个线程："+Thread.currentThread().getName());
				}
			});
		}
	}
}

从结果可以看到，在for循环中，执行第二个任务的时候第一个任务已经完成，会复用执行第一个任务的线程，不用每次新建线程。

2.2 newFixedThreadPool

创建一个指定工作线程数量的线程池，每当提交一个任务就创建一个工作线程，当线程 处于空闲状态时，它们并不会被回收，除非线程池被关闭了，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列（没有大小限制）中。由于newFixedThreadPool只有核心线程并且这些核心线程不会被回收，这样它更加快速底相应外界的请求。

示例代码

package test.sensen;

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

public class TestFixedThreadPool {
	public static void main(String[] args) {
		//设置最大工作线程为4个
		ExecutorService mFixedThreadPool = Executors.newFixedThreadPool(4);
		for(int i=0; i<7; i++) {
			final int index = i;
			mFixedThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("第"+index+"个线程："+Thread.currentThread().getName()+",当前时间："+System.currentTimeMillis());
					try {
						Thread.sleep(2000);
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}
}

因为只设置了4个工作线程，所以还有3个线程需要等到线程池中的线程能够使用（此处设置了休眠2000ms）时，再执行。

2.3 newScheduledThreadPool

创建一个线程池，它的核心线程数量是固定的，而非核心线程数是没有限制的，并且当非核心线程闲置时会被立即回收，它可安排给定延迟后运行命令或者定期地执行。这类线程池主要用于执行定时任务和具有固定周期的重复任务。

延迟执行示例代码：

package test.sensen;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestScheduledThreadPool {
	public static void main(String[] args) {
		//设置池中保存的核心线程为2个
		ScheduledExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(2);
		System.out.println("当前时间是："+System.currentTimeMillis());
		mScheduledThreadPool.schedule(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("当前时间是："+System.currentTimeMillis());
			}
		}, 4, TimeUnit.SECONDS);//设置延迟4秒后执行
	}
}

可以看到延迟了4秒。

定期执行示例代码

package test.sensen;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class TestScheduledThreadPool2 {
	public static void main(String[] args) {
		//设置池中保存的核心线程为2个
		ScheduledExecutorService mScheduledThreadPool = Executors.newScheduledThreadPool(2);
		System.out.println("当前时间是："+System.currentTimeMillis());
		mScheduledThreadPool.scheduleAtFixedRate(new Runnable() {
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("当前时间是："+System.currentTimeMillis());
			}
		}, 2, 3, TimeUnit.SECONDS);//设置延迟2秒后每3秒执行一次
	}
}

延迟2s后每3s执行一次，如果不强制中断，则会一直执行下去。

2.4 newSingleThreadExecutor

这类线程池内部只有一个核心线程，以无界队列方式来执行该线程，这使得这些任务之间不需要处理线程同步的问题，它确保所有的任务都在同一个线程中按顺序中执行，并且可以在任意给定的时间不会有多个线程是活动的。

示例代码

package test.sensen;

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

public class TestSingleThreadExecutor {
	public static void main(String[] args) {
		
		ExecutorService mSingleThreadPool = Executors.newSingleThreadExecutor();
		for(int i=0; i<7; i++) {
			final int num = i;
			mSingleThreadPool.execute(new Runnable() {
				
				@Override
				public void run() {
					// TODO Auto-generated method stub
					System.out.println("第"+num+"个线程"+Thread.currentThread().getName()+"，当前时间是："+System.currentTimeMillis());
					try {
						Thread.sleep(2000);//休眠2s
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			});
		}
	}
}

这7个线程是按队列顺序执行的。

3. 线程池的优点

1.重用线程池的线程，避免因为线程的创建和销毁锁带来的性能开销。

2.有效控制线程池的最大并发数，避免大量的线程之间因抢占系统资源而阻塞。

3.能够对线程进行简单的管理，并提供一下特定的操作如：可以提供定时、定期、单线程、并发数控制等功能。

参考资料：https://blog.csdn.net/qq_33453910/article/details/81413285