Java线程池介绍及使用（附含demo）

线程池简介

简介

线程池的基本思想还是一种对象池的思想，开辟一块内存空间，里面存放了众多（未死亡）的线程，池中线程执行调度由池管理器来处理。当有线程任务时，从池中取一个，执行完成后线程对象归池，这样可以避免反复创建线程对象所带来的性能开销，节省了系统的资源。

在Java5中，需要了解的是java.util.concurrent.Executors类的API，这个类提供大量创建连接池的静态方法。

优势

• 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
• 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
• 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。

线程池的工作原理

线程池实践

线程池参数

参数	说明
corePoolSize	核心线程数量，线程池维护线程的最少数量
maximumPoolSize	线程池维护线程的最大数量
keepAliveTime	线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将allowCoreThreadTimeout设置为true时，核心线程也会超时回收。
unit	指定keepAliveTime参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。
workQueue	线程池所使用的任务缓冲队列
threadFactory	线程工厂。用于指定为线程池创建新线程的方式。
handler	线程池对拒绝任务的处理策略

当线程池任务处理不过来的时候，可以通过handler指定的策略进行处理，ThreadPoolExecutor提供了四种策略：

1. ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常；也是默认的处理方式。
2. ThreadPoolExecutor.DiscardPolicy：丢弃任务，但是不抛出异常。
3. ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
4. ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务

注意：除了ThreadPoolExecutor提供的策略，也可以通过实现RejectedExecutionHandler接口自定义处理方式。

新建线程池

Executors已经为我们封装好了4种常见的功能线程池，如下：

• 定长线程池（FixedThreadPool）：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
• 定时线程池（ScheduledThreadPool）：创建一个定长线程池，支持定时及周期性任务执行。
• 可缓存线程池（CachedThreadPool）： 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
• 单线程化线程池（SingleThreadExecutor）：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照顺序执行。

/**
 * 定长线程池
 * 特点：只有核心线程，线程数量固定，执行完立即回收，任务队列为链表结构的有界队列。
 * 应用场景：控制线程最大并发数。
 */
ExecutorService pool = Executors.newFixedThreadPool(3);


/**
 * 单任务线程池
 * 特点：只有1个核心线程，无非核心线程，执行完立即回收，任务队列为链表结构的有界队列。
 * 应用场景：不适合并发但可能引起IO阻塞性及影响UI线程响应的操作，如数据库操作、文件操作等
 */
ExecutorService pool = Executors.newSingleThreadExecutor();


/**
 * 可伸缩（缓存）线程池
 * 特点：无核心线程，非核心线程数量无限，执行完闲置60s后回收，任务队列为不存储元素的阻塞队列。
 * 应用场景：执行大量、耗时少的任务。
 */
ExecutorService pool = Executors.newCachedThreadPool();


 /**
 * 定时线程池
 * 特点：核心线程数量固定，非核心线程数量无限，执行完闲置10ms后回收，任务队列为延时阻塞队列。
 * 应用场景：执行定时或周期性的任务
 */
ExecutorService pool = Executors.newScheduledThreadPool(2);

四种线程池的对比：

说明： Executors 返回的线程池对象的弊端如下：

FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，可能会堆积大量的请求，从而导致 OOM。

CachedThreadPool 和 ScheduledThreadPool：允许的创建线程数量为 Integer.MAX_VALUE， 可能会创建大量的线程，从而导致 OOM。

自定义线程池

/**
 * 自定义线程池
 */
public class MyThreadPool {
    private static final int CORE_POOL_SIZE = 5; // 最大核心线程
    private static final int MAX_POOL_SIZE = 10; // 最大线程
    private static final long KEEP_ALIVE_TIME = 5000; // 非核心线程保留时长

    public static void main(String[] args) {
        // 定义阻塞队列
        BlockingQueue queue = new ArrayBlockingQueue(20);
        // 定义线程池
        ThreadPoolExecutor pool = new ThreadPoolExecutor(CORE_POOL_SIZE,MAX_POOL_SIZE,KEEP_ALIVE_TIME, TimeUnit.SECONDS, queue);
        pool.execute(new MyThread("A"));
        // 关闭线程池
        pool.shutdown();
    }

}

阻塞队列

任务队列是基于阻塞队列实现的，即采用生产者消费者模式，在Java中需要实现BlockingQueue接口。但Java已经为我们提供了7种阻塞队列的实现：

• ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列（数组结构可配合指针实现一个环形队列）。
• LinkedBlockingQueue： 一个由链表结构组成的有界阻塞队列，在未指明容量时，容量默认为Integer.MAX_VALUE。
• PriorityBlockingQueue： 一个支持优先级排序的无界阻塞队列，对元素没有要求，可以实现Comparable接口也可以提供Comparator来对队列中的元素进行比较。跟时间没有任何关系，仅仅是按照优先级取任务。
• DelayQueue：类似于PriorityBlockingQueue，是二叉堆实现的无界优先级阻塞队列。要求元素都实现Delayed接口，通过执行时延从队列中提取任务，时间没到任务取不出来。
• SynchronousQueue： 一个不存储元素的阻塞队列，消费者线程调用take()方法的时候就会发生阻塞，直到有一个生产者线程生产了一个元素，消费者线程就可以拿到这个元素并返回；生产者线程调用put()方法的时候也会发生阻塞，直到有一个消费者线程消费了一个元素，生产者才会返回。
• LinkedBlockingDeque： 使用双向队列实现的有界双端阻塞队列。双端意味着可以像普通队列一样FIFO（先进先出），也可以像栈一样FILO（先进后出）。
• LinkedTransferQueue： 它是ConcurrentLinkedQueue、LinkedBlockingQueue和SynchronousQueue的结合体，但是把它用在ThreadPoolExecutor中，和LinkedBlockingQueue行为一致，但是是无界阻塞队列。

注意有界队列和无界队列的区别：如果使用有界队列，当队列饱和时并超过最大线程数时就会执行拒绝策略；而如果使用无界队列，因为任务队列永远都可以添加任务，所以设置maximumPoolSize没有任何意义。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * 测试阻塞队列/阻塞栈
 */
public class TestBlockQueue {

    /**
     * 阻塞队列
     */
    @Test
    public void test() {
        BlockingQueue queue = new ArrayBlockingQueue(10);
        for (int i = 0; i < 20; i++) {
            queue.add(i);
            System.out.println("向队列添加元素"+i);
        }
        System.out.println("运行结束");
    }

    /**
     * 阻塞栈
     */
    @Test
    public void test1() {
        BlockingDeque queue = new LinkedBlockingDeque(10);
        for (int i = 0; i < 20; i++) {
            queue.add(i);
            System.out.println("向栈添加元素"+i);
        }
        System.out.println("运行结束");
    }

}

总结

以上就是Java多线程中线程池的一些内容，前面也写了一些关于Java多线程基本概念，有兴趣的小伙伴可以去看看，关于多线程的内容就分享到这里了，再次希望本文对大家理解线程池有帮助~~