关于java中的线程池用法

目录

线程池的参数介绍

线程池的工作流程

使用Executors创建常见的线程池

---

  池的思想，在计算机中是非常普遍的概念。顾名思义，池是将一个或多个任务提前创建好，放入容器中，当程序运行的时候直接取出使用，这个容器就叫线程池。随着时代的发展，并发编程的情况愈来愈多，对效率的要求也越来越高。频繁的创建销毁线程的开销，也变的越来越明显了。在这种情况下，可以引入线程池。

线程池的优点如下：

1. 降低资源消耗：减少线程的创建和销毁带来的性能开销。
2. 提高响应速度：当任务来时可以直接使用，不用等待线程创建
3. 可管理性： 进行统一的分配，监控，避免大量的线程间因互相抢占系统资源导致的阻塞现象。

为啥引入线程池后，能够提升效率？

  最关键的要点，是直接创建/销毁线程，是需要用户态+内核态配合完成的工作。而线程池的创建和销毁只需要通过用户态即可，不需要内核态的配合。

  另一个原因，直接调用api，创建线程，销毁线程，这个过程需要内核完成。内核完成的工作很多的时候是不太可控的。如果使用线程池，提前把线程都创建好，放到用户态代码中写的数据结构里面，后面用的时候，随时从池子里取，用完了放回池子里去，这个过程，完全是用户态代码，不需要和内核进行交互。

线程池的参数介绍

  我们下面使用java标准库中提供的ThreadPoolExector类来介绍关于线程池的一些参数。

1. 核心线程数（corePoolSize）与最大线程数（maximumPoolSize）

标准库的线程池把线程分为两类：1、核心线程(corePoolSize)  2、非核心线程 

maximumPoolSize 就是核心线程数 + 非核心线程数

一个线程池，刚被创建出来的时候，里面就包含核心线程这么多的线程。线程池会提供一个submit方法，往里面添加任务，每个任务都是一个Runnable对象。

比如我们有4个核心线程数，如果当前添加的任务比较少，4个线程就足以能够处理，就只有4个线程在工作了。如果添加的任务比较多，4个线程处理不过来了（有很多的任务在排队等待执行）。这个时候，线程池就会自动创建出新的线程，来支撑更多的任务。创建出来的线程总数，不能超过最大线程数。过了一段时间后，任务没那么多了，线程清闲了，部分线程就会被释放掉（回收了），回收只是把非核心线程回收掉，至少会保证线程池中线程数目不少于核心线程数。

2、非核心线程允许空闲的最大时间（keepAliveTime）和时间单位（unit） 

非核心线程是要在线程池不忙的时候回收掉，不是立即回收。例如，设定保留时间为3s，3s之内，非核心线程一直没有任务执行，就可以被回收了。unit表示时间的单位（分钟，小时，毫秒....），是个枚举类型。

3、任务队列（workQueue）

表示线程中的任务队列，线程池会提供submit方法，让其他线程把任务提交给线程池。线程池内部需要有一个队列这样的数据结构，把要执行的任务保存起来。后续线程池内部的工作线程，就会消费这个队列，从而来完成具体的任务执行。

4、线程工厂（threadFactory）

工厂模式的核心思路，是不再使用构造方法创建对象，而是给构造方法再包装一层。下面是一段工厂模式的代码。Point称为工厂类，通过类名PointBuilder调用方法，创建对象。主要解决了构造方法不能重载的问题。

class Point{
     private double x;

     public void setX(double x){
         this.x = x;
     }


}

class PointBuilder{
    public static Point makePointByXY(double x,double y){
           Point p  =new Point();
           p.setX(x);
           p.setY(y);
           return  p;
    }
    public static Point makePointByRA(double r, double a){
        Point p = new Point();
        p.setR(r);
        p.setA(a);
        return p;
    }
}
public class ThreadDemo21 {
    public static void main(String[] args) {
        Point p =  PointBuilder.makePointByXY(10,20);
    }
}

threadFactory是标准库中提供的，用来创建线程的工厂类。工厂类里面提供了工厂方法，工厂方法中封装了创建对象的过程。 

我们除了可以使用Thread类来new一个线程对象，还可以使用工厂类提供的工厂方法来创建。线程工厂还可以批量的给要创建的线程设置一些属性。

5、拒绝策略（RejectedExecutionHandler  handler）（重点）

拒绝策略是一个枚举类型。如果当前任务队列满了，仍然要继续添加任务，我们该怎么做？

如何处理这种情况就是拒绝策略：

1）直接抛出异常（程序运行结束）

2）令添加任务的submit调用者（submit内部要做的事情不仅仅是入队列，如果发现队列满 && 当前使用的这个拒绝策略，就会在submit内部自己去执行Rnnable的run方法），负责执行任务，线程池本身不管了。

3）丢弃最老的任务，让新的任务去队列中排队。

4）丢弃最新的任务，还是按照原有的节奏来执行。

线程池的工作流程

我们可以自己模拟实现一个简单的线程池，代码如下：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
class   MyThreadPool{
    private BlockingQueue<Runnable> queue = new ArrayBlockingQueue<>(1000);
    private  int maxPoolSize = 0;
    private List<Thread> threadList = new ArrayList<>();
    //初始化线程池（FixedThreadPool）
    public MyThreadPool(int corePoolSize,int maxPoolSize){
       this.maxPoolSize =  maxPoolSize;
        //创建若干个线程
        for(int i = 0;i<corePoolSize;i++){
            Thread t = new Thread(()->{
               try {
                   while (true){
                       Runnable runnable = queue.take();
                       runnable.run();
                   }
               }catch (InterruptedException e){
                   e.printStackTrace();
               }
            });
            t.start();
            threadList.add(t);
        }
    }
    //把任务添加到线程池中
    void submit(Runnable runnable) throws InterruptedException {
        //此处进行判定当前任务队列的元素个数
        //如果队列元素比较长，说明已有的线程，不太能够处理过来了，创建新的线程即可。
        //如果队列不是很长，没必要创建新的线程。
        queue.put(runnable);
        //阈值都是随便想的
        if(queue.size() >=500 && threadList.size() <maxPoolSize){
            //创建新的线程
            Thread t = new Thread(()->{
                try {
                    while (true){
                        Runnable task = queue.take();
                        task.run();
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            });
            t.start();
        }
    }
}

public class ThreadDemo18 {
    public static void main(String[] args) throws InterruptedException {
        MyThreadPool threadPool = new MyThreadPool(10,20);
        for (int i =0 ;i<10000;i++){
            int id = i;
            threadPool.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello"+ id +" "+ Thread.currentThread().getName());
                }
            });
        }
    }


}

一个新的任务到线程池时，线程池的处理流程如下：
1.线程池判断核心线程池里的线程是否都在执行任务。 如果不是，创建一个新的工作线程来执行任务。如果核心线程池里的线程都在执行任务，则进入下个流程。
2、线程池判断阻塞队列是否已满。 如果阻塞队列没有满，则将新提交的任务存储在阻塞队列中。如果阻塞队列已满，则进入下个流程。
3、线程池判断线程池里的线程是否都处于工作状态。 如果没有，则创建一个新的工作线程来执行任务。如果已满，则交给饱和策略来处理这个任务。

使用Executors创建常见的线程池

java标准库提供了创建线程池的工厂类Executors。可以帮助我们创建不同的线程池。

常用的分为以下4种：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class ThreadDemo19 {
    public static void main(String[] args) {
        //创建标准库线程池
        //能够根据线程的数目，自动进行线程扩容
        ExecutorService service = Executors.newCachedThreadPool();

        //创建固定线程数目的线程池
          ExecutorService service = Executors.newFixedThreadPool(4);
        //创建一个只包含单个线程的线程池
        ExecutorService service = Executors.newSingleThreadExecutor();
        //创建一个固定线程个数，但是任务延时执行的线程池
        ScheduledExecutorService service = Executors.newScheduledThreadPool(4);
        for(int i =0;i< 1000;i++){
            int id =i;
            service.submit(new Runnable() {
                @Override
                public void run() {
                    System.out.println("hello" + id+","+Thread.currentThread().getName());
                }
            });
        }
    }
}

以上关于线程池，希望对你有所帮助。