线程池(详解)：三大方法、七大参数、四种拒绝策略

线程池（重点）

一：线程池：三大方法，七大参数，四种拒绝策略

　　池化技术：
    　　01：程序的运行，本质 ：占用系统的资源！ 优化资源的使用！  =>池化技术
    　　02：线程池、连接池、内存池、对象池///......创建、销毁。 十分浪费资源
    　　03：池化技术：事先准备好一些资源，有人要用，就来我这里拿，用完之后还给我。

　　线程池的好处：
    　　01：降低资源的消耗
    　　02：提高响应的速度
    　　03：方便管理
   　　（重点）线程复用、可以控制最大并发数、管理线程
二：三大方法：

　　01：Executors.newSingleThreadExecutor()　　//单个线程
　　　　代码示例01

package pool;

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

//Executors 工具类、3大方法

public class Demo01 {
    public static void main(String[] args) {

        ExecutorService threadpool = Executors.newSingleThreadExecutor();     //单个线程

        try {
            for (int i = 0; i < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadpool.shutdown();   //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果： （10个任务被同一个线程所操作）

  

 　　02：newFixedThreadPool(int nThreads)　　　　 //创建一个固定的线程池的大小

　　　　代码示例02

package pool;

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

//Executors 工具类、3大方法

public class Demo01 {
    public static void main(String[] args) {

        //最多5个线程同时执行，从控制台中查看结果
        ExecutorService threadpool = Executors.newFixedThreadPool(5);   //创建一个固定的线程池的大小，（5个线程）

        try {
            for (int i = 0; i < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadpool.shutdown();   //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果：（最高同时有5个线程在执行）

 　　03：newCachedThreadPool() 　　　　 //缓存池，可伸缩的， 遇强则强，遇弱则弱

　　　　代码示例03

package pool;

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

//Executors 工具类、3大方法

public class Demo01 {
    public static void main(String[] args) {

        ExecutorService threadpool = Executors.newCachedThreadPool();   //缓存池，可伸缩的， 遇强则强，遇弱则弱

        try {
            for (int i = 0; i < 10; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadpool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadpool.shutdown();   //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果：（最高同时有10个线程在执行，可伸缩的， 遇强则强，遇弱则弱）

 　　三：七大参数

　　　　　　01：三大方法之源码分析：

　　　　 (1)  newSingleThreadExecutor()              //单个线程

        public static ExecutorService newSingleThreadExecutor() {
                return new FinalizableDelegatedExecutorService
                    (new ThreadPoolExecutor(1, 1,
                                            0L, TimeUnit.MILLISECONDS,
                                            new LinkedBlockingQueue<Runnable>()));
            }
        ==================================================================================
        (2)  newFixedThreadPool(int nThreads)       //创建一个固定的线程池的大小

        public static ExecutorService newFixedThreadPool(int nThreads) {
                return new ThreadPoolExecutor(nThreads, nThreads,
                                              0L, TimeUnit.MILLISECONDS,
                                              new LinkedBlockingQueue<Runnable>());
            }
        ===================================================================================
        (3)  newCachedThreadPool()                  //缓存池，可伸缩的， 遇强则强，遇弱则弱

        public static ExecutorService newCachedThreadPool() {
                return new ThreadPoolExecutor(0, Integer.MAX_VALUE,     //Integer.Max_VALUE  约等于21亿  //如果我们有这么多条线程一起跑的话，电脑会OOM(溢出)，出现问题
                                              60L, TimeUnit.SECONDS,                          
                                              new SynchronousQueue<Runnable>());             
            }
        ====================================================================================
        (4) 三大方法所公共的  ThreadPoolExecutor() 方法

                                        ******7大参数******

        public ThreadPoolExecutor(int corePoolSize,                         //核心线程池大小
                                      int maximumPoolSize,                  //最大核心线程池大小
                                      long keepAliveTime,                   //超时了没有人调用就会释放
                                      TimeUnit unit,                        //超时单位
                                      BlockingQueue<Runnable> workQueue,    //阻塞队列
                                      ThreadFactory threadFactory,          //线程工厂，创建线程的，一般不用动
                                      RejectedExecutionHandler handler) {   //拒绝策略
                if (corePoolSize < 0 ||
                    maximumPoolSize <= 0 ||
                    maximumPoolSize < corePoolSize ||
                    keepAliveTime < 0)
                    throw new IllegalArgumentException();
                if (workQueue == null || threadFactory == null || handler == null)
                    throw new NullPointerException();
                this.corePoolSize = corePoolSize;
                this.maximumPoolSize = maximumPoolSize;
                this.workQueue = workQueue;
                this.keepAliveTime = unit.toNanos(keepAliveTime);
                this.threadFactory = threadFactory;
                this.handler = handler;
            }

　　阿里巴巴开发手册中有如下规定：

 　　例如银行办理业务图：

　　四：四种拒绝策略：

/**
 * new ThreadPoolExecutor.AbortPolicy()         //银行满了，还有人进来，不处理这个人的，抛出异常
 * new ThreadPoolExecutor.CallerRunsPolicy()    //哪来的去哪里！
 * new ThreadPoolExecutor.DiscardPolicy()       //队列满了，丢掉任务，不会抛出异常！
 * new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试和最早的竞争，也不会抛出异常
 */

五：手动（自定义）创建一个线程池：
　

　代码示例01　　　　new ThreadPoolExecutor.AbortPolicy()　　//银行满了，还有人进来，不处理这个人的，抛出异常

package pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！ 工作中只会使用 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,                                  //核心线程池大小
                5,                             //最大核心线程池大小
                3,                                //超时了没有人调用就会释放
                TimeUnit.SECONDS,                               //超时单位
                new LinkedBlockingDeque<>(3),          //阻塞队列
                Executors.defaultThreadFactory(),               //线程工厂，创建线程的，一般不用动
                new ThreadPoolExecutor.AbortPolicy());  //银行满了，还有人进来，不处理这个人的，抛出异常

        try {
            //最大承载数，Deque + Max    (队列线程数+最大线程数)
            //超出 抛出 RejectedExecutionException 异常
            for (int i = 1; i <= 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();      //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果（对比）：

     

     

　　代码示例02　　　　new ThreadPoolExecutor.CallerRunsPolicy()　　　　//哪来的去哪里

package pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！ 工作中只会使用 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,                                  //核心线程池大小
                5,                             //最大核心线程池大小
                3,                                //超时了没有人调用就会释放
                TimeUnit.SECONDS,                               //超时单位
                new LinkedBlockingDeque<>(3),          //阻塞队列
                Executors.defaultThreadFactory(),               //线程工厂，创建线程的，一般不用动
                new ThreadPoolExecutor.CallerRunsPolicy());     //哪来的去哪里！

        try {
            //最大承载数，Deque + Max    (队列线程数+最大线程数)
            //超出 抛出 RejectedExecutionException 异常
            for (int i = 1; i <= 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();      //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果:

 　　代码示例03　　　　new ThreadPoolExecutor.DiscardPolicy() //队列满了，丢掉任务，不会抛出异常！

package pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！ 工作中只会使用 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,                                  //核心线程池大小
                5,                             //最大核心线程池大小
                3,                                //超时了没有人调用就会释放
                TimeUnit.SECONDS,                               //超时单位
                new LinkedBlockingDeque<>(3),          //阻塞队列
                Executors.defaultThreadFactory(),               //线程工厂，创建线程的，一般不用动
                new ThreadPoolExecutor.DiscardPolicy());        //队列满了，丢掉任务，不会抛出异常！

        try {
            //最大承载数，Deque + Max    (队列线程数+最大线程数)
            //超出 抛出 RejectedExecutionException 异常
            for (int i = 1; i <= 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();      //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果：

 　　04：代码示例　　　　new ThreadPoolExecutor.DiscardOldestPolicy() //队列满了，尝试和最早的竞争，也不会抛出异常

package pool;

import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo02 {
    public static void main(String[] args) {
        //自定义线程池！ 工作中只会使用 ThreadPoolExecutor
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2,                                  //核心线程池大小
                5,                             //最大核心线程池大小
                3,                                //超时了没有人调用就会释放
                TimeUnit.SECONDS,                               //超时单位
                new LinkedBlockingDeque<>(3),          //阻塞队列
                Executors.defaultThreadFactory(),               //线程工厂，创建线程的，一般不用动
                new ThreadPoolExecutor.DiscardOldestPolicy());  //队列满了，尝试和最早的竞争，也不会抛出异常

        try {
            //最大承载数，Deque + Max    (队列线程数+最大线程数)
            //超出 抛出 RejectedExecutionException 异常
            for (int i = 1; i <= 9; i++) {
                //使用了线程池之后，使用线程池来创建线程
                threadPool.execute(()->{
                    System.out.println(Thread.currentThread().getName()+" ok");
                });
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //线程池用完，程序结束，关闭线程池
            threadPool.shutdown();      //（为确保关闭，将关闭方法放入到finally中）
        }
    }
}

运行结果：