java线程池

一：线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。

二：使用线程池的好处：

（1）：降低资源消耗，通过重复利用已创建的线程降低线程创建和销毁造成的消耗。

（2）：提高响应速度，当任务到达时，任务可以不需要等到线程创建就能立即执行。

（3）：提高线程的可管理性，线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控

三：使用代码实现线程池：

class Test1{
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
              //核心线程数
                3,
                //最大线程数
                5,
                //存活时间
                1L,
                //时间单位
                TimeUnit.SECONDS,
                //等待队列
                new ArrayBlockingQueue<>(3),
                //线程工厂
                Executors.defaultThreadFactory(),
                //拒绝策略
                new ThreadPoolExecutor.AbortPolicy());
        for(int i=0;i<3;i++){
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName() + "===> 执行任务");
            });
        }
    }
}

　　

 

 此时正常分配任务

class Test1{
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
              //核心线程数
                3,
                //最大线程数
                5,
                //存活时间
                1L,
                //时间单位
                TimeUnit.SECONDS,
                //等待队列
                new ArrayBlockingQueue<>(3),
                //线程工厂
                Executors.defaultThreadFactory(),
                //拒绝策略
                new ThreadPoolExecutor.AbortPolicy());
        for(int i=0;i<6;i++){
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName() + "===> 执行任务");
            });
        }
    }

 

 此时需要执行的任务超过了核心线程数，则会让任务进入等待队列，等前面的任务执行完然后执行.

class Test1{
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
              //核心线程数
                3,
                //最大线程数
                5,
                //存活时间
                1L,
                //时间单位
                TimeUnit.SECONDS,
                //等待队列
                new ArrayBlockingQueue<>(3),
                //线程工厂
                Executors.defaultThreadFactory(),
                //拒绝策略
                new ThreadPoolExecutor.AbortPolicy());
        for(int i=0;i<8;i++){
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName() + "===> 执行任务");
            });
        }
    }
}

 

 此时需要执行的任务超过了核心线程数，等待队列满了后，线程池会创建不超过最大线程数的线程来执行任务.

class Test1{
    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(
              //核心线程数
                3,
                //最大线程数
                5,
                //存活时间
                1L,
                //时间单位
                TimeUnit.SECONDS,
                //等待队列
                new ArrayBlockingQueue<>(3),
                //线程工厂
                Executors.defaultThreadFactory(),
                //拒绝策略
                new ThreadPoolExecutor.AbortPolicy());
        for(int i=0;i<11;i++){
            executorService.execute(()->{
                System.out.println(Thread.currentThread().getName() + "===> 执行任务");
            });
        }
    }
}

 

 此时需要执行的任务超过了最大线程数，它会把能够执行的任务执行然后报错.