在程序中，有很多地方并不需要进行同步操作。 比如，不论成功与否都要进行的操作、缓存与数据库的操作。 使用线程的最大的一个特点就是，两个事务他们的执行顺序没有前后之分 那么我们就可以把这些逻辑放在线程中去执行。 让其CPU空闲的时候处理了这些线程，这样就大大的提高了系统的响应时间。
new Thread(){
@Override
public void run() {
super.run();
}
}.start();
当然我们每次去手动的创建线程，这样效率太低啦。
在Java中给我们提供了4中线程池。
1. 线程池的返回值ExecutorService简介：
ExecutorService是Java提供的用于管理线程池的类。该类的两个作用：控制线程数量和重用线程。
2. 具体的4种常用的线程池实现如下：（返回值都是ExecutorService）
2.1 Executors.newCacheThreadPool()：可缓存线程池，先查看池中有没有以前建立的线程，如果有，就直接使用。如果没有，就建一个新的线程加入池中，
缓存型池子通常用于执行一些生存期很短的异步型任务。线程池为无限大，当执行当前任务时上一个任务已经完成，会复用执行上一个任务的线程，而不用每次新建线程
1 package com.study.test;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5
6 public class ThreadPoolExecutorTest {
7 public static void main(String[] args) {
8 //创建一个可缓存线程池
9 ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
10 for (int i = 0; i < 10; i++) {
11 try {
12 //sleep可明显看到使用的是线程池里面以前的线程，没有创建新的线程
13 Thread.sleep(1000);
14 } catch (InterruptedException e) {
15 e.printStackTrace();
16 }
17 cachedThreadPool.execute(new Runnable() {
18 public void run() {
19 //打印正在执行的缓存线程信息
20 System.out.println(Thread.currentThread().getName()+"正在被执行");
21 }
22 });
23 }
24 }
25 }
2.2 Executors.newFixedThreadPool(int n)：创建一个可重用固定个数的线程池，以共享的*队列方式来运行这些线程。
1 package com.study.test;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5
6 public class ThreadPoolExecutorTest {
7 public static void main(String[] args) {
8 //创建一个可重用固定个数的线程池
9 ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
10 for (int i = 0; i < 10; i++) {
11 fixedThreadPool.execute(new Runnable() {
12 public void run() {
13 try {
14 //打印正在执行的缓存线程信息
15 System.out.println(Thread.currentThread().getName()+"正在被执行");
16 Thread.sleep(2000);
17 } catch (InterruptedException e) {
18 e.printStackTrace();
19 }
20 }
21 });
22 }
23 }
24 }
2.3 Executors.newScheduledThreadPool(int n)：创建一个定长线程池，支持定时及周期性任务执行。
1 package com.study.test;
2
3 import java.util.concurrent.Executors;
4 import java.util.concurrent.ScheduledExecutorService;
5 import java.util.concurrent.TimeUnit;
6
7 public class ThreadPoolExecutorTest {
8 public static void main(String[] args) {
9 //创建一个定长线程池，支持定时及周期性任务执行——延迟执行
10 ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
11 //延迟1秒执行
12 scheduledThreadPool.schedule(new Runnable() {
13 public void run() {
14 System.out.println("延迟1秒执行");
15 }
16 }, 1, TimeUnit.SECONDS);
17 }
18 }
2.4 Executors.newSingleThreadExecutor()：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1 package com.study.test;
2
3 import java.util.concurrent.ExecutorService;
4 import java.util.concurrent.Executors;
5
6 public class TestThreadPoolExecutor {
7 public static void main(String[] args) {
8 //创建一个单线程化的线程池
9 ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
10 for (int i = 0; i < 10; i++) {
11 final int index = i;
12 singleThreadExecutor.execute(new Runnable() {
13 public void run() {
14 try {
15 //结果依次输出，相当于顺序执行各个任务
16 System.out.println(Thread.currentThread().getName()+"正在被执行,打印的值是:"+index);
17 Thread.sleep(1000);
18 } catch (InterruptedException e) {
19 e.printStackTrace();
20 }
21 }
22 });
23 }
24 }
25 }
下面提供一个常用了缓存线程池工具类。
1 /**
2 * 〈线程池工具类〉<br>
3 * TODO(线程池工具类)
4 *
5 * @author han.sun
6 * @version 1.0.0
7 * @since 2019/3/7 15:34
8 */
9 public class ThreadPoolUtils {
10
11 private ThreadPoolUtils() {
12 }
13
14 private static ExecutorService executorService;
15 private static final PictureUtils PIC = PictureUtils.getInstance();
16
17 static {
18 executorService = Executors.newCachedThreadPool();
19 }
20
21 public static ExecutorService getThreadPool() {
22 return executorService;
23 }
24
25 public static void writeImage(final HttpServletRequest request, final String imgId, final String base64) {
26 ExecutorService threadPool = ThreadPoolUtils.getThreadPool();
27 threadPool.execute(new Runnable() {
28 @Override
29 public void run() {
30 try {
31 PIC.writeImage(request, base64, imgId);
32 } catch (Exception e) {
33 e.printStackTrace();
34 }
35 }
36 });
37 }
38
39
40 }
参考文献：https://blog.csdn.net/hnd978142833/article/details/80253784