Executors :
Executors ,就是一个线程工具类；大部分操作线程的方法，都可以在这个工具类中就行创建，执行，调用一些线程的方法；
Executor ：
用于执行和提交一个runnable 任务；就是将线程的创建与执行就行了解藕：
像：
new Thread(new(RunnableTask())).start()}
可以被替代为
Executor executor = anExecutor;
executor.execute(new RunnableTask1());：
线程池 ThreadPool:
是我们维护线程数量的一个池子，创建的目的是为了节省系统资源，避免频繁创建线程与销毁线程带来的系统开销；接下来进行实例型的线程例子：
1. Executors.newFixedThreadPool(nthread); 创建一个固定数量的线程池
如果任务超出了线程的数量，那么多出的任务放在 LinkedBlockingQueue<Runnable>中，然后在这个队列中进行进行任务获取执行，先进先出；
尝试运行如下程序：
public static void main(String[] args) throws InterruptedException {
ExecutorService pool = Executors.newFixedThreadPool(3);
for(int i=0;i<6;i++) {
pool.submit(()->{
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"....");});
}
System.out.println(pool.isTerminated());
System.out.println(pool);
Thread.sleep(4000);
System.err.println(pool);
pool.shutdown();
}
运行结果如下：
false
java.util.concurrent.ThreadPoolExecutor@eed1f14[Running, pool size = 3, active threads = 3, queued tasks = 3, completed tasks = 0]
pool-1-thread-1....
pool-1-thread-3....
pool-1-thread-2....
pool-1-thread-3....
pool-1-thread-1....
pool-1-thread-2....
java.util.concurrent.ThreadPoolExecutor@eed1f14[Running, pool size = 3, active threads = 0, queued tasks = 0, completed tasks = 6]
可以看到我们的线程池对象中：
pool size ：大小就是我们定义的3个线程，且运行也是在这3个线程之内进行运行；
active thread：目前活动的线程
queued tasks ：在队列中的线程数量
completed tasks ：完成的线程数
运作机制：在 ThreadPoolExecutor类中维护着一个worker内部类的内部类来维护着线程的运行状态；
volatile long completedTasks;//统计已经执行完毕的线程数量
//可以看到使用了线程工厂ThreadFactory进行线程的创建，我们所有的任务都会在这里进行工作的分配
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
} /** Delegates main run loop to outer runWorker */
public void run() {
runWorker(this);
}
2.Executors.newCachedThreadPool() 创建缓存线程池；
public static void main(String[] args) throws InterruptedException, ExecutionException {
ExecutorService pool = Executors.newCachedThreadPool();
Future<Integer> p1 = pool.submit(()->{ Thread.sleep(1000);System.out.println(Thread.currentThread().getName());return 2;});
Future<Integer> p2 = pool.submit(()->{ Thread.sleep(1000); System.out.println(Thread.currentThread().getName());return 3;});
Future<Integer> p3 = pool.submit(()->{ Thread.sleep(1000); System.out.println(Thread.currentThread().getName());return 4;});
Future<Integer> p4 = pool.submit(()->{ System.out.println(Thread.currentThread().getName());return 5;});
Future<Integer> p5 = pool.submit(()->{ System.out.println(Thread.currentThread().getName());return 6;});
Future<Integer> p6 = pool.submit(()->{ System.out.println(Thread.currentThread().getName());return 8;});
System.out.println(pool);
Thread.sleep(70000);
System.err.println(pool);
}
结果如下：
pool-1-thread-4
pool-1-thread-5
pool-1-thread-5
java.util.concurrent.ThreadPoolExecutor@41629346[Running, pool size = 5, active threads = 3, queued tasks = 0, completed tasks = 3]
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
java.util.concurrent.ThreadPoolExecutor@41629346[Running, pool size = 0, active threads = 0, queued tasks = 0, completed tasks = 6]
得知CacheThreadPool会根据任务来创建不同个数的线程；没有空闲的线程就创建；有就重复使用
最大是integet.MAX_VALUE,线程超过60second 不使用，线程会被销毁;应用于并发很大，机器很牛逼；
3.Executors.newSingleThreadExecutor() ：创建一个单个线程；顾名思义：就是所有的任务都放在一个线程中去执行，这样就保证了线程中任务运行的执行顺序，按照顺序进行执行；
public static void main(String[] args) {
ExecutorService pool = Executors.newSingleThreadExecutor();
Future<Integer> p1 = pool.submit(()->{ Thread.sleep(1000);System.out.println(Thread.currentThread().getName()+"...1");return 2;});
Future<Integer> p2 = pool.submit(()->{ Thread.sleep(1000); System.out.println(Thread.currentThread().getName()+"...2");return 3;});
Future<Integer> p3 = pool.submit(()->{ Thread.sleep(1000); System.out.println(Thread.currentThread().getName()+"...3");return 4;});
Future<Integer> p4 = pool.submit(()->{ System.out.println(Thread.currentThread().getName()+"...4");return 5;});
Future<Integer> p5 = pool.submit(()->{ System.out.println(Thread.currentThread().getName()+"...5");return 6;});
Future<Integer> p6 = pool.submit(()->{ System.out.println(Thread.currentThread().getName()+"...6");return 8;});
System.out.println(pool);
}
可以看到任务都是一条一条执行的；
4.Executors.newScheduledThreadPool(nthread) :用来执行定时任务的线程池，代替了timer
public static void main(String[] args) throws Exception{
ScheduledExecutorService schedule = Executors.newScheduledThreadPool(2);
//在指定时间内执行，只执行一次
ScheduledFuture<Integer> schedule2 = schedule.schedule(()-> {System.out.println(Thread.currentThread().getName());return 2;}, 3, TimeUnit.SECONDS);
//指定时间时间，并在一定的时间内去重复执行
schedule.scheduleAtFixedRate(()->{System.out.println(Thread.currentThread().getName());}, 1, 3, TimeUnit.SECONDS);
System.out.println(schedule);
Thread.sleep(10000);
System.out.println(schedule);
}
5. ForkJoinPool:可以将一个庞大的任务根据自己的规则将任务划分成不同的小块，ForkJoin会根据规则去开启线程去运行每一个小部分；
例子是计算0-2000000的和：使用extends RecursiveAction 这个没有返回值；
package com.java.baseknowledge.concurrent15; import java.io.IOException;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction; /**
* fork join pool
* 进行将一个大的任务根据自己的规则进行切分，用线程去执行
* 启动的线程是后台线程（精灵线程