线程池的使用和原理分析

最新推荐文章于 2024-07-06 13:51:47 发布
最新推荐文章于 2024-07-06 13:51:47 发布
阅读量150 收藏 1
点赞数
分类专栏： Java系列 源码系列 文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43731074/article/details/104997692
版权

首先看一下类图
C:\Users\WJ\AppData\Roaming\Typora\typora-user-images\i

线程池的执行流程

在这里插入图片描述

在这里插入图片描述

线程池整个流程：

  1. 创建线程池，开始等待请求
  2. 调用execute()方法添加一个请求任务时，线程池会判断
    1. 如果正在运行的线程数雄安与核心线程数，那么会创建线程运行这个任务
    2. 如果正在运行的线程数大于或者等于核心线程数，则将这个任务放入队列中
    3. 如果这个队列满了，而且线程数论小于最大线程数，则创建非核心线程执行任务
    4. 如果队列满了，而且正在运行的线程数也大于或者等于最大线程数，则线程池启动包和拒绝策略来处理
  3. 当一个线程完成任务时，则从队列里取下一个任务来执行。
  4. 当一个线程无事可走超过了活跃时间，则判断当前线程数是否大于核心线程，如果大于则关闭线程到核心线程数，否则核心数的线程个数保持活跃
线程池的拒绝策略

JDK中默认提供了4种拒绝策略，并且都 实现RejectedExecutionHandle接口

  1. AbortPolicy(默认)：直接抛出RejectExecutionException异常阻止系统正常运行
  2. CallerRunsPolicy：调用者运行“一种调节机制，该策略即不会抛弃任务，也不会抛出异常，而是将某些任务回退到调用者，从而降低新的任务流量”
  3. DiscardOldestPolic：抛弃队列中等待的最久的任务，然后把当前任务加入队列中，再尝试再次提交当前任务。
  4. DiscardPolic：该策略默默地丢弃无法处理的任务，不予以任何处理也不抛弃异常，如果允许任务丢失，这是一种最后的策略。

先看一下线程池的基本使用：

/**
  *@Author:苏牧夕
  *@Date:2020/3/19 23:24
  *@Version 1.0
 */
public class ThreadPool {
    //单例线程池
    static class InstancePool{
       public static ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
               2,//核心数
               4,
//               Runtime.getRuntime().availableProcessors(),//获取cpu的核数
               30, //空闲非线程的存活时间
               TimeUnit.SECONDS,//时间类型
               new LinkedBlockingQueue<>(2),//阻塞队列
//               new ThreadPoolExecutor.AbortPolicy()
//               new ThreadPoolExecutor.DiscardOldestPolicy()
//               new ThreadPoolExecutor.DiscardPolicy()
               new ThreadPoolExecutor.CallerRunsPolicy()//包和拒绝策略
       );
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        AtomicInteger ctl = new AtomicInteger();
       //根据构造线程池的参数可以指定执行的最大任务数是阻塞队列大小+cpu核数
        //这里直接使用2+4=6任务数
        for (int i=0 ; i<30 ; i++){
            int j=i;
            InstancePool.poolExecutor.execute(()->{
                System.out.println(Thread.currentThread().getName()+",任务编号："+j);
            });
        }
             InstancePool.poolExecutor.shutdown();
    }
    //===============运行结果===============
    /**
     * 使用默认拒绝策略
     * 从结果看到，任务执行到第7个就直接拒绝了抛异常
     * pool-1-thread-1,任务编号：0
     * Exception in thread "main" pool-1-thread-1,任务编号：2
     * pool-1-thread-1,任务编号：3
     * java.util.concurrent.RejectedExecutionException: Task jdk8.ThreadPool$$Lambda$1/1149319664@568db2f2 rejected from java.util.concurrent.ThreadPoolExecutor@378bf509[Running, pool size = 4, active threads = 4, queued tasks = 2, completed tasks = 0]
     * 	at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2063)
     * 	at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:830)
     * 	at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1379)
     * 	at jdk8.ThreadPool.main(ThreadPool.java:33)
     * pool-1-thread-2,任务编号：1
     * pool-1-thread-3,任务编号：4
     * pool-1-thread-4,任务编号：5
     */
    /**
     * 使用DiscardOldestPolicy() 丢弃老任务执行新任务，但不抛出异常
     * pool-1-thread-2,任务编号：1
     * pool-1-thread-2,任务编号：28
     * pool-1-thread-2,任务编号：29
     * pool-1-thread-1,任务编号：0
     * pool-1-thread-4,任务编号：5
     * pool-1-thread-3,任务编号：4
     */
    /**
     * DiscardPolicy()，不抛异常，也不处理
     *pool-1-thread-2,任务编号：1
     * pool-1-thread-4,任务编号：5
     * pool-1-thread-1,任务编号：0
     * pool-1-thread-4,任务编号：3
     * pool-1-thread-2,任务编号：2
     * pool-1-thread-3,任务编号：4
     */
    /**
     * CallerRunsPolicy() 不抛出异常，交给调用者线程去处理
     * 可以发现任务全部执行完成
     * ....
     *main,任务编号：28
     * main,任务编号：29
     * pool-1-thread-2,任务编号：1
     * pool-1-thread-2,任务编号：2
     * pool-1-thread-2,任务编号：3
     * pool-1-thread-1,任务编号：0
     * pool-1-thread-3,任务编号：4
     * pool-1-thread-4,任务编号：5
     */
}

从上面各种拒绝策略及运行结果可以看出，线程执行完成自己任务后就从任务队列里面取任务来执行，但是会因为线程池装载任务的数量限制而有可能出现任务丢失，这也是为什么后来出现了支持sumit提交一个callable的任务，该方法是支持异步任务，任务提交给线程后会立刻继续接其他任务，就好像工厂接单生产任务，先接单然后慢慢生产，Callable底层是通过FutureTask包装起来的，因此个人感觉submit+callable来提交任务比较好，丢失任务的几率更小。

下面看一下基于默认拒绝策略下使用callable+sumit来提交任务的结果：

public class ThreadPool {
    //单例线程池
    static class InstancePool{
       public static ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(
               2,//核心数
               4,
//               Runtime.getRuntime().availableProcessors(),//获取cpu的核数
               30, //空闲非线程的存活时间
               TimeUnit.SECONDS,//时间类型
               new LinkedBlockingQueue<>(2),//阻塞队列
               new ThreadPoolExecutor.AbortPolicy()
//               new ThreadPoolExecutor.DiscardOldestPolicy()
//               new ThreadPoolExecutor.DiscardPolicy()
//               new ThreadPoolExecutor.CallerRunsPolicy()//包和拒绝策略
       );
    }
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        AtomicInteger ctl = new AtomicInteger();
       //根据构造线程池的参数可以指定执行的最大任务数是阻塞队列大小+cpu核数
        //这里直接使用2+4=6任务数
        for (int i=0 ; i<30 ; i++){
            int j=i;
            InstancePool.poolExecutor.submit(() -> {
                System.out.println(Thread.currentThread().getName() + ",任务编号：" + j);
//                return j;
            }).get();
        }
        InstancePool.poolExecutor.shutdown();
    }
    /**
     * pool-1-thread-1,任务编号：0
     * pool-1-thread-2,任务编号：1
     * pool-1-thread-1,任务编号：2
     * pool-1-thread-2,任务编号：3
     * pool-1-thread-1,任务编号：4
     * pool-1-thread-2,任务编号：5
     * pool-1-thread-1,任务编号：6
     *..................
     * pool-1-thread-1,任务编号：20
     * pool-1-thread-2,任务编号：21
     * pool-1-thread-1,任务编号：22
     * pool-1-thread-2,任务编号：23
     * pool-1-thread-1,任务编号：24
     * pool-1-thread-2,任务编号：25
     * pool-1-thread-1,任务编号：26
     * pool-1-thread-2,任务编号：27
     * pool-1-thread-1,任务编号：28
     * pool-1-thread-2,任务编号：29
     */

可以看到执行完成了所以任务，线程复用率更大了

下面是线程池源码分析：

首先分析ThreadPoolExecutor这个核心创建线程池类：

  • 先分析一下全局变量的作用

       //用来标记线程池的状态(高三位)，和线程数(低29位)
   private final AtomicInteger ctl = new AtomicInteger(ctlOf(RUNNING, 0));
   
   //线程个数掩码位数
    private static final int COUNT_BITS = Integer.SIZE - 3;
    
    //线程最大个数(低29位)00011111111111111111111111111111
    private static final int CAPACITY   = (1 << COUNT_BITS) - 1;

    // 下面几种是线程池状态，
    //（高3位）：11100000000000000000000000000000
    //该状态标识接收任务并且处理阻塞队列的任务
    private static final int RUNNING    = -1 << COUNT_BITS;

    //（高3位）：00000000000000000000000000000000
    //拒绝任务但是处理阻塞队列里面的任务
    private static final int SHUTDOWN   =  0 << COUNT_BITS;

    //（高3位）：00100000000000000000000000000000
    //拒绝新任务并且抛弃阻塞队里的任务，同时会中断正在处理的任务
    private static final int STOP       =  1 << COUNT_BITS;

    //（高3位）：01000000000000000000000000000000
    //所以任务的执行完成，当前线程池活动线程为0，准备调用terminated方法
    private static final int TIDYING    =  2 << COUNT_BITS;
    
    //（高3位）：01100000000000000000000000000000
    //终止状态
    private static final int TERMINATED =  3 << COUNT_BITS;
    // 获取高三位 运行状态
    private static int runStateOf(int c)     { return c & ~CAPACITY; }

    //获取低29位 线程个数
    private static int workerCountOf(int c)  { return c & CAPACITY; }

    //计算ctl新值，线程状态 与 线程个数
    private static int ctlOf(int rs, int wc) { return rs | wc; }

	//任务阻塞队列
    private final BlockingQueue<Runnable> workQueue;

	//重入锁，在添加工作线程，修改状态等地方用到
    private final ReentrantLock mainLock = new ReentrantLock();

	//存储工作线程的哈希表
    private final HashSet<Worker> workers = new HashSet<Worker>();

   //锁的条件，用来配合重入锁实现唤醒等待相关操作
    private final Condition termination = mainLock.newCondition();
   
   //用来追踪线程池实际大小。
    private int largestPoolSize;
  
    //完成的任务数
    private long completedTaskCount;
   
    //线程工厂
    private volatile ThreadFactory threadFactory;
	//拒绝策略
    private volatile RejectedExecutionHandler handler;
	//非核心线程空闲存活时间
    private volatile long keepAliveTime;
    //核心线程是否一直存活还是存活一段时间
    private volatile boolean allowCoreThreadTimeOut;
   //核心线程的大小
    private volatile int corePoolSize;
    //最大线程数
    private volatile int maximumPoolSize;
    //使用默认拒绝策略，直接抛出异常
    private static final RejectedExecutionHandler defaultHandler =
        new AbortPolicy();
    //下面是相关权限参数
    private static final RuntimePermission shutdownPerm =
        new RuntimePermission("modifyThread");

    private final AccessControlContext acc;

  • 核心构造方法

    //这是完整参数的构造方法，其他那些不完整的使用默认值
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;
    }

  • 下面中execute()方法开始分析

    execute方法中执行逻辑就是开头写的几种情况

      //该方法是向线程池提交runnable任务的方法
  public void execute(Runnable command) {
  //检测参数是否非法
        if (command == null)
            throw new NullPointerException();
   //下面开始便上开头说的几种情况 
    //获取当前存活的线程数
        int c = ctl.get();
        //1.如果小于核心线程数则直接调用addWorker创建工作线程，
        //并且开始任务，该方法后面分析
        if (workerCountOf(c) < corePoolSize) {
            if (addWorker(command, true))
                return;
          // 如果创建失败，则重写获取存活线程数     
            c = ctl.get();
        }
        //2.核心数满的情况或者其他情况使工作线程创建失败时，
        //判断是否是接收任务并处理的状态，如果是则直接向任务队列添加任务
        if (isRunning(c) && workQueue.offer(command)) {
           //再次检查存活的工作线程数
            int recheck = ctl.get();
            //4.再次判断如果非接收任务和处理的状态则异常该任务，执行拒绝策略。
            if (! isRunning(recheck) && remove(command))
                reject(command);
            //如果工作线程数等于0即线程池为空还没有形成，则直接添加工作线程
            else if (workerCountOf(recheck) == 0)
                addWorker(null, false);
        }
        //3.队列满了，则添加新工作形成，如果新增失败则执行拒绝策略
        else if (!addWorker(command, false))
            reject(command);
    }

  • 接着分析线程池是如何添加新的工作线程的，即addWorker方法

    添加工作线程的基本逻辑：

    1. 先获取线程池和存储线程个数的集合体，然后根据集合体获取当前线程池的状态，然后对线程池的状态和工作队列进行判断，如果线程池已经处于不接收任务或者拒绝处理的状态并且工作队列不为空则直接返回false表示添加工作线程失败。

    2. 如果条件1成立，则再通过循环cas对工作线程个数进行修改+1，不过会重新获取当前线程池工作线程个数看是否超限制，如果超限制也直接返回失败，否则进行cas修改工作线程个数，如果修改成功直接跳出大循环进入后续相关操作，否则失败则判断当前线程池状态是否与刚刚进入大循环的状态一致如果不一致，则重新进入大循环，如果状态一致则继续循环cas修改操作，直到修改一次成功后退出循环。

    3. 如果条件2通过cas修改工作线程个数成功，则进行最后两个步骤：

      1. 把新增的工作线程添加的线程池的工作线程集合中；

        首先根据传入的任务创建一个工作线程对象实例，并且获取该对象实例的线程，判断是否为null，如果非null，则开始用重入锁上锁保证原子性下在进行添加操作，添加操作过程是：先获取当前线程池的状态和判断是否还可以接收任务和处理任务，如果还可以接收并处理任务，在进一步判断该线程是否存活，如果存活则添加到工作线程集合中，修改添加标记，然后获取工作线程集合的大小与追踪大小比较并且进行相关修改，然后解锁。

      2. 在线程添加到工作线程集合成功的前提下，让该线程开始执行任务。

        线程开始的过程：首先更加上述添加标记是否成功添加，如果成功添加，则让线程开始工作，并修改线程是否开始运行的标记。

    4. 如果条件2通过，最后对上述添加标记进行判断，如果没添加成功，则调用添加失败的处理方法，先上锁保证原子性，再判断该工作线程对象实例是否为null,如果不为空则，在工作线程的集合里面移除该对象。

        private boolean addWorker(Runnable firstTask, boolean core) {
        //这是一个标记，后面使用这个进行再次进入循环用
        retry:
        for (;;) {
        //获取当前线程池的状态+线程个数变量的组合值
            int c = ctl.get();
            //获取线程池当前状态
            int rs = runStateOf(c);
			//检查队列是否为空，和当前线程池是否处于接收任务和处理任务状态，如果不则直接返回false表示失败
            // Check if queue empty only if necessary.
            if (rs >= SHUTDOWN &&
                ! (rs == SHUTDOWN &&
                   firstTask == null &&
                   ! workQueue.isEmpty()))
                return false;
         //通过循环进行cas修改工作线程存活的个数
            for (;;) {
            //根据c组合值来获取工作线程数
                int wc = workerCountOf(c);
                //判断工作线程数是否大于容量或者是否大于最大核心数，如果超了则直接返回false
                if (wc >= CAPACITY ||
                    wc >= (core ? corePoolSize : maximumPoolSize))
                    return false;
              //如果上述条件都通过，则通过cas修改工作线程个数+1
                if (compareAndIncrementWorkerCount(c))
                    break retry;//如果成功修改则直接退出retr这个大循环，以上是只有修改一次成功则循环结束。
             //再次获取 线程池状态和各种线程个数的组合
                c = ctl.get();  // Re-read ctl
                //重写判断状态，如果和开始进来的状态不同则重新开始retry大循环。
                if (runStateOf(c) != rs)
                    continue retry;
                // 否则继续内循环cas,直到修改成功
            }
        }
//到这里证明已经通过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 {
                    //获取线程池当前状态
                    int rs = runStateOf(ctl.get());
					//判断线程池是否处于接收任务和处理任务状态
                    if (rs < SHUTDOWN ||
                        (rs == SHUTDOWN && firstTask == null)) {
                        //进一步判断，该工作线程是否是存活的
                        if (t.isAlive()) // precheck that t is startable
                            throw new IllegalThreadStateException();
                       //如果存活则把该线程添加到工作线程的集合里面
                        workers.add(w);
                        //获取工作线程集合的大小
                        int s = workers.size();
                        //如果当下工作线程数大于追踪的线程数，则修改
                        if (s > largestPoolSize)
                            largestPoolSize = s;
                       //修改状态改为添加成功
                        workerAdded = true;
                    }
                } 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 {
        //如果工作线程对象不为null的情况下调用工作线程集合进行移除该对象实例
            if (w != null)
                workers.remove(w);
                //调用cas修改工作线程数
            decrementWorkerCount();
            //尝试终止
            tryTerminate();
        } finally {
        //最后解锁
            mainLock.unlock();
        }
    }

  • 接着分析工作线程类的run方法

    简单来阐述一下工作线程对象worker调用run方法后的执行逻辑以及执行完自己任务后如何从任务队列获取来执行：

    1. 首先调用run方法后，在通过调用runWorker方法该方法是真正执行任务的方法，进入该方法后，首先获取当前线程用于中断，因为改方法是允许被中断的，再获取worker工作线程对象的任务，然后修改工作线程对象的任务置空，然后进入while循环判断任务是否为空，如果是空则通过getTask方法从任务队列里面获取任务
    2. 从getTask方法获取任务的逻辑如下
      1. 判断线程池的状态和任务阻塞队列是否为空，如果为空或者状态以及处于非处理任务和接收任务状态，则通过cas修改存活的工作线程数，直接返回null
      2. 工作线程数超过了最大线程数或者超时并且再次检查任务队列是否为null，如果条件成立通过cas修改工作线程数-1，直接返回null
      3. 如果条件1和条件2都成立，则开始从阻塞任务队列里面获取任务来执行，获取有两种方式一种是有时间限制，一种是没有时间限制。
    3. 如果任务不为空，则加锁，来保证原子性操作，在操作钱，再次判断线程池的状态是否符合执行任务和是否处于中断状态，如果是则进行中断，否则执行一些前置操作(默认是空实现)，然后执行任务run，执行后再进行一些后置操作(默认也是空实现)，并且对改工作线程的统计完成任务数+1，然后释放锁，一次任务完成后，继续循环从阻塞队列里获取任务，一直到没有任务后结束循环
    4. 最后通过processWorkerExit方法判断是否要把当前工作线程对象移出工作线程集合(队列)，这里移除条件会根据当前任务队列以及线程池的核心线程数来进行相关判断。
    //该方法是worker类的run方法，调用了ThreadPoolExecuto方法Workfn
public void run() {
            runWorker(this);
        }
  
    final void runWorker(Worker w) {
    //获取当前线程
        Thread wt = Thread.currentThread();
       //获取工作线程对象的任务
        Runnable task = w.firstTask;
        //获取任务后置空
        w.firstTask = null;
        //该工作线程允许允许中断
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try {l
      当前工作线程对象实例任务不为空，(或者当前工作线程的对象实例任务为空，则通过getTask方法从任务阻塞队列里面获取任务，如果还是获取不到任务则跳出循环)
            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);
                    Throwable thrown = null;
                    try {
                    //执行任务(或者runnable/callable接口的任务类)
                        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 {
                //执行完一个任务后，进行相关操作，对应的工作线程对象完成的任务书+1，并且解锁
                    task = null;
                    w.completedTasks++;
                    w.unlock();
                }
            }
           
            completedAbruptly = false;
        } finally {
        //最后进行把工作线程对象移除工作线程集合操作。
            processWorkerExit(w, completedAbruptly);
        }
    }

    private Runnable getTask() {
    //默认没有实际限制
        boolean timedOut = false; // Did the last poll() time out?
        for (;;) {
        //获取线程池状态和存活线程数的结合体32位二进制
            int c = ctl.get();
            //获取线程池状态
            int rs = runStateOf(c);

            // 判断是否处于接收任务和处理任务状态并且任务队列非空，如果是空则工作线程数-1，返回结束，在runwork方法后续会把该工作线程对象直接移出集合。
            if (rs >= SHUTDOWN && (rs >= STOP || workQueue.isEmpty())) {
                decrementWorkerCount();
                return null;
            }
			//获取工作线程的数量
            int wc = workerCountOf(c);

            // 判断是否有时间限制或超过核心数
            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
			//1.当前工作线程数超过了最大线程数并且任务队列也为空了则通过cas修改当前存活的工作线程数-1
			//2.当超时并且当前工作线程数>1或者任务队列为空，也进行工作线程数修改-1
			//如果通过cas修改成功则直接返回null,移除工作线程丢给上级操作
			//否则一直循环到修改成功。
            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;
            }
        }
    }

    到这里主要方法以及分析完成其他。

    接着分析一下Executors线程池工具类里面提高的四大线程池

    首先通过Executors来创建线程池在阿里开发者手册里面是极度不推荐的，原因是

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

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

      下面来看一下四种创建demo

      1. newFixedThreadPool(int n)-创建固定大小的线程池

      2. newScheduledThreadPool(int n)-创建一个定时器线程池，线程可复用

        public static void main(String[] args) {
     ScheduledExecutorService executorService = Executors.newScheduledThreadPool(5);
        System.out.println(executorService);
        executorService.scheduleAtFixedRate(() -> {
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName());
        }, 0, 500, TimeUnit.MILLISECONDS);
    }

      3. newSingleThreadExecutor()-创建只有一个线程的线程池

        public static void main(String[] args) throws InterruptedException {
 ExecutorService executorService = 			 Executors.newSingleThreadExecutor();
        System.out.println(executorService);
        for (int i = 0; i < 10; i++) {
            executorService.execute(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        TimeUnit.SECONDS.sleep(80);
    }

      4. newCachedThreadPool()-创建不限线程数上限的线程池，任何提交的任务都立即执行

        public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        System.out.println(executorService);
        for (int i = 0; i < 5; i++) {
            executorService.execute(() -> {
                try {
                    TimeUnit.MILLISECONDS.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName());
            });
        }
        System.out.println(executorService);
        TimeUnit.SECONDS.sleep(80);
        System.out.println(executorService);
    }

    接着看一下四种线程池的构造方法就知道为什么会出现oom

          //================newFixedThreadPool=========
   public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }
    public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }
    //================SingleThreadExecutor=========
    public static ExecutorService newSingleThreadExecutor() {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>()));
    }
    public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) {
        return new FinalizableDelegatedExecutorService
            (new ThreadPoolExecutor(1, 1,
                                    0L, TimeUnit.MILLISECONDS,
                                    new LinkedBlockingQueue<Runnable>(),
                                    threadFactory));
    }

    从上述两种线程池的构造函数可以看到，底层都是通过ThreadPoolExecutor来创建的，只是帮我们封装了一部分参数，但整因为这样，我们可以看到上面两种线程池只能手动设置线程数和线程工厂，但是一个线程池一次可以装载多少个任务是由阻塞队列+最大线程数来决定的，虽然我们控制了最大线程数，但是我们无法控制阻塞队列，因此阻塞队列可以无限装载任务，从而导致OOM异常。

    接着再看下面两种线程池：

        public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }
    
 public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }
    
    public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }

    从上面两种构造方法可以看出来，这两种线程池更离谱了，连最大线程数都无法手动设置，也会出现oom

    总结：四种线程池底层都是通过ThredPoolExecutor类来创建线程的，只是这几种线程池的阻塞队列不一样，因此我们可以手动通过ThreadPoolExecutor来创建线程池，而且还可以手动指定最大线程数，以及阻塞队列的大小，可以有效防止出现OOM

参考博客

渐入佳境o
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程中的Join
柯基的博客
09-16 2612
线程中join(强制执行)：当前线程执行完毕之后，才会执行后面程序，其他线程阻塞； 实例： public class ThreadJoin implements Runnable{ @Override public void run() { for (int i = 1; i < 1000; i++) { System.out.println("Join..."+i+"运行中"); } } public stat
Java 线程池详解（一）：线程池实现原理及使用
To be a great coder
07-22 2108
阿瑟东撒的
线程池的使用和原理
hongtaolong的博客
10-20 263
目录 一、线程池的作用 二、线程池的关系图 三、线程池的创建及参数 四、线程池的使用原理 五、线程池的使用   一、线程池的作用 随着cpu核数越来越多，不可避免的利用多线程技术以充分利用其计算能力。所以，多线程技术是服务端开发人员必须掌握的技术。线程的创建和销毁，都涉及到系统调用，比较消耗系统资源，所以就引入了线程池技术，线程池中有已经创建好的线程，可直接使用，并且使用完了，直接...
线程池的原理及实现
热门推荐
qq_31753145的博客
03-15 2万+
1、线程池简介：     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。     如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。                 一个线程
RejectedPolicy--CallerRunsPolicy
Cages的专栏
02-28 194
  package com.jerry.concurrency; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestCallerRun...
Java线程池的使用及原理分析
宋铮的博客
04-30 2486
概述         线程池是管理一组同构工作线程的资源池。合理利用线程池能够带来三个好处。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，...
线程池流程分析原理
caox_nazi的博客
02-27 193
线程池流程分析原理        1）首先，要清楚corePoolSize和maximumPoolSize的含义； 　　2）其次，要知道Worker是用来起到什么作用的； 　　3）要知道任务提交给线程池之后的处理策略，这里总结一下主要有4点： 如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务； 如果当前线程池中的线程数目&gt;=...
线程池原理分析
Baijp的博客
06-05 734
线程池原理分析什么是线程池？线程池作用ThreadPoolExecutor线程池四种创建方式线程池原理剖析合理配置线程池 什么是线程池？ Java中的线程池是运用场景最多的并发框架，几乎所有需要异步或并发执行任务的程序 都可以使用线程池。在开发过程中，合理地使用线程池能够带来3个好处。 第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 第二：提高响应速度。当任务到达时，任...
JAVA线程池的分析和使用
01-31
线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。我们可以通过ThreadPoolExecutor来...
详解Java线程池和Executor原理的分析
08-29
Java线程池和Executor原理分析 Java线程池和Executor原理是Java并发编程中非常重要的一部分。线程池是一个或者多个线程的集合，用户可以把需要执行的任务简单地扔给线程池，而不用过多的纠结与执行的细节。Java...
3.1.8.线程池的实现原理分析1
08-04
线程池是Java中一种高效的线程管理机制，它的出现是为了优化线程的创建和销毁过程，以提高系统的响应速度并合理利用系统资源。...理解线程池的实现原理和使用方式，对于开发高效、稳定的多线程应用至关重要。
线程池ThreadPoolExecutor底层原理源码分析
03-19
线程池ThreadPoolExecutor底层原理源码分析
基于线程池的工作原理与源码解读
08-28
本篇文章主要讲解了基于线程池的工作原理与源码解读，旨在帮助开发者更好地理解线程池的工作机制和实现原理。 一、线程池创建 线程池的创建主要涉及到ThreadPoolExecutor类的构造方法，参数包括： 1. ...
10.javaSE基础_JDBC编译程序(Driver+Statement+Connection+mysql数据库连接)
m0_61086522的博客
07-02 1202
JDBC是的缩写。它是Sun的Javasoft公司制定的Java数据库连接技术，是一套标准接口java.sql包中提供了JDBC API,通过它连接到各种数据库系统，编写访问数据库的程序。JDBC API不能直接访问数据库，它依赖于数据库厂商提供的JDBC Driver（JDBC驱动程序）
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 488
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
解决分布式环境下session共享问题
最新发布
shenxiaomo1688的博客
07-06 477
在分布式环境下，session会存在两个问题第一个问题:不同域名下，浏览器存储的jsessionid是没有存储的。比如登录时认证服务auth.gulimall.com存储了session，但是搜索服务search.gulimall.com是没有这个session的；
ShardingSphere
Casual_Lei的博客
07-04 617
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 298
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 202
maven配置使用nexus仓库
并发编程之线程与线程池.pptx
01-05
我们会深入分析AQS的实现原理，并通过实例展示如何使用AQS解决一些并发编程问题。 最后，我们会介绍线程的创建方式，包括继承Thread类、实现Runnable接口、实现Callable接口和使用线程池等。我们还会总结线程的生命...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值