Java创建线程池和线程池的七个核心参数

110010100

于 2024-10-11 21:57:26 发布

阅读量470

点赞数 21

文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_44840230/article/details/142852440

版权

线程池的工作流程是：当一个任务被提交到线程池时，线程池会根据当前的线程数量和工作队列的状态来决定如何处理这个任务。如果当前运行的线程数量小于corePoolSize，则创建新线程执行任务；如果大于等于corePoolSize，则将任务放入工作队列；如果工作队列已满，且运行的线程数量小于maximumPoolSize，则创建新线程执行任务；如果线程数量等于maximumPoolSize，则应用拒绝策略。
线程池原理流程图：

常用的四种线程池

        ExecutorService threadPool = Executors.newFixedThreadPool(5);//创建一个固定线程数的线程池，
        ExecutorService threadPoo2 = Executors.newCachedThreadPool();//会根据你计算机和任务的情况，进行自动增减线程
        ExecutorService threadPoo3 = Executors.newSingleThreadExecutor();//创建一个单线程的线程池，每次只能执行一个任务
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);//支持定时及周期性任务执行

newFixedThreadPool————指定线程数量

创建一个指定工作线程数量的线程池。
每当提交一个任务就创建一个工作线程，如果工作线程数量达到线程池初始的最大数，则将提交的任务存入到池队列中。

提高程序效率和节省创建线程时所耗的开销；
线程池空闲时，即线程池中没有可运行任务时，它不会释放工作线程，还会占用一定的系统资源

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class fixedThreadPool {
    public volatile int i;
    public static void main(String[] args) {
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(2);  
        for (int i = 0; i < 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(8000);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

newCachedThreadPool——可缓存线程池

如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

线程的创建数量几乎没有限制。这样可灵活的往线程池中添加线程。
如果长时间没有往线程池中提交任务，即如果工作线程空闲了指定的时间(默认为1分钟)，则该工作线程将自动终止。终止后，如果你又提交了新的任务，则线程池重新创建一个工作线程
要注意控制任务的数量，否则，由于大量线程同时运行，很有会造成系统瘫痪。

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class executor {
    public static void main(String[] args) {
        ExecutorService pool = Executors.newCachedThreadPool();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index*1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            pool.execute(new Runnable() {
                public void run() {
                    System.out.println(index);
                }
            });
        }
    }
}

newSingleThreadExecutor————单线程的Executor

只创建唯一的线程来执行任务。保证任务按照指定顺序（FIFO,LIFO，优先级）执行。
如果这个线程异常结束，会有另一个取代它

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class singleThreadExecutor {
    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 0; i < 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {
                public void run() {
                    try {
                        System.out.println(index);
                        Thread.sleep(8000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

newScheduleThreadPool——定时线程池

支持定时及周期性任务执行。
延迟3s执行示例代码：

import java.sql.Time;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class scheduledThreadPool {
    public static void main(String[] args) {
        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
       scheduledThreadPool.schedule(new Runnable() {
           public void run() {
               System.out.println("延迟5秒执行");
           }
       },5, TimeUnit.SECONDS);
    }
}

ThreadPoolExecutor

下面是ThreadPoolExecutor类的构造方法源码，其他（以上四个常用线程池）创建线程池的方法最终都会导向这个构造方法。

    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.acc = System.getSecurityManager() == null ?
                null :
                AccessController.getContext();
        this.corePoolSize = corePoolSize;
        this.maximumPoolSize = maximumPoolSize;
        this.workQueue = workQueue;
        this.keepAliveTime = unit.toNanos(keepAliveTime);
        this.threadFactory = threadFactory;
        this.handler = handler;
    }

这些参数通过volatile进行修饰。

volatile是Java中的一个关键字，它提供了一种轻量级的同步机制。在多线程环境中，当一个变量被volatile修饰后，它能够保证这个变量对所有线程的可见性。这意味着当一个线程改变了这个变量的值，新值对于其他线程来说是立即可知的。然而，volatile并不保证操作的原子性，也就是说，像自增操作这样的复合操作不能仅仅通过volatile来保证其线程安全性。

public class ThreadPoolExecutor extends AbstractExecutorService {
    private final BlockingQueue<Runnable> workQueue;
    private volatile ThreadFactory threadFactory;
    private volatile RejectedExecutionHandler handler;
    private volatile long keepAliveTime;
    // 是否允许核心线程被回收
    private volatile boolean allowCoreThreadTimeOut;
    private volatile int corePoolSize;
    private volatile int maximumPoolSize;
}

核心线程数（corePoolSize）

线程池维护的最小线程数，即使这些线程处于空闲状态，除非设置了allowCoreThreadTimeOut，否则它们也不会被销毁。当任务提交到线程池后，如果当前运行的线程数量小于corePoolSize，则会创建新线程来处理这个任务。

最大线程数（maximumPoolSize）

最大线程数是线程池允许创建的最大线程数量。当核心线程数已满，且工作队列也已满，线程池还没达到最大线程数，并且没有空闲线程时，会创建新线程来执行任务。

空闲线程存活时间（keepAliveTime）

空闲线程存活时间是指当线程池中的线程数量超过corePoolSize时，如果这些线程没有任务执行，它们可以存活的时间。超过这个时间，线程将被销毁以节省资源。

时间单位（unit）

时间单位是keepAliveTime的单位，可以是纳秒、微秒、毫秒、秒、分钟、小时等。

TimeUnit.NANOSECONDS
TimeUnit.MICROSECONDS
TimeUnit.MILLISECONDS
TimeUnit.SECONDS
TimeUnit.MINUTES
TimeUnit.HOURS
TimeUnit.DAYS

工作队列（workQueue）

工作队列用于存放等待执行的任务。当所有核心线程都在忙时，新提交的任务会进入这个队列等待。JDK提供了多种类型的队列，如ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。

ArrayBlockingQueue （数组型阻塞队列）：数组结构，初始化时传入大小，有界，FIFO，使用一个重入锁，默认使用非公平锁，入队和出队共用一个锁，互斥。
LinkedBlockingQueue （链表型阻塞队列）：链表结构，默认初始化大小为Integer.MAX_VALUE，有界（近似无解），FIFO，使用两个重入锁分别控制元素的入队和出队，用Condition进行线程间的唤醒和等待。
SynchronousQueue （同步队列）：容量为0，添加任务必须等待取出任务，这个队列相当于通道，不存储元素。
PriorityBlockingQueue （优先阻塞队列）：无界，默认采用元素自然顺序升序排列。
DelayQueue （延时队列）：无界，元素有过期时间，过期的元素才能被取出。

线程工厂（threadFactory）

线程工厂用于创建新线程。可以通过线程工厂来设置线程的一些属性，如线程名、是否为守护线程等。

拒绝策略（handler）

当线程池和工作队列都满了，无法处理更多的任务时，新提交的任务会使用拒绝策略进行处理。JDK提供了四种拒绝策略：AbortPolicy、DiscardPolicy、DiscardOldestPolicy和CallerRunsPolicy。

AbortPolicy：丢弃任务并抛出RejectedExecutionException异常。
DiscardPolicy：丢弃任务，但是不抛出异常。可能导致无法发现系统的异常状态。
DiscardOldestPolicy：丢弃队列最前面的任务，然后重新提交被拒绝的任务。
CallerRunsPolicy：由调用线程处理该任务。