线程池一个并不陌生的概念，印象中的线程池经常使用，但是却不怎么了解原理。本文主要从线程出发，讲解线程池的使用，以及线程池的底层原理。
线程
创建线程的方式
- 继承Thread类
- 实现Runnable接口
- 实现Callable接口通过FutureTask包装器来创建Thread线程
但是从本质上来讲，java中创建线程的方式只有一种，就是实现Runable接口,即所以的线程都实现了run()方法。
下面可以通过java中的UML图进行证明
先看个线程的使用demo
public class ThreadTest {
public static class ThreadDemo extends Thread {
private String name;
public ThreadDemo(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println("调用方式:" + this.name + ",线程id:" + Thread.currentThread().getId() + ",线程name:" + Thread.currentThread().getName());
}
}
public static void main(String[] args) {
System.out.println("main线程id:" + Thread.currentThread().getId());
//线程级别
new ThreadDemo("start").start();
//方法级别
new ThreadDemo("run").run();
}
}执行结果
通过执行结果可以看出，调用start()和 run()方法执行的线程并不一致，start()是新创建的线程，而run()则和main()共用一个线程。它们之间线程的关系，如下图
1、线程有生命周期
2、调用start(),执行run() --》多线程
3、start()是线程级别，而单独调用run()是方法级别，等同于普通调用
线程池
public static void main(String[] args) throws InterruptedException {
Long start = System.currentTimeMillis();
final Random random = new Random();
final List<Integer> list = new ArrayList<Integer>();
ExecutorService executorService = Executors.newSingleThreadExecutor();
for (int i = 0; i < 100000; i++) {
executorService.execute(new Runnable() {
@Override
public void run() {
list.add(random.nextInt());
}
});
}
executorService.shutdown();
executorService.awaitTermination(1, TimeUnit.DAYS);
System.out.println("使用Executors.newSingleThreadExecutor 花费时间："+(System.currentTimeMillis() - start));
System.out.println("大小："+list.size());
System.out.println("==================");
list.clear();
for (int i = 0; i < 100000; i++) {
Thread thread = new Thread() {
@Override
public void run() {
list.add(random.nextInt());
}
};
thread.start();
thread.join();
}
System.out.println("使用thread时间："+(System.currentTimeMillis() - start));
System.out.println("大小："+list.size());
}执行结果
为什么两种方式执行结果相差这么大？
因为方式一使用的是线程池的方式，那么为何线程池？
线程池 就是首先创建一些线程，它们的集合称为线程池。使用线程池可以很好地提高性能，线程池在系统启动时即创建大量空闲的线程，程序将一个任务传给线程池，线程池就会启动一条线程来执行这个任务，执行结束以后，该线程并不会死亡，而是再次返回线程池中成为空闲状态，等待执行下一个任务。
两种处理方式时间相差较大的原因，本质上就是省去线程的创建时间，线程的复用，节省了大量的时间消耗。
几种常见的线程池使用
public class ThreadPoolDemo {
public static void main(String[] args) {
//固定大小的线程池，跟回收型线程池类似，只是可以限制同时运行的线程数量 执行慢
ExecutorService executorService1 = Executors.newFixedThreadPool(10);
//回收型线程池，可以重复利用之前创建过的线程，运行线程最大数是Integer.MAX_VALUE，快
ExecutorService executorService2 = Executors.newCachedThreadPool();
//单线程池，同时只有一个线程在跑，最慢
ExecutorService executorService3 = Executors.newSingleThreadExecutor();
//提供延迟和定时任务的线程池
Executors.newScheduledThreadPool(10);
for (int i = 0; i < 100; i++) {
executorService1.execute(new MyTask(i));
}
}
}
class MyTask implements Runnable {
int i = 0;
public MyTask(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--" + i);
try {
Thread.sleep(1000L);
} catch (Exception e) {
e.printStackTrace();
}
}
}执行结果已经标注到注释中，就不放图单独展示了。
那么为什么每种线程池的执行效率又各不相同呢？
在ThreadPoolExecutor的创建过程涉及到以下几个属性值
int corePoolSize,核心线程
int maximumPoolSize,非核心线程
long keepAliveTime,时间
TimeUnit unit,时间单位
BlockingQueue<Runnable> workQueue,队列
ThreadFactory threadFactory,线程工厂
RejectedExecutionHandler handler 拒绝策略
先看线程池组成
核心线程在整个程序运行过程会一直存在，即使处于空闲。
非核心线程等于maximumPoolSize减corePoolSize，非核心线程在空闲状态中的存活时间取决于keepAliveTime单位秒，如果keepAliveTime为0，即无待执行任务后，非核心线程立刻结束生命周期。
队列用于存放尚未处理的任务
RejectedExecutionHandler拒绝策略，当核心线程，队列，和非核心线程都没有空间存放待处理任务时，则任务会被拒绝执行。ps:拒绝策略非本文核心，只做简单展示
下面结合demo来展示线程池中核心线程，非核心线程，队列的使用
public class ThreadPoolDemo {
public static void main(String[] args) {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(2, 4,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<>(2));
for (int i = 0; i < 6; i++) {
threadPoolExecutor.execute(new MyTask(i));
}
}
}
class MyTask implements Runnable {
int i = 0;
public MyTask(int i) {
this.i = i;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "--" + i);
try {
Thread.sleep(1000L);
} catch (Exception e) {
e.printStackTrace();
}
}
}执行结果
为什么任务2，3比任务4，5执行的更晚？
原因在线程池中任务的提交顺序和任务的执行顺序并不相同
提交顺序
对应到java代码中java.util.concurrent.ThreadPoolExecutor#execute
因为这个提交顺序，所以在java提供的线程池FixedThreadPool没有非核心线程，因为使用队列为LinkedBlockingQueue:是一个基于链表结构的阻塞队列并无边界，此时即使有非核心线程也不会发挥作用。同样CachedThreadPool，使用的是SynchronousQueue一个不存储元素的阻塞队列，所以CachedThreadPool执行效率特别高，因为任务不会堆积，会一直创建线程来执行新的任务。
但是在日常开发过程上述几种线程池均不推荐使用，因为LinkedBlockingQueue无边界，如果任务过多，会发生内存耗尽的情况。而CachedThreadPool当任务过多的时候，会创建大量线程，进行任务处理，同样会占用过多的CPU资源阻碍其他进程。
执行顺序
从执行结果其实就可以看出执行顺序为核心线程-》非核心线程-》队列
线程的本质都有run()->runWorker()
java.util.concurrent.ThreadPoolExecutor#runWorker
为什么任务0，1和任务2，3执行的线程是相同的？
这个问题的本质，线程是如何做到复用的
线程复用和线程执行流程图：
总结
线程有三种创建方式，但是本质上只有一种即实现Runable接口，所以线程均有run()。想要搞懂线程池的底层实现原理，必须先明白一个概念，start()是创建线程，而run()则只是普通方法。在线程复用的时候，则调用的是方法级别的run()。
线程池的有核心线程，非核心线程，队列三个属性值。在向线程池提交任务和执行任务的时候顺序并不相同，提交任务顺序为核心-》队列-》非核心，而执行任务则为核心-》非核心-》队列。
