java多线程系列：ThreadPoolExecutor源码分析，java基础面试笔试题

最新推荐文章于 2021-12-15 21:16:47 发布
最新推荐文章于 2021-12-15 21:16:47 发布
阅读量169 收藏
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agoodcoder777/article/details/89648099
版权


我总结出了很多互联网公司的面试题及答案，并整理成了文档，以及各种学习的进阶学习资料，免费分享给大家。
扫描二维码或搜索下图红色VX号，加VX好友，拉你进【程序员面试学习交流群】免费领取。也欢迎各位一起在群里探讨技术。
推荐文章：Java 面试知识点解析；Mysql优化技巧（数据库设计、命名规范、索引优化

 

前言

 

这篇主要讲述ThreadPoolExecutor的源码分析，贯穿类的创建、任务的添加到线程池的关闭整个流程，让你知其然所以然。希望你可以通过本篇博文知道ThreadPoolExecutor是怎么添加任务、执行任务的，以及延伸的知识点。那么先来看看ThreadPoolExecutor的继承关系吧。

继承关系

Executor接口


public interface Executor {

    void execute(Runnable command);

}

Executor接口只有一个方法execute,传入线程任务参数

ExecutorService接口


public interface ExecutorService extends Executor {

    void shutdown();

    List<Runnable> shutdownNow();

    boolean isShutdown();

    boolean isTerminated();

    boolean awaitTermination(long timeout, TimeUnit unit)

        throws InterruptedException;

    <T> Future<T> submit(Callable<T> task);

    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,

                                  long timeout, TimeUnit unit)

        throws InterruptedException;

    

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)

        throws InterruptedException, ExecutionException;

   

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,

                    long timeout, TimeUnit unit)

        throws InterruptedException, ExecutionException, TimeoutException;

}

ExecutorService接口继承Executor接口，并增加了submit、shutdown、invokeAll等等一系列方法。

AbstractExecutorService抽象类


public abstract class AbstractExecutorService implements ExecutorService {

    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {

        return new FutureTask<T>(runnable, value);

    }

    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {

        return new FutureTask<T>(callable);

    }

    public Future<?> submit(Runnable task) {

        if (task == null) throw new NullPointerException();

        RunnableFuture<Void> ftask = newTaskFor(task, null);

        execute(ftask);

        return ftask;

    }

    public <T> Future<T> submit(Runnable task, T result) {

        if (task == null) throw new NullPointerException();

        RunnableFuture<T> ftask = newTaskFor(task, result);

        execute(ftask);

        return ftask;

    }

    public <T> Future<T> submit(Callable<T> task) {

        if (task == null) throw new NullPointerException();

        RunnableFuture<T> ftask = newTaskFor(task);

        execute(ftask);

        return ftask;

    }

    private <T> T doInvokeAny(Collection<? extends Callable<T>> tasks,

                              boolean timed, long nanos)

        throws InterruptedException, ExecutionException, TimeoutException {...}

    public <T> T invokeAny(Collection<? extends Callable<T>> tasks)

        throws InterruptedException, ExecutionException {... }

    public <T> T invokeAny(Collection<? extends Callable<T>> tasks,

                           long timeout, TimeUnit unit)

        throws InterruptedException, ExecutionException, TimeoutException {...}

    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)

        throws InterruptedException {...}

    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,

                                         long timeout, TimeUnit unit)

        throws InterruptedException {...}

}

AbstractExecutorService抽象类实现ExecutorService接口，并且提供了一些方法的默认实现，例如submit方法、invokeAny方法、invokeAll方法。

像execute方法、线程池的关闭方法（shutdown、shutdownNow等等）就没有提供默认的实现。

ThreadPoolExecutor

先介绍下ThreadPoolExecutor线程池的状态吧

线程池状态

int 是4个字节，也就是32位（注：一个字节等于8位）


//记录线程池状态和线程数量（总共32位，前三位表示线程池状态，后29位表示线程数量）

private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));

//线程数量统计位数29  Integer.SIZE=32 

private static final int COUNT_BITS = Integer.SIZE - 3;

//容量 000 11111111111111111111111111111

private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

//运行中 111 00000000000000000000000000000

private static final int RUNNING    = -1 << COUNT_BITS;

//关闭 000 00000000000000000000000000000

private static final int SHUTDOWN   =  0 << COUNT_BITS;

//停止 001 00000000000000000000000000000

private static final int STOP       =  1 << COUNT_BITS;

//整理 010 00000000000000000000000000000

private static final int TIDYING    =  2 << COUNT_BITS;

//终止 011 00000000000000000000000000000

private static final int TERMINATED =  3 << COUNT_BITS;

//获取运行状态（获取前3位）

private static int runStateOf(int c)     { return c & ~CAPACITY; }

//获取线程个数（获取后29位）

private static int workerCountOf(int c)  { return c & CAPACITY; }

private static int ctlOf(int rs, int wc) { return rs | wc; }



  •  
  • RUNNING：接受新任务并且处理阻塞队列里的任务


     
  • SHUTDOWN：拒绝新任务但是处理阻塞队列里的任务


     
  • STOP：拒绝新任务并且抛弃阻塞队列里的任务同时会中断正在处理的任务


     
  • TIDYING：所有任务都执行完（包含阻塞队列里面任务）当前线程池活动线程为0，将要调用terminated方法


     
  • TERMINATED：终止状态。terminated方法调用完成以后的状态


     

线程池状态转换

RUNNING -> SHUTDOWN

   显式调用shutdown()方法, 或者隐式调用了finalize()方法

(RUNNING or SHUTDOWN) -> STOP

   显式调用shutdownNow()方法

SHUTDOWN -> TIDYING

   当线程池和任务队列都为空的时候

STOP -> TIDYING

   当线程池为空的时候

TIDYING -> TERMINATED

   当 terminated() hook 方法执行完成时候

构造函数

有四个构造函数，其他三个都是调用下面代码中的这个构造函数


public ThreadPoolExecutor(int corePoolSize,

                          int maximumPoolSize,

                          long keepAliveTime,

                          TimeUnit unit,

                          BlockingQueue<Runnable> workQueue,

                          ThreadFactory threadFactory,

                          RejectedExecutionHandler handler) {

}

参数介绍

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

参数类型含义
corePoolSizeint核心线程数
maximumPoolSizeint最大线程数
keepAliveTimelong存活时间
unitTimeUnit时间单位
workQueueBlockingQueue存放线程的队列
threadFactoryThreadFactory创建线程的工厂
handlerRejectedExecutionHandler多余的的线程处理器（拒绝策略）

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

提交任务

submit


public Future<?> submit(Runnable task) {

    if (task == null) throw new NullPointerException();

    RunnableFuture<Void> ftask = newTaskFor(task, null);

    execute(ftask);

    return ftask;

}

public <T> Future<T> submit(Runnable task, T result) {

    if (task == null) throw new NullPointerException();

    RunnableFuture<T> ftask = newTaskFor(task, result);

    execute(ftask);

    return ftask;

}

public <T> Future<T> submit(Callable<T> task) {

    if (task == null) throw new NullPointerException();

    RunnableFuture<T> ftask = newTaskFor(task);

    execute(ftask);

    return ftask;

}

流程步骤如下




  1.  
  2. 调用submit方法，传入Runnable或者Callable对象


     
  3. 判断传入的对象是否为null，为null则抛出异常，不为null继续流程


     
  4. 将传入的对象转换为RunnableFuture对象


     
  5. 执行execute方法，传入RunnableFuture对象


     
  6. 返回RunnableFuture对象


     

流程图如下

execute


public void execute(Runnable command) {

   //传进来的线程为null，则抛出空指针异常

   if (command == null)

       throw new NullPointerException();

  

   //获取当前线程池的状态+线程个数变量

   int c = ctl.get();

   /**

    * 3个步骤

    */

   //1.判断当前线程池线程个数是否小于corePoolSize,小于则调用addWorker方法创建新线程运行,且传进来的Runnable当做第一个任务执行。

   //如果调用addWorker方法返回false，则直接返回

   if (workerCountOf(c) < corePoolSize) {

       if (addWorker(command, true))

           return;

       c = ctl.get();

   }

   //2.如果线程池处于RUNNING状态，则添加任务到阻塞队列

   if (isRunning(c) && workQueue.offer(command)) {

       //二次检查

       int recheck = ctl.get();

       //如果当前线程池状态不是RUNNING则从队列删除任务，并执行拒绝策略

       if (! isRunning(recheck) && remove(command))

           reject(command);

       //否者如果当前线程池线程空，则添加一个线程

       else if (workerCountOf(recheck) == 0)

           addWorker(null, false);

   }

   //3.新增线程，新增失败则执行拒绝策略

   else if (!addWorker(command, false))

       reject(command);

}

其实从上面代码注释中可以看出就三个判断，




  1.  
  2. 核心线程数是否已满


     
  3. 队列是否已满


     
  4. 线程池是否已满


     

然后根据这三个条件进行不同的操作，下图是Java并发编程的艺术书中的线程池的主要处理流程，或许会比较容易理解些

下面是整个流程的详细步骤




  1.  
  2. 调用execute方法，传入Runable对象


     
  3. 判断传入的对象是否为null，为null则抛出异常，不为null继续流程


     
  4. 获取当前线程池的状态和线程个数变量


     
  5. 判断当前线程数是否小于核心线程数，是走流程5，否则走流程6


     
  6. 添加线程数，添加成功则结束，失败则重新获取当前线程池的状态和线程个数变量,


     
  7. 判断线程池是否处于RUNNING状态，是则添加任务到阻塞队列，否则走流程10，添加任务成功则继续流程7


     
  8. 重新获取当前线程池的状态和线程个数变量


     
  9. 重新检查线程池状态，不是运行状态则移除之前添加的任务，有一个false走流程9，都为true则走流程11


     
  10. 检查线程池线程数量是否为0，否则结束流程，是调用addWorker(null, false)，然后结束


     
  11. 调用!addWorker(command, false)，为true走流程11，false则结束


     
  12. 调用拒绝策略reject(command)，结束


     

可能看上面会有点绕，不清楚的可以看下面的流程图

addWorker


private boolean addWorker(Runnable firstTask, boolean core) {

    retry:

    for (;;) {

        int c = ctl.get();

        int rs = runStateOf(c);

        // 检查当前线程池状态是否是SHUTDOWN、STOP、TIDYING或者TERMINATED

        // 且！（当前状态为SHUTDOWN、且传入的任务为null，且队列不为null）

        // 条件都成立则返回false

        if (rs >= SHUTDOWN &&

            ! (rs == SHUTDOWN &&

               firstTask == null &&

               ! workQueue.isEmpty()))

            return false;

        //循环

        for (;;) {

            int wc = workerCountOf(c);

            //如果当前的线程数量超过最大容量或者大于（根据传入的core决定是核心线程数还是最大线程数）核心线程数 || 最大线程数，则返回false

            if (wc >= CAPACITY ||

                wc >= (core ? corePoolSize : maximumPoolSize))

                return false;

            //CAS增加c，成功则跳出retry

            if (compareAndIncrementWorkerCount(c))

                break retry;

            //CAS失败执行下面方法，查看当前线程数是否变化，变化则继续retry循环，没变化则继续内部循环

            c = ctl.get();  // Re-read ctl

            if (runStateOf(c) != rs)

                continue retry;

        }

    }

    //CAS成功

    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 {

                

                //重新检查线程池状态

                //避免ThreadFactory退出故障或者在锁获取前线程池被关闭

                int rs = runStateOf(ctl.get());

                if (rs < SHUTDOWN ||

                    (rs == SHUTDOWN && firstTask == null)) {

                    if (t.isAlive()) // 先检查线程是否是可启动的

                        throw new IllegalThreadStateException();

                    workers.add(w);

                    int s = workers.size();

                    if (s > largestPoolSize)

                        largestPoolSize = s;

                    workerAdded = true;

                }

            } finally {

                mainLock.unlock();

            }

            //判断worker是否添加成功，成功则启动线程，然后将workerStarted设置为true

            if (workerAdded) {

                t.start();

                workerStarted = true;

            }

        }

    } finally {

        //判断线程有没有启动成功，没有则调用addWorkerFailed方法

        if (! workerStarted)

            addWorkerFailed(w);

    }

    return workerStarted;

}

这里可以将addWorker分为两部分，第一部分增加线程池个数，第二部分是将任务添加到workder里面并执行。

第一部分主要是两个循环，外层循环主要是判断线程池状态，下面描述来自Java中线程池ThreadPoolExecutor原理探究

  
rs >= SHUTDOWN &&

              ! (rs == SHUTDOWN &&

                  firstTask == null &&

                  ! workQueue.isEmpty())
 

展开！运算后等价于

  
s >= SHUTDOWN &&

               (rs != SHUTDOWN ||

             firstTask != null ||

             workQueue.isEmpty())
 

也就是说下面几种情况下会返回false：

 



  •  
  • 当前线程池状态为STOP，TIDYING，TERMINATED


     
  • 当前线程池状态为SHUTDOWN并且已经有了第一个任务


     
  • 当前线程池状态为SHUTDOWN并且任务队列为空


     
 

内层循环作用是使用cas增加线程个数，如果线程个数超限则返回false，否者进行cas，cas成功则退出双循环，否者cas失败了，要看当前线程池的状态是否变化了，如果变了，则重新进入外层循环重新获取线程池状态，否者进入内层循环继续进行cas尝试。

 

到了第二部分说明CAS成功了，也就是说线程个数加一了，但是现在任务还没开始执行，这里使用全局的独占锁来控制workers里面添加任务，其实也可以使用并发安全的set，但是性能没有独占锁好（这个从注释中知道的）。这里需要注意的是要在获取锁后重新检查线程池的状态，这是因为其他线程可可能在本方法获取锁前改变了线程池的状态，比如调用了shutdown方法。添加成功则启动任务执行。


 

所以这里也将流程图分为两部分来描述

第一部分流程图

第二部分流程图

Worker对象

Worker是定义在ThreadPoolExecutor中的finnal类，其中继承了AbstractQueuedSynchronizer类和实现Runnable接口，其中的run方法如下

public void run() {

    runWorker(this);

}

线程启动时调用了runWorker方法，关于类的其他方面这里就不在叙述。

runWorker


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();

            // 当线程池是处于STOP状态或者TIDYING、TERMINATED状态时，设置当前线程处于中断状态

            // 如果不是，当前线程就处于RUNNING或者SHUTDOWN状态，确保当前线程不处于中断状态

            // 重新检查当前线程池的状态是否大于等于STOP状态

            if ((runStateAtLeast(ctl.get(), STOP) ||

                 (Thread.interrupted() &&

                  runStateAtLeast(ctl.get(), STOP))) &&

                !wt.isInterrupted())

                wt.interrupt();

            try {

                //提供给继承类使用做一些统计之类的事情，在线程运行前调用

                beforeExecute(wt, task);

                Throwable thrown = null;

                try {

                    task.run();

                } catch (RuntimeException x) {

                    thrown = x; throw x;

                } catch (Error x) {

                    thrown = x; throw x;

                } catch (Throwable x) {

                    thrown = x; throw new Error(x);

                } finally {

                    //提供给继承类使用做一些统计之类的事情，在线程运行之后调用

                    afterExecute(task, thrown);

                }

            } finally {

                task = null;

                //统计当前worker完成了多少个任务

                w.completedTasks++;

                w.unlock();

            }

        }

        completedAbruptly = false;

    } finally {

        //整个线程结束时调用，线程退出操作。统计整个线程池完成的任务个数之类的工作

        processWorkerExit(w, completedAbruptly);

    }

}

getTask

getTask方法的主要作用其实从方法名就可以看出来了，就是获取任务


private Runnable getTask() {

    boolean timedOut = false; // Did the last poll() time out?

    //循环

    for (;;) {

        int c = ctl.get();

        int rs = runStateOf(c);

        //线程线程池状态和队列是否为空

        if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {

            decrementWorkerCount();

            return null;

        }

        //线程数量

        int wc = workerCountOf(c);

        

        boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

        //（当前线程数是否大于最大线程数或者）

        //且（线程数大于1或者任务队列为空）

        //这里有个问题(timed && timedOut)timedOut = false，好像(timed && timedOut)一直都是false吧

        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;

        }

    }

}

关闭线程池

shutdown

当调用shutdown方法时，线程池将不会再接收新的任务，然后将先前放在队列中的任务执行完成。

下面是shutdown方法的源码


public void shutdown() {

    final ReentrantLock mainLock = this.mainLock;

    mainLock.lock();

    try {

        checkShutdownAccess();

        advanceRunState(SHUTDOWN);

        interruptIdleWorkers();

        onShutdown(); // hook for ScheduledThreadPoolExecutor

    } finally {

        mainLock.unlock();

    }

    tryTerminate();

}

shutdownNow

立即停止所有的执行任务，并将队列中的任务返回


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;

}

shutdown和shutdownNow区别

shutdown和shutdownNow这两个方法的作用都是关闭线程池，流程大致相同，只有几个步骤不同，如下




  1.  
  2. 加锁


     
  3. 检查关闭权限


     
  4. CAS改变线程池状态


     
  5. 设置中断标志(线程池不在接收任务，队列任务会完成)/中断当前执行的线程


     
  6. 调用onShutdown方法（给子类提供的方法）/获取队列中的任务


     
  7. 解锁


     
  8. 尝试将线程池状态变成终止状态TERMINATED


     
  9. 结束/返回队列中的任务


     

总结

线程池可以给我们多线程编码上提供极大便利，就好像数据库连接池一样，减少了线程的开销，提供了线程的复用。而且ThreadPoolExecutor也提供了一些未实现的方法，供我们来使用，像beforeExecute、afterExecute等方法，我们可以通过这些方法来对线程进行进一步的管理和统计。

在使用线程池上好需要注意，提交的线程任务可以分为CPU 密集型任务和IO 密集型任务，然后根据任务的不同进行分配不同的线程数量。




  •  
  • CPU密集型任务：
     



    •  
    • 应当分配较少的线程，比如 CPU个数相当的大小


       



     
  • IO 密集型任务：
     



    •  
    • 由于线程并不是一直在运行，所以可以尽可能的多配置线程，比如 CPU 个数 * 2


       



     
  • 混合型任务：
     



    •  
    • 可以将其拆分为 CPU 密集型任务以及 IO 密集型任务，这样来分别配置。


       



     

好了，这篇博文到这里就结束了，文中可能会有些纰漏，欢迎留言指正。

如果本文对你有所帮助，给个star呗，谢谢。本文GitHub地址：点这里点这里

参考资料




  1.  
  2. 并发编程网-Java中线程池ThreadPoolExecutor原理探究


     
  3. Java并发编程的艺术


     

 


转载：https://www.cnblogs.com/fixzd/p/9253203.html

推荐内容：
java面试题之----HashMap常见面试题总结
Java 微服务框架选型（Dubbo 和 Spring Cloud？）
Java面试官最常问的volatile关键字
推荐几个IDEA插件，Java开发者撸码利器。
java实现HTTP请求的三种方式
【面试题】2018年最全Java面试通关秘籍汇总集！
最新Java技术
2019 Java面试题
Java数据结构和算法（十一）——红黑树
面试 12：玩转 Java 快速排序

 

[Java]ThreadPoolExecutor源码分析
HeapStackk的博客
05-24 621
ThreadPoolExecutor 使用线程池来处理提交的线程任务，该类主要用来处理两大问题：1.提升大量异步任务的执行性能。2.同时也提供任务完成情况信息。 通常我们要使用ThreadPoolExecutor 可以通过其构造类方法，或者使用Executors工厂类的到ThreadPoolExecutor。 如果使用构造类方法，我们需要懂其中几个必要的构造参数： publi
2024年Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
最新发布
2301_82257383的博客
05-02 1036
在多线程编程中,线程池是一种非常重要的工具。它可以帮助我们高效地管理线程资源,避免频繁创建和销毁线程带来的性能开销。Java中提供了强大的线程池实现,如 ThreadPoolExecutor ,但有时我们可能希望了解其内部原理,并实现一个简单的线程池来加深对其工作机制的理解，手写线程池也是很多大厂常考的笔试题。开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。
java多线程系列：ThreadPoolExecutor源码分析
weixin_33862188的博客
07-02 114
前言 这篇主要讲述ThreadPoolExecutor的源码分析，贯穿类的创建、任务的添加到线程池的关闭整个流程，让你知其然所以然。希望你可以通过本篇博文知道ThreadPoolExecutor是怎么添加任务、执行任务的，以及延伸的知识点。那么先来看看ThreadPoolExecutor的继承关系吧。 继承关系 Executor接口 public interface Executor { ...
Java ThreadPoolExecutor 源码分析
爱技术，爱生活
04-09 245
1.背景    了解过Java线程池的同学一定对Executors不陌生，我们可以用它的静态方法很快的创建出我们需要的线程池，比如：我们需要一个固定数目的线程池，那么可以这样：     Executors.newFixedThreadPool(5)  创建一个只有5个线程的线程池。也可以通过：     Executors.newCachedThreadPool()  创建一个没有数量限制的线程池。...
Java 线程池 --- ThreadPoolExecutor源码分析
小张的专栏
01-23 860
在多线程编程中，或多或少都听过或者使用过线程池，合理利用线程池能够带来三个好处。 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 但是要做到合理的利用线程池，必
线程池TreadPoolExecutor
超帅哥哥的人生巅峰
10-01 460
线程池的工作原理： 1.如果当前运行的线程少于corePoolSize(线程池的基本大小），则创建新线程来执行任务。2.如果运行的线程等于或者多与corePoolSize，则将任务加入BlockingQueue（阻塞队列）3.如果无法将任务加入BlockingQueue（队列已满），则创建新的线程来处理任务。4.如果创建新线程将使当前运行的线程超出maximumPoolSize（线程池的最大数量）
java面试笔试题大汇总
03-01
**Java面试笔试题大汇总** 在Java开发领域，面试和笔试是评估候选人技术能力的重要环节。这份资料集合了大量常见的Java面试和笔试题，旨在帮助求职者或开发者巩固基础，提高解决问题的能力。以下是对其中一些关键...
膜拜大牛！编程猫java笔试题
m0_57983447的博客
05-19 671
前言 面试技巧另外开篇再说，先上面试干货吧。面试的题目并不一定有严格的顺序关系，有的是从前一个问题延伸而来，（探究的是一个知识的深度），有的是考察面试者的知识广度、有的纯粹是我想到哪里写到哪里的啦。。不要太在意哈，最近工作有点忙。 1.笔试常见的问题？ 面试常见的问题上面给的面试题链接基本都有。我只提几点： 写SQL：写SQL很常考察group by、内连接和外连接。 手写代码：手写代码一般考单例、排序、线程、消费者生产者。我建议排序算法除了冒泡排序，最好还能手写一种其他的排序代码。试想：如果一般面试者都
java笔试题大全
03-21
Java笔试题大全主要涵盖的是Java编程语言的基础知识、进阶概念以及常见的面试问题。这个资源可能包含了一系列关于Java编程的问题，旨在帮助准备Java程序员的笔试或面试。由于没有提供具体的题目内容，我会根据常见的...
线程池（ThreadPoolExecutor）源码解析
小志的博客
12-15 7325
目录一、线程池概念介绍1.1、什么是线程池1.2、线程池工作流程1.3、线程池的代码用例二、源码解析——构造函数2.1、线程池的构造函数及类的继承关系2.2、Executors提供的线程池模板2.3、拒绝策略的实现2.4、任务队列BlockingQueue的实现三、 源码解析——execute(Runnable command)3.1、流程概述 一、线程池概念介绍 1.1、什么是线程池 池化技术其实在技术生态圈中是比较常见的，比如：对象池、连接池等等。 为什么会有线程池这个东西存在呢？其实原因跟其他池化技
Java线程池架构原理和源码解析(ThreadPoolExecutor)
iteye_14356的博客
03-25 513
在前面介绍JUC的文章中，提到了关于线程池Execotors的创建介绍，在文章：《java之JUC系列-外部Tools》中第一部分有详细的说明，请参阅； 文章中其实说明了外部的使用方式，但是没有说内部是如何实现的，为了加深对实现的理解，在使用中可以放心，我们这里将做源码解析以及反馈到原理上，Executors工具可以创建普通的线程池以及schedule调度任务的调度池，其实两者实现上还是有一些区...
ThreadPoolExecutor源码解析（基于Java1.8）
Rebirth_Love的博客
07-19 4559
第一部分：ThreadPoolExecutor的继承结构 根据上图可以知道，ThreadPoolExecutor是继承的AbstractExecutorService（抽象类）。再来看一下AbstractExecutorService的结构可以发现，AbstractExecutorService实现了ExecutorService，并且ExecutorService继承Executor接
Java ThreadPoolExecutor线程池原理及源码分析
Schelor的专栏
02-21 2839
一、源码分析（基于JDK1.6） ThreadExecutorPool是使用最多的线程池组件，了解它的原始资料最好是从从设计者（Doug Lea）的口中知道它的来龙去脉。在Jdk1.6中，ThreadPoolExecutor直接继承了AbstractExecutorService,并层级实现了ExecutorService和Executor接口。 1.Executor Executor是
LettuceConnectionFactory多配置，及配置原理详解
热门推荐
qq_42394457的博客
07-02 4万+
先说一下怎么配置不同的redis源吧. 配置文件 application.properties: #########--------------------------------------> Redis 配置,因为是不同的数据库, 所以需要配置不同的 redisTemplate ############设置缓存为 Redis spring.cache.type=redis...
springboot之redis集成(遇到的那些坑)
狂奔的蜗牛
07-14 9596
一.集成过程 redis在阿里云已经搭建好，本地用单元测试也通过了，本以为使用springboot接入很easy，但是遇到了很多的坑 首先列一下springboot接入redis的步骤 1.在yml中配置一下redis的地址及端口，配置host主机地址和port端口即可即可 2.创建JedisConnectionFactory连接，读取yml中的地址及端口；创建redisTemplate，...
java多线程面试题（上机代码实现）
xcc_2269861428的博客
03-10 6187
1、编写线程、实现子线程先循环10次、接着主线程循环20、再接着子线程循环10次、主线程循环20次、反复进行50次package com.interview_questions.first; public class OrderThread { private boolean flag=false; //子线程 public synchronized void sub(){ wh...
springboot2整合redis使用lettuce连接池（解决lettuce连接池无效问题）
qq_41921994的博客
11-12 3万+
添加依赖 dependencies { implementation 'org.springframework.boot:spring-boot-starter-jdbc' implementation 'org.springframework.boot:spring-boot-starter-data-redis' implementation 'org.springframework.boot:spring-boot-starter-thymeleaf' implem.
ThreadPoolExecutor 源码解析
chenlixin19670820的博客
08-02 298
Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。合理地使用线程池能够带来3个好处： 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。 提高线程的可管理...
Java面试题合集：基础篇与笔试试题
"这篇资源是一份综合性的Java面试题集合，涵盖了从基础到高级的各种问题，包括但不限于Java的基础知识、线程、JSP、JDBC、JDO、XML、EJB、J2EE、MVC、UML、CORBA、编程题以及代码查错等各个方面。这份资料由tntxia在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值