Java 多线程学习二（线程池）

一、为什么使用线程池？

前一篇博客里简单列举了几种实现线程的方法，在一个项目中，线程很多的情况下，每次都要去new线程，创建时间T1，线程存在时间T2，销毁时间T3，如果T1+T3>T2，这样就会造成内存消耗，而且不断创建新的线程，占用过多的系统资源，会导致死锁以及OOM。

使用线程池的好处

• 降低资源消耗：通过重复利用已创建的线程降低T1和T3造成的消耗
• 提高响应速度：当任务到达时，任务可以不用等到线程创建就立即执行
• 提高线程可管理性：线程池可以对线程进行统一分配，调优和监控，有效控制最大并发线程数，避免OOM和死锁等

线程的状态

• RUNNING：线程池能够接受新任务，以及对新添加的任务进行处理。
• shutdown()：线程池不可以接受新任务，但是可以对已添加的任务进行处理。
• STOP：线程池不接收新任务，不处理已添加的任务，并且会中断正在处理的任务。
• shutdownNow()：使线程池处于stop的状态
• TIDYING：当所有的任务已终止，ctl记录的"任务数量"为0，线程池会变为TIDYING状态。当线程池变为TIDYING状态时，会执行钩子函数terminated()。terminated()在ThreadPoolExecutor类中是空的，若用户想在线程池变为TIDYING时，进行相应的处理；可以通过重载terminated()函数来实现。
• TERMINATED：线程池彻底终止的状态。

二、创建线程池

1、通过Executor框架的工具类Executors来实现

（1）、newCachedThreadPool：创建可缓存线程池，最大线程数为Integer.MAX_VALUE，如果当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程，可以看到在示例代码中加不加延时，输出的线程名会不同，加1s延时，线程名只有1和2；加2s延时，线程名只有1；不加延时，线程名有1到10。示例代码如下

package ThreadPool;

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

public class CacheDemo {
    //传入Runnable接口
    private static Runnable getRunnable(final int i) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //打印当前线程名
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        };
    }

    public static void main(String[] args) {
        ExecutorService cacheThreadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            //这里加不加延时，输出会不同的哦，可以试下
            /*try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }*/
            cacheThreadPool.execute(getRunnable(i));
        }
        cacheThreadPool.shutdown();
    }
}

（2）、newFixedThreadPool：创建固定长度线程池，超出最大长度，线程在队列中等待，可以看到结果中只有三个线程循环执行。示例代码如下

package ThreadPool;

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

public class FixThreadPoolDemo {
    private static Runnable getRunnable(final int i) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        };
    }

    public static void main(String[] args) {
        //定长线程池，可控制最大并发数，超出线程在队列中等待
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            fixedThreadPool.execute(getRunnable(i));
        }
        fixedThreadPool.shutdown();
    }
}

（3）、newSingleThreadExecutor：唯一线程，在线程池中工作，不管是否加延时，只要一个线程名，示例代码如下

package ThreadPool;

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

public class SingleThreadDemo {
    private static Runnable getRunnable(final int i) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        };
    }

    public static void main(String[] args) {
        //单线程的线程池，唯一工作线程执行任务
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            //加不加延时，线程名只有1个
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleThreadExecutor.execute(getRunnable(i));
        }
        singleThreadExecutor.shutdown();
    }
}

（4）、newScheduledThreadPool：创建固定长度线程池，支持延时，定期执行线程任务

package ThreadPool;

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

public class ScheduledDemo {
    private static Runnable getRunnable(final int i) {
        return new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + " is running");
            }
        };
    }

    public static void main(String[] args) {
        ScheduledExecutorService scheduleThreadPool = Executors.newScheduledThreadPool(3);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //延时0s，每3s执行一次
            scheduleThreadPool.scheduleAtFixedRate(getRunnable(i), 0, 3, TimeUnit.SECONDS);
        }
        scheduleThreadPool.shutdown();
    }
}

2、ThreadPoolExecutor()：指定线程数的线程池，通过构造方法实现线程池，好像阿里大佬强制线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，可以更好的处理性能问题。

自定义线程池待深入理解

Executor返回线程池的劣势在于：

• FixedThreadPool和SingleThreadExecutor：允许请求队列长度为Integer.MAX_VALUE，可能堆积大量请求，造成OOM
• CachedThreadPool和ScheduledThreadPool：允许创建线程最大并发数为Integer.MAX_VALUE，可能会创建大量线程，造成OOM。

未完待续......