Java线程池代码怎么写

Java线程池核心原理

看过Java线程池源码的小伙伴都知道，在Java线程池中最核心的类就是ThreadPoolExecutor，而在ThreadPoolExecutor类中最核心的构造方法就是带有7个参数的构造方法，如下所示。

 public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                              BlockingQueue<Runnable> workQueue,

                              ThreadFactory threadFactory,

                              RejectedExecutionHandler handler)

各参数的含义如下所示。

• corePoolSize：线程池中的常驻核心线程数。

• maximumPoolSize：线程池能够容纳同时执行的最大线程数，此值大于等于1。

• keepAliveTime：多余的空闲线程存活时间，当空间时间达到keepAliveTime值时，多余的线程会被销毁直到只剩下corePoolSize个线程为止。

• unit：keepAliveTime的单位。

• workQueue：任务队列，被提交但尚未被执行的任务。

• threadFactory：表示生成线程池中工作线程的线程工厂，用户创建新线程，一般用默认即可。

• handler：拒绝策略，表示当线程队列满了并且工作线程大于等于线程池的最大显示数(maxnumPoolSize)时，如何来拒绝请求执行的runnable的策略。

并且Java的线程池是通过 生产者-消费者模式 实现的，线程池的使用方是生产者，而线程池本身就是消费者。

Java线程池的核心工作流程如下图所示。

手撸Java线程池

我们自己手动实现的线程池要比Java自身的线程池简单的多，我们去掉了各种复杂的处理方式，只保留了最核心的原理：线程池的使用者向任务队列中添加任务，而线程池本身从任务队列中消费任务并执行任务。

只要理解了这个核心原理，接下来的代码就简单多了。在实现这个简单的线程池时，我们可以将整个实现过程进行拆解。拆解后的实现流程为：定义核心字段、创建内部类WorkThread、创建ThreadPool类的构造方法和创建执行任务的方法。

定义核心字段

首先，我们创建一个名称为ThreadPool的Java类，并在这个类中定义如下核心字段。

• DEFAULT_WORKQUEUE_SIZE：静态常量，表示默认的阻塞队列大小。

• workQueue：模拟实际的线程池使用阻塞队列来实现生产者-消费者模式。

• workThreads：模拟实际的线程池使用List集合保存线程池内部的工作线程。

核心代码如下所示。

//默认阻塞队列大小

private static final int DEFAULT_WORKQUEUE_SIZE = 5;



//模拟实际的线程池使用阻塞队列来实现生产者-消费者模式

private BlockingQueue<Runnable> workQueue;



//模拟实际的线程池使用List集合保存线程池内部的工作线程

private List<WorkThread> workThreads = new ArrayList<WorkThread>();

创建内部类WordThread

在ThreadPool类中创建一个内部类WorkThread，模拟线程池中的工作线程。主要的作用就是消费workQueue中的任务，并执行任务。由于工作线程需要不断从workQueue中获取任务，所以，这里使用了while(true)循环不断尝试消费队列中的任务。

核心代码如下所示。

//内部类WorkThread，模拟线程池中的工作线程

//主要的作用就是消费workQueue中的任务，并执行

//由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务

class WorkThread extends Thread{

    @Override

    public void run() {

        //不断循环获取队列中的任务

        while (true){

            //当没有任务时，会阻塞

            try {

                Runnable workTask = workQueue.take();

                workTask.run();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

}

创建ThreadPool类的构造方法

这里，我们为ThreadPool类创建两个构造方法，一个构造方法中传入线程池的容量大小和阻塞队列，另一个构造方法中只传入线程池的容量大小。

核心代码如下所示。

//在ThreadPool的构造方法中传入线程池的大小和阻塞队列

public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){

    this.workQueue = workQueue;

    //创建poolSize个工作线程并将其加入到workThreads集合中

    IntStream.range(0, poolSize).forEach((i) -> {

        WorkThread workThread = new WorkThread();

        workThread.start();

        workThreads.add(workThread);

    });

}



//在ThreadPool的构造方法中传入线程池的大小

public ThreadPool(int poolSize){

    this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE));

}

创建执行任务的方法

在ThreadPool类中创建执行任务的方法execute()，execute()方法的实现比较简单，就是将方法接收到的Runnable任务加入到workQueue队列中。

核心代码如下所示。

//通过线程池执行任务

public void execute(Runnable task){

    try {

        workQueue.put(task);

    } catch (InterruptedException e) {

        e.printStackTrace();

    }

}

完整源码

这里，我们给出手动实现的ThreadPool线程池的完整源代码，如下所示。

package io.binghe.thread.pool;



import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.BlockingQueue;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.stream.IntStream;



/**

 * @author binghe

 * @version 1.0.0

 * @description 自定义线程池

 */

public class ThreadPool {



    //默认阻塞队列大小

    private static final int DEFAULT_WORKQUEUE_SIZE = 5;



    //模拟实际的线程池使用阻塞队列来实现生产者-消费者模式

    private BlockingQueue<Runnable> workQueue;



    //模拟实际的线程池使用List集合保存线程池内部的工作线程

    private List<WorkThread> workThreads = new ArrayList<WorkThread>();



    //在ThreadPool的构造方法中传入线程池的大小和阻塞队列

    public ThreadPool(int poolSize, BlockingQueue<Runnable> workQueue){

        this.workQueue = workQueue;

        //创建poolSize个工作线程并将其加入到workThreads集合中

        IntStream.range(0, poolSize).forEach((i) -> {

            WorkThread workThread = new WorkThread();

            workThread.start();

            workThreads.add(workThread);

        });

    }



    //在ThreadPool的构造方法中传入线程池的大小

    public ThreadPool(int poolSize){

        this(poolSize, new LinkedBlockingQueue<>(DEFAULT_WORKQUEUE_SIZE));

    }



 //通过线程池执行任务

    public void execute(Runnable task){

        try {

            workQueue.put(task);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }



    //内部类WorkThread，模拟线程池中的工作线程

    //主要的作用就是消费workQueue中的任务，并执行

    //由于工作线程需要不断从workQueue中获取任务，使用了while(true)循环不断尝试消费队列中的任务

    class WorkThread extends Thread{

        @Override

        public void run() {

            //不断循环获取队列中的任务

            while (true){

                //当没有任务时，会阻塞

                try {

                    Runnable workTask = workQueue.take();

                    workTask.run();

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

            }

        }

    }

}

没错，我们仅仅用了几十行Java代码就实现了一个极简版的Java线程池，没错，这个极简版的Java线程池的代码却体现了Java线程池的核心原理。

接下来，我们测试下这个极简版的Java线程池。

编写测试程序

测试程序也比较简单，就是通过在main()方法中调用ThreadPool类的构造方法，传入线程池的大小，创建一个ThreadPool类的实例，然后循环10次调用ThreadPool类的execute()方法，向线程池中提交的任务为：打印当前线程的名称--->> Hello ThreadPool。

整体测试代码如下所示。

package io.binghe.thread.pool.test;



import io.binghe.thread.pool.ThreadPool;



import java.util.stream.IntStream;



/**

 * @author binghe

 * @version 1.0.0

 * @description 测试自定义线程池

 */

public class ThreadPoolTest {



    public static void main(String[] args){

        ThreadPool threadPool = new ThreadPool(10);

        IntStream.range(0, 10).forEach((i) -> {

            threadPool.execute(() -> {

                System.out.println(Thread.currentThread().getName() + "--->> Hello ThreadPool");

            });

        });

    }

}

接下来，运行ThreadPoolTest类的main()方法，会输出如下信息。

Thread-0--->> Hello ThreadPool

Thread-9--->> Hello ThreadPool

Thread-5--->> Hello ThreadPool

Thread-8--->> Hello ThreadPool

Thread-4--->> Hello ThreadPool

Thread-1--->> Hello ThreadPool

Thread-2--->> Hello ThreadPool

Thread-5--->> Hello ThreadPool

Thread-9--->> Hello ThreadPool

Thread-0--->> Hello ThreadPool