线程池的使用（newCachedThreadPool、newFixedThreadPool、newScheduledThreadPool、newSingleThreadExecutor）

newCachedThreadPool

创建一个可扩展线程池的执行器

* 作用：用来创建一个可以无限增大的线程池。当有任务到来时，会判断当先线程池中是否有已经执行完被回收的空闲线程，有则使用，没有则创建新的线程。（空闲线程：线程如果60秒没有使用就会被任务是空闲线程并移出Cache）

* 特点：无限扩展、自动回收空闲线程、复用空闲线程

* 使用场景：在小任务量，任务时间执行短的场景下提高性能

* 注意：使用完要调用shutdown()来关闭执行器，如果不关闭，则一直等待新任务的到来。

* shutdown():调用shutdown()后不在接收新的任务，并按照已经提交的任务的顺序发起一个有序的关闭过程。如果已经关闭执行器了，则调用没有其他作用。

* 使用方式:

ExecutorService executor = Executors.newCachedThreadPool();//创建线程池执行器服务

executor.execute(task); //把Runnable交给执行器执行

executor.shutdown(); //申请关闭执行器

* 可能发生的异常：java.lang.OutOfMemoryError

* 异常原因：任务量太大，线程池不断创建新的线程，超越了内存限制

public class MyCacheThreadPool{
public static void main(String[] arg) {
ExecutorService executor = Executors.newCachedThreadPool();
for(int i = 0; i < 20; i++){
executor.execute(new Thread(new Runnable() {

@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}

}));
}
}

}

newFixedThreadPool

创建一个可重用的固定线程数的线程池

* 作用：任务执行开始从线程池中获取可用的线程执行任务，如果线程池中正在执行的任务达到设置的线程最大数（无可用线程），则新得任务会放到阻塞队列里等待，有可用线程时按顺序执行。

* 特点：可指定线程数、线程可重用、队列数量没有限制

* 使用场景：用于负载比较重的服务器，为了资源的合理利用，需要限制当前线程数量

* 注意: 如果没有显式的关闭，则池中的线程将一直存在

* 使用方式:

ExecutorService executor = Executors.newFixedThreadPool(3);//创建线程池执行器服务

executor.execute(task); //把Runnable交给执行器执行

executor.shutdown(); //申请关闭执行器

public class MyFixedThreadPool {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(3);
for(int i = 0; i < 10; i++){
executor.execute(new Runnable() {

@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行...");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}

}
});
}
}
}

newScheduledThreadPool

创建一个定长的线程池，支持定时任务、周期性任务的执行

* 作用：线程池能按时间计划来执行任务，允许用户设定计划执行任务的时间。

* 注意：newScheduledThreadPool(int corePoolSize) 参数corePoolSize设定线程池中线程的最小数目。当任务较多时，线程池可能会创建更多的工作线程来执行任务

public class MyScheduledThreadPool {
//定时任务
public static void main(String[] args) {
ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
executor.schedule(new Runnable() {

@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "延迟3秒后运行...");

}
}, 3, TimeUnit.SECONDS);
}

//周期任务
/*  public static void main(String[] args) {
System.out.println("任务开始，1秒后运行，每隔3秒运行一次...");
ScheduledExecutorService executor = Executors.newScheduledThreadPool(3);
executor.scheduleAtFixedRate(new Runnable() {

@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "    >>>" + new Date().toLocaleString());

}
}, 1, 3, TimeUnit.SECONDS);
}*/
}

newSingleThreadExecutor

创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

public class MySingleThreadExecutor {
public static void main(String[] args) {
ExecutorService executor = Executors.newSingleThreadExecutor();
for(int i = 0; i < 10; i++){
final int index = i;
executor.execute(new Runnable() {

@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "执行 >>> " + index);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}

4000
}
});
}
}
}