java线程池

jojo2311111

已于 2024-07-03 23:58:46 修改

阅读量724

点赞数 24

分类专栏：基础知识原理 java 文章标签： java 开发语言

于 2024-05-19 20:28:34 首次发布

本文链接：https://blog.csdn.net/qq_34267204/article/details/139045961

版权

java 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

基础知识原理

2 篇文章 0 订阅

订阅专栏

线程池是生产者消费者模式，它解决的问题是协调生产者和消费者的速率，同时避免线程切换，提升运行速度。

下面是我对线程池的一些理解，主要原理图如下：

一、java线程池原理

参考如下文章

手写线程池（简化版）-CSDN博客

核心一：死循环获取任务执行

初始化一些线程，它们一直执行一个while死循环方法，在该方法中，不停地去blockingqueue中获取任务，然后执行，如下：

    private void runWorker(Worker worker) {
        if(worker==null) throw new NullPointerException("空的工作线程");
        try {
            Runnable firstTask = worker.firstTask;
            Thread wk = worker.thread;
            worker.firstTask = null;
            // 当前的任务先给他完成了
            while(firstTask!=null || (firstTask=getTask())!=null){
                // 如果执行线程池的stop方法，所有工作队里都要进行interrupted
                if(wk.isInterrupted()){
                    System.out.println("this thread is interrupted");
                }
                if(status.get()==STOP){
                    System.out.println("this threadPoll has already stopped");
                }

                firstTask.run();
                firstTask = null;
                worker.finishTaskCount++;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            // 没任务了退出
            while (true){
                // 原子类的操作有可能失败，所以要不停重试，直到成功为止
                if(casDeleteWorkerCount()){
                    finishedTaskCount += worker.finishTaskCount;
                    break;
                }else{
                    continue;
                }
            }
            L.lock();
            try {
                workers.remove(worker);
            } finally {
                L.unlock();
            }
        }
    }

核心二：阻塞队列协调生成者消费者速率

如果一直死循环下去，对cpu是比较大的浪费，blockingqueue可以让线程在没有任务时，阻塞停止获取任务，当有任务时再唤醒线程。同时插入任务时，队列满了也能执行拒绝策略，阻断生成者。

二、blockingqueue原理

线程池主要核心是阻塞队列，下面再看下阻塞队列的原理：

blockingqueue是通过加Reentrantlock锁的方式实现的添加元素时，添加元素时，先获取锁，然后判断队列是否为空，如果为空调用condition.wait()方法，将线程阻塞，如下：

    /**
     * 从队列中取一个元素
     * @return [description]
     * @throws InterruptedException [description]
     */
    public E take() throws InterruptedException {
        //对操作进行加锁 多线程时轮流取元素
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            //如果队列中没有对象 则阻塞线程等待
            while (count == 0)
                //重点：等待存数据的线程通知
                notEmpty.await();
            //代码运行到此处说明count!=null 执行从队列中取元素
            return dequeue();
        } finally {
            lock.unlock();
        }
    }

而condition.wait()是aqs中的方法，它将当前线程封装成一个节点，插入到aqs中，下面再看下aqs原理。

三、aqs原理

aqs是抽象队列同步器，顾名思义，它是用来进行线程间同步的，也就是加锁，然后它是使用一个state变量和一个队列来实现的。获取锁时，先使用cas来设置state变量，设置成功代表获取到了锁，设置失败则将当前线程包装成队列的一个节点，插入队列中，并且使用LockSupport.park方法阻塞当前线程。如下：

/**
 * 让线程不间断地获取锁，若线程对应的节点不是头节点的下一个节点，则会进入等待状态
 * @param node the node
 */
final boolean acquireQueued(final Node node, int arg) {
    // 记录失败标志
    boolean failed = true;
    try {
        // 记录中断标志，初始为true
        boolean interrupted = false;
        // 循环执行，因为线程在被唤醒后，可能再次获取锁失败，需要重写进入等待
        for (;;) {
            // 获取当前线程节点的前一个节点
            final Node p = node.predecessor();
            // 若前一个节点是头节点，则tryAcquire尝试获取锁，若获取成功，则执行if中的代码
            if (p == head && tryAcquire(arg)) {
                // 将当前节点设置为头节点
                setHead(node);
                // 将原来的头节点移出同步队列
                p.next = null; // help GC
                // 失败标志置为false
                failed = false;
                // 返回中断标志，acquire方法可以根据返回的中断标志，判断当前线程是否被中断
                return interrupted;
            }
            // shouldParkAfterFailedAcquire方法判断当前线程是否能够进入等待状态，
            // 若当前线程的节点不是头节点的下一个节点，则需要进入等待状态，
            // 在此方法内部，当前线程会找到它的前驱节点中，第一个还在正常等待或执行的节点，
            // 让其作为自己的直接前驱，然后在需要时将自己唤醒（因为其中有些线程可能被中断），
            // 若找到，则返回true，表示自己可以进入等待状态了；
            // 则继续调用parkAndCheckInterrupt方法，当前线程在这个方法中等待，
            // 直到被其他线程唤醒，或者被中断后返回，返回时将返回一个boolean值，
            // 表示这个线程是否被中断，若为true，则将执行下面一行代码，将中断标志置为true
            if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        // 上面代码中只有一个return语句，且return的前一句就是failed = false;
        // 所以只有当异常发生时，failed才会保持true的状态运行到此处；
        // 异常可能是线程被中断，也可能是其他方法中的异常，
        // 比如我们自己实现的tryAcquire方法
        // 此时将取消线程获取锁的动作，将它从同步队列中移除
        if (failed)
            cancelAcquire(node);
    }
}

其中cas是比较并替换，由cpu包装这条指令执行的线程安全性。LockSupport.park方法底层是c语言写的方法。

四、线程阻塞

aqs主要是可以阻塞当前线程，那线程阻塞是什么意思呢？

线程和进程其实差不多，linux内核中把线程也当做进程来处理。学习c语言代码时，首先会写个main函数，代表一个程序的进程，所以线程其实就是一段函数，它存储在内存中，主要包含线程的堆栈，代码，当前执行到哪一行和一些数据，还有描述线程的一些状态信息等等。线程的阻塞其实就是改变当前线程的状态，使得cpu不执行当前线程。LockSupport.park是将当前线程的状态变成等待。