多线程之线程池

1.线程池的优点

减少资源消耗
提高响应速度
提交线程的可管理性

2.线程的生命周期

3.线程池的执行流程

4.创建线程池的两种方式

1.通过Executorsc创建，他提供了四种线程池：（不推荐使用）

• newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• newFixedThreadPool(线程池大小)创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• newScheduledThreadPool创建一个定长线程池，支持定时及周期性任务执行。以下示例：
• newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

使用：Executors. …;
注意：newSingleThreadExecutor和newFixedThreadPool允许的最大请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求,导致内存溢出。newCachedThreadPool和newScheduledThreadPool允许的创建线程的最大数量为Integer.MAX_VALUE，，从而导致内存溢出。

/**
 * newScheduledThreadPool
 * 表示延迟1秒后每3秒执行一次,周期性
 */
public class TestPool003 {
    public static void main(String[] args) {
        ScheduledExecutorService spool = Executors.newScheduledThreadPool(3);
        spool.scheduleAtFixedRate(()-> System.out.println(Thread.currentThread().getName())
            ,1,3, TimeUnit.SECONDS);
    }
}

/**定时
 * scheduledThreadPool
 */
public class TestPool03 {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(2);
        MyRunnable1 myRunnable0 = new MyRunnable1();
        MyRunnable1 myRunnable2 = new MyRunnable1();
        MyRunnable1 myRunnable3 = new MyRunnable1();
        scheduledThreadPool.schedule(myRunnable0,5, TimeUnit.SECONDS);
        scheduledThreadPool.schedule(myRunnable2,2, TimeUnit.SECONDS);
        scheduledThreadPool.schedule(myRunnable3,30, TimeUnit.SECONDS);
    }
}

class MyRunnable1 implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            final int index = i;
            System.out.println(Thread.currentThread().getName()+"---"+index);
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

2.通过ThreadPoolExecutor创建，它有七个参数：

ThreadPoolExecutor(int corePoolSize, //核心线程池大小，始终存在
               int maximumPoolSize, //最大线程数
                long keepAliveTime, //闲线程存活时间，超时则销毁
                     TimeUnit unit, //keepAliveTime的时间计量单位
 BlockingQueue<Runnable> workQueue, //等待阻塞队列
       ThreadFactory threadFactory, //线程工厂
   RejectedExecutionHandler handler) //线程拒绝策略

阻塞队列的类型：
ArrayBlockingQueue

基于数组的有界阻塞队列，按FIFO排序

LinkedBlockingQuene

基于链表的无界阻塞队列（其实最大容量为Interger.MAX），按照FIFO排序。使用该工作队列时，参数maxPoolSize其实是不起作用的。

SynchronousQuene

一个不缓存任务的阻塞队列，也就是说新任务进来时，不会缓存，而是直接被调度执行该任务，如果没有可用线程，则创建新线程，如果线程数量达到maxPoolSize，则执行拒绝策略。

PriorityBlockingQueue

具有优先级的无界阻塞队列，优先级通过参数Comparator实现。

handler拒绝策略：
CallerRunsPolicy

在调用者线程中直接执行被拒绝任务的run方法，除非线程池已经shutdown，则直接抛弃任务。

AbortPolicy

直接丢弃任务，并抛出RejectedExecutionException异常。

DiscardPolicy

该策略下，直接丢弃任务，什么都不做。

DiscardOldestPolicy

该策略下，抛弃进入队列最早的那个任务，然后尝试把这次拒绝的任务放入队列

new ThreadPoolExecutor.AbortPolicy()
new ThreadPoolExecutor.CallerRunsPolicy()
new ThreadPoolExecutor.DiscardPolicy()
new ThreadPoolExecutor.DiscardOldestPolicy()

例如:

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class TestPoolExecutor {
    public static void main(String[] args) {
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
                5,10,10,
                TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(100),
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName());
            }
        });
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 3; i++) {
                    System.out.println(Thread.currentThread().getName()+"---"+i);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        //lambda表达式
        poolExecutor.execute(()->System.out.println(Thread.currentThread().getName()));
    }
}