Java线程池简介

谁践踏了优雅 2022-09-05 01:53 216阅读 0赞

## 多线程简介 ##

Cpu处理速度非常快，程序执行中很多时间cpu都在等待，因为硬件之间效率差异太大，内存比硬盘速度快很多，即便是内存，读写的过程对于cpu来说也是浪费时间。为了提高对硬件的使用效率，防止程序过多的等待io（如等待读取文件，等待写入文件，等待网络，等待数据库等）而浪费硬件性能，操作系统提供多线程的处理方式，可以同时处理多个任务，让硬件（尤其且主要是cpu）尽可能忙起来。**比如A任务正在等待读取数据库，可以先处理B任务，没必要一次把A任务执行完再执行下一个任务，这样不仅浪费时间，也浪费硬件性能**。

多线程可以提交处理效率，但线程的创建和多线程执行的切换本身也是一种消耗。如果cpu的一个核心（现在的cpu基本都是多核）同时需要处理几百个任务，光创建线程和来回切换都会浪费很多时间，反倒会影响程序执行效率，或许还不如单线程执行效率高。所以合理的使用多线程，对程序的性能影响较大。

## Java线程池 ##

使用线程池有助于合理使用多线程编程，提高程序效率。  
为了方便开发，Java提供了三种线程池：  
newCachedThreadPool()  
newFixedThreadPool(int nThreads)  
newScheduledThreadPool(int corePoolSize)  
newSingleThreadExecutor()

这三种线程池都是对ThreadPoolExecutor的不同运用，即ThreadPoolExecutor才是线程池的核心实现，也是我们需要关注的重点，甚至java也提倡手动创建ThreadPoolExecutor来合理使用线程池。

ThreadPoolExecutor构造函数说明

public ThreadPoolExecutor(int corePoolSize,
                                  int maximumPoolSize,
                                  long keepAliveTime,
                                  TimeUnit unit,
                                  BlockingQueue<Runnable> workQueue,
                                  ThreadFactory threadFactory,
                                  RejectedExecutionHandler handler)

**corePoolSize**:核心线程数，线程池中固定保存的线程数，线程池创建时线程数为0，之后会在接到任务后**创建线程直到线程数达到核心线程数**，再之后即便没有任务，空闲的线程也不会被销毁。  
**maximumPoolSize**:最大线程数，线程池中线程数已到达corePoolSize之后，仍有任务等待执行，会先放置到阻塞队列中，**当阻塞队列已满且maximumPoolSize大于corePoolSize时**，线程池会额外创建几个线程**用于加速消耗阻塞队列中的任务**，但**线程池中同时存在的线程数不能超过maximumPoolSize**。  
**keepAliveTime**:上述用于加速消耗阻塞队列任务而额外创建的线程，再空闲时是需要被销毁的，空闲状态的线程池中应只保留corePoolSize个线程，**此配置用于额外创建的线程空闲后最多可保留时间**。如配置60s，则最多允许多出来的线程空闲保留60s。  
**timeUnit**: keepAliveTime的时间单位，可以是毫秒、秒、分等等  
**workQueue**:阻塞队列，线程池中所有线程都在执行任务时，新到的任务无法分配线程只能保存起来排队等待。  
threadFactory:线程工厂，创建线程时使用，可以设置有意义的线程名方便日志打印与查找。  
**rejectedExecutionHandler**:任务被拒绝时的策略处理器，当线程池中队列已满且线程数已到达maximumPoolSize后，线程池已满，无法处理新到的任务，只能拒绝掉任务。拒绝策略处理器可提供接口让用户决定如何处理这些被拒绝的任务，默认抛异常。

## 线程池原理 ##

### 原理概述 ###

上述线程池入参已大致可以看出线程池原理，这里做一些汇总。

线程池创建后，并不存在线程，当接受任务后，首先判断核心线程数够不够，不够则创建线程并执行任务。核心线程已足够时，则将任务加入阻塞队列，等待线程空闲时再执行队列中的任务，若线程池状态为已关闭或线程池已满则拒绝任务。

![请添加图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIwOTgwMjE_size_16_color_FFFFFF_t_70]

### 任务执行 ###

提交给线程池的任务task，必须实现Runnable接口

public void execute(Runnable command){ }

PS：Java中线程的执行，需要使用Thread类，并调用start方法，最终会自动调用run方法，如果手动调用run方法则不会启动新线程，而只是一次普通的方法调用。

线程池执行任务时，如果需要创建新线程则会使用Thread.start执行，那么空闲的线程如何执行任务呢？如果把任务作为一个线程执行，那么空闲线程重复利用这一点貌似就做不到了，因为如果把任务本身作为一个线程执行，新的任务就必须创建新线程。

这里使用了一个巧妙的设计，使用了一个Worker类，该类本身就是一个线程，我们提交的任务会当做该类的一个成员属性firstTask保存，该类的run方法是无线循环的执行task，这个task首选取firstTask，使用时顺带把firstTask置空，再次循环时，发现firstTask为空则调用getTask方法从队列中取任务，由于队列是阻塞的，没有任务是，worker就卡主睡眠了，不会一直无线循环。而**task虽然实现了Runnable接口，但这里只是为了手动调用run方法，而不是作为一个线程执行**。

final void runWorker(Worker w) { 
        Thread wt = Thread.currentThread();
        Runnable task = w.firstTask;
        w.firstTask = null;
        w.unlock(); // allow interrupts
        boolean completedAbruptly = true;
        try { 
            while (task != null || (task = getTask()) != null) { 
                w.lock();
                // If pool is stopping, ensure thread is interrupted;
                // if not, ensure thread is not interrupted. This
                // requires a recheck in second case to deal with
                // shutdownNow race while clearing interrupt
                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;
                    w.completedTasks++;
                    w.unlock();
                }
            }
            completedAbruptly = false;
        } finally { 
            processWorkerExit(w, completedAbruptly);
        }
    }

所以线程池的**corePoolSize**指的是工作线程，工作线程会一直自旋消耗阻塞队列。

常用阻塞队列  
之所以使用阻塞队列，目的在于没有任务时，工作线程不需要一直自旋（无线循环）来获取任务。  
workQueue.take方法会让工作线程“卡主”陷入睡眠，等待任务的到来。  
下面说下几种阻塞队列：  
**LinkedBlockingQueue**：几乎等于无界队列，最大容量为Integer.MAX\_VALUE，可以手动设置容量，使用链表实现。  
**ArrayBlockingQueue**：有界队列，需要手动设置容量，使用数组实现。  
**SynchronousQueue**：同步队列，容量为1，或者说没有容量，进入一个任务必须消费了才能保存另一个任务。

LinkedBlockingQueue为最常用的队列，对比ArrayBlockingQueue效率更高，两者都是线程安全的，LinkedBlockingQueue生产和消费使用两个锁，而ArrayBlockingQueue生产消费使用一个锁。

## 总结 ##

Java线程池使用ThreadPoolExecutor创建，通过控制工作线程数，复用线程，以及使用缓存队列，可以高效合理的使用多线程开发，提高程序执行效率，是一项建议必备的知识点哦。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTIwOTgwMjE_size_16_color_FFFFFF_t_70]: /images/20220829/668cbc5c3ca944ccb5bda70a588d4419.png