Java 线程池

于 2024-02-23 10:29:58 发布
阅读量45 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 数据库 开发语言
原文链接：https://mp.weixin.qq.com/s?__biz=MzkzNzIwNDI0Nw==&mid=2247486713&idx=1&sn=661e651c45085853559add494211c6e0&chksm=c394006b6bc9faee71715143929e19c0c4f26516490291625fe9855d31ee7a3409619a9b1d03&scene=126&sessionid=0
本文详细介绍了JavaThreadPoolExecutor的构造器参数、核心线程、最大线程数、线程存活策略、任务队列以及拒绝策略。同时探讨了线程池状态的判断和常见Executors工具类的使用案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

线程的创建和销毁是昂贵的操作，会消耗大量的系统资源。线程池任务队列执行完成后会保留 corePoolSize 数量的线程，以备重复使用。这降低了线程创建和销毁的开销，提高了系统的性能和响应时间。

ThreadPoolExecutor

构造函数

线程池构造函数参数

  • corePoolSize   ： 核心线程数量 ，线程池里面会一直保留，没有任务时休眠，有任务时唤醒

  • maximumPoolSize ：  最大线程数量 ，当核心线程数量不够完成任务，而外开启新线程进行工作，整个线程池的线程总数。

  • keepAliveTime  ： 当新建线程超过了核心线程数，当没有任务时，非核心线程存活多久进行才销毁线程

  • unit ： keepAliveTime 的时间单位

  • workQueue ： 任务队列，当线程来不及处理任务时，存储在此队列里 这是一个阻塞队列的数据结构 关于阻塞队列 Java 队列介绍

  • threadFactory ： 线程工厂

  • handler ： 拒绝策略，当线程池线程数量已经到达最大值 maximumPoolSize ，且当 workQueue 任务队列无法添加任务时，如果继续再向线程池中添加任务时，决定线程池的操作策略。

线程工厂

线程池创建时线程时会调用 newThread() 方法 ，用于线程池创建线程时对线程进行统一配置 ，如给线程设置线程名,优先级等

public interface ThreadFactory {
    Thread newThread(Runnable r);
}

拒绝策略

  • CallerRunsPolicy ： 如果线程池没有停止，就在当前添加任务到线程池的线程直接运行

  • AbortPolicy ： 抛出 RejectedExecutionException 异常,线程池默认策略

  • DiscardPolicy ： 直接废弃任务，当什么都没发生

  • DiscardOldestPolicy ： 如果线程池没有停止，把任务队列里面一个老的任务删除，新任务添加上去

public interface RejectedExecutionHandler {
    
    void rejectedExecution(Runnable r, ThreadPoolExecutor executor);
}

线程池的状态

线程池使用一个 int 类型参数的前 3 位表示线程池的状态，后 29 位表示线程池的线程数量。并且通过原子类 AtomicInteger 包装，ctl 初始化为 RUNNING 状态，线程数量为 0.

通过打印成二机制，理解起来会更清楚。

COUNT_MASK ： 00011111111111111111111111111111
RUNNING    ： 11100000000000000000000000000000
SHUTDOWN   ： 00000000000000000000000000000000
STOP       ： 00100000000000000000000000000000
TIDYING    ： 01000000000000000000000000000000
TERMINATED ： 01100000000000000000000000000000
*/

线程池状态只看前 3位，

  • 只有 RUNNING 为负数，

  • SHUTDOWN 为 0.

  • STOP，TIDYING，TERMINATED 是正数的最高位 所以可以通过数值计算进行状态比较。

如 小于 SHUTDOWN 的只有 RUNNING ，通过这个能够判断线程池正在运行。

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
private static final int COUNT_BITS = Integer.SIZE - 3;
private static final int COUNT_MASK = (1 << COUNT_BITS) - 1;




private static final int RUNNING    = -1 << COUNT_BITS; 
private static final int SHUTDOWN   =  0 << COUNT_BITS; 
private static final int STOP       =  1 << COUNT_BITS;
private static final int TIDYING    =  2 << COUNT_BITS;
private static final int TERMINATED =  3 << COUNT_BITS;






private static int workerCountOf(int c)  { return c & COUNT_MASK; }
private static int ctlOf(int rs, int wc) { return rs | wc; }




private static boolean runStateLessThan(int c, int s) {
    return c < s;
}


private static boolean runStateAtLeast(int c, int s) {
    return c >= s;
}


private static boolean isRunning(int c) {
    return c < SHUTDOWN;
}


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;
}

  • RUNNING:  接收新的任务，并且处理入队的任务

  • SHUTDOWN: 不接收新的任务但是处理已经入队的任务

  • STOP:     不接收新的任务，也不处理入队的任务，中断正在处理任务的线程

  • TIDYING:  当所有的任务已被停止 ，线程数量为 0。线程池的状态为 TIDYING 然后会执行 terminated() 方法 ，terminated() 方法执行完成，状态会转移到 TERMINATED

  • TERMINATED: 线程池完全停止状态

RUNNINGSHUTDOWNSTOPTIDYINGTERMINATEDshutdown()shutdownNow()当线程池中所有线程已被终止并且任务队列为空当线程池中所有线程已被终止并且任务队列为空当 terminated() 执行完成RUNNINGSHUTDOWNSTOPTIDYINGTERMINATED线程池状态时序图

把任务添加到线程池进行执行

public void execute(Runnable command) {
    
    if (command == null)
        throw new NullPointerException();
    
    int c = ctl.get();
    
    if (workerCountOf(c) < corePoolSize) {
        
        if (addWorker(command, true))
            return;
        c = ctl.get();
    }
    
    if (isRunning(c) && workQueue.offer(command)) {
        int recheck = ctl.get(); 
        
        if (! isRunning(recheck) && remove(command))
            reject(command); 
         
         
        else if (workerCountOf(recheck) == 0) 
            addWorker(null, false); 
    }
    else if (!addWorker(command, false)) 
        reject(command); 
}

创建线程

修改ctl失败时 需要重新加载 ctl的值 。有两层无限循环进行检查
  第一层无限循环 有 retry 标记，检查了线程池的状态，是否停止
  第二层无限循环 检查的是线程池数量是否超过了设定值
*/
private boolean addWorker(Runnable firstTask, boolean core) {
    
    
    retry:
    for (int c = ctl.get();;) {
        
        
        
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP)
                || firstTask != null
                || workQueue.isEmpty()))
            return false;


        for (;;) {
            
            
            
            
            
            if (workerCountOf(c)
                >= ((core ? corePoolSize : maximumPoolSize) & COUNT_MASK))
                return false;
            
            if (compareAndIncrementWorkerCount(c))
                break retry;
            
            c = ctl.get();  
            
            
            if (runStateAtLeast(c, SHUTDOWN))
                continue retry;
            
        }
    }
    
    boolean workerStarted = false;
    boolean workerAdded = false;
    Worker w = null;
    try {
    
        w = new Worker(firstTask); 
        final Thread t = w.thread;
        if (t != null) {
            final ReentrantLock mainLock = this.mainLock;
            mainLock.lock();
            try {
                int c = ctl.get();
                if (isRunning(c) ||
                    (runStateLessThan(c, STOP) && firstTask == null)) {
                    
                    if (t.getState() != Thread.State.NEW)
                        throw new IllegalThreadStateException();
                    workers.add(w); 
                    workerAdded = true;
                    int s = workers.size();
                    if (s > largestPoolSize) 
                        largestPoolSize = s;
                }
            } finally {
                mainLock.unlock();
            }
            
            if (workerAdded) {
                t.start(); 
                workerStarted = true;
            }
        }
    } finally {
        
        if (! workerStarted)
            addWorkerFailed(w);
    }
    
    return workerStarted;
}




private void addWorkerFailed(Worker w) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        if (w != null)
            workers.remove(w); 
        decrementWorkerCount();  
        tryTerminate(); 
    } finally {
        mainLock.unlock();
    }
}

执行线程

Worker 继承 了 AbstractQueuedSynchronizer

private final class Worker
    extends AbstractQueuedSynchronizer
    implements Runnable
{
    final Thread thread;
    Runnable firstTask;
    volatile long completedTasks;


    Worker(Runnable firstTask) {
        setState(-1); 
        this.firstTask = firstTask;
        this.thread = getThreadFactory().newThread(this);
    }


   
    public void run() {
        runWorker(this);
    }
    
    
    protected boolean isHeldExclusively() {
        return getState() != 0;
    }


    protected boolean tryAcquire(int unused) {
        if (compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
            return true;
        }
        return false;
    }


    protected boolean tryRelease(int unused) {
        setExclusiveOwnerThread(null);
        setState(0);
        return true;
    }


    public void lock()        { acquire(1); }
    public boolean tryLock()  { return tryAcquire(1); }
    public void unlock()      { release(1); }
    public boolean isLocked() { return isHeldExclusively(); }


    void interruptIfStarted() {
        Thread t;
        if (getState() >= 0 && (t = thread) != null && !t.isInterrupted()) {
            try {
                t.interrupt();
            } catch (SecurityException ignore) {
            }
        }
    }
}


final void runWorker(Worker w) {
    Thread wt = Thread.currentThread();
    Runnable task = w.firstTask;
    w.firstTask = null;
    w.unlock(); 
    boolean completedAbruptly = true;  
    try {
       
       
        while (task != null || (task = getTask()) != null) {
            w.lock();
            
            if ((runStateAtLeast(ctl.get(), STOP) ||
                 (Thread.interrupted() &&
                  runStateAtLeast(ctl.get(), STOP))) &&
                !wt.isInterrupted())
                wt.interrupt();
            try {
                beforeExecute(wt, task); 
                try {
                    task.run(); 
                    afterExecute(task, null); 
                } catch (Throwable ex) {
                    afterExecute(task, ex);
                    throw ex;
                }
            } finally {
                task = null;  
                w.completedTasks++; 
                w.unlock(); 
            }
        }
        completedAbruptly = false; 
    } finally {
        
        processWorkerExit(w, completedAbruptly);
    }
}






private Runnable getTask() {
    boolean timedOut = false; 


    for (;;) {
        int c = ctl.get();


         
        
        
        if (runStateAtLeast(c, SHUTDOWN)
            && (runStateAtLeast(c, STOP) || workQueue.isEmpty())) {
            decrementWorkerCount(); 
            return null; 
        }


        int wc = workerCountOf(c); 
       
        
        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
        
        
        
        if ((wc > maximumPoolSize || (timed && timedOut))
            && (wc > 1 || workQueue.isEmpty())) {
            if (compareAndDecrementWorkerCount(c)) 
                return null;
            continue;
        }


        try {
            Runnable r = timed ? 
                workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
                workQueue.take(); 
            if (r != null) 
                return r;
            timedOut = true; 
        } catch (InterruptedException retry) {
            timedOut = false; 


        }
    }
}




private void processWorkerExit(Worker w, boolean completedAbruptly) {
    if (completedAbruptly) 
        decrementWorkerCount();


    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        completedTaskCount += w.completedTasks; 
        workers.remove(w); 
    } finally {
        mainLock.unlock();
    }
    
    tryTerminate();


    int c = ctl.get();
    
    if (runStateLessThan(c, STOP)) {
        
        if (!completedAbruptly) {
            
            int min = allowCoreThreadTimeOut ? 0 : corePoolSize;
            
            if (min == 0 && ! workQueue.isEmpty())
                min = 1; 
            
            if (workerCountOf(c) >= min)
                return; 
        }
        
        
        addWorker(null, false);
    }
}




final void tryTerminate() {
    for (;;) {
        int c = ctl.get();
        
        
        
        
        if (isRunning(c) ||
            runStateAtLeast(c, TIDYING) ||
            (runStateLessThan(c, STOP) && ! workQueue.isEmpty()))
            return;
        
        if (workerCountOf(c) != 0) { 
            interruptIdleWorkers(ONLY_ONE);
            return;
        }


        final ReentrantLock mainLock = this.mainLock;
        mainLock.lock();
        try {
            
            if (ctl.compareAndSet(c, ctlOf(TIDYING, 0))) {
                try {
                    terminated(); 
                } finally {
                    ctl.set(ctlOf(TERMINATED, 0));
                    termination.signalAll(); 
                }
                return;
            }
        } finally {
            mainLock.unlock();
        }
        
    }
}

停止线程池

public void shutdown() {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(SHUTDOWN); 
        interruptIdleWorkers(); 
        onShutdown(); 
    } finally {
        mainLock.unlock();
    }
    tryTerminate(); 
}




public List<Runnable> shutdownNow() {
    List<Runnable> tasks;
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        checkShutdownAccess();
        advanceRunState(STOP); 
        interruptWorkers(); 
        tasks = drainQueue(); 
    } finally {
        mainLock.unlock();
    }
    tryTerminate(); 
    return tasks;
}






private void advanceRunState(int targetState) {
    
    for (;;) {
        int c = ctl.get();
        if (runStateAtLeast(c, targetState) ||
            ctl.compareAndSet(c, ctlOf(targetState, workerCountOf(c))))
            break;
    }
}


private void interruptIdleWorkers() {
    interruptIdleWorkers(false);
}


private void interruptIdleWorkers(boolean onlyOne) {
    final ReentrantLock mainLock = this.mainLock;
    mainLock.lock();
    try {
        for (Worker w : workers) {
            Thread t = w.thread;
            
            if (!t.isInterrupted() && w.tryLock()) { 
                try {
                    t.interrupt(); 
                } catch (SecurityException ignore) {
                } finally {
                    w.unlock();
                }
            }
            if (onlyOne)
                break;
        }
    } finally {
        mainLock.unlock();
    }
}




private void interruptWorkers() {
    
    for (Worker w : workers)
        w.interruptIfStarted(); 
}

Executors

Executors 工具类提供了几个静态方法快速创建各种类型的线程池。

  • newCachedThreadPool()

    • 创建一个 0 核心线程数 ，最大线程数为 Integer.MAX_VALUE ，没有任务时线程保持存活 60 秒。 SynchronousQueue<Runnable>()是一个零容量的队列，不会保存元素用于后续的访问，当一个线程试图向中插入元素时，它会被阻塞，直到另一个线程从队列中取走这个元素，同样地，当一个线程试图从  中取走元素时，它也会被阻塞，直到另一个线程将元素放入队列中 。当有大量任务耗时任务添加到此线程池时，会创建大量线程，不会限制创建线程的数量，会消耗很多系统资源，甚至OOM 需要特别注意

  • newSingleThreadScheduledExecutor()

    • 创建单核心线程数为 1 ，最大线程数也为 1 ，阻塞队列 LinkedBlockingQueue<Runnable>() 可以保存  Integer.MAX_VALUE 任务 ，当有大量任务耗时任务添加到此线程池时，需要注意任务队列 OOM

  • newFixedThreadPool(int nThreads)

    • 创建固定线程数量的线程池 ，单核心线程数为 nThreads ，最大线程数也为 nThreads ，阻塞队列 也是 LinkedBlockingQueue<Runnable>() 需要注意任务队列 OOM

  • newScheduledThreadPool()

创建 ScheduledExecutorService ，可设置定时任务，周期任务的线程池 。阻塞队列DelayedWorkQueue() 也是可以保存Integer.MAX_VALUE 任务 ，当有大量任务耗时任务添加到此线程池时，需要注意任务队列 OOM

梦魇丿
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值