Java之线程池简单实现(Java线程池入门实现详解)

原创

ithorizon 6个月前 (10-20) 阅读数 14 #后端开发

Java线程池易懂实现 - 入门实现详解

一、线程池概述

在Java中，线程池是一种用于管理多个线程的工具，它能够有效地管理线程的生命周期，减少线程创建和销毁的开销，节约系统性能。本文将介绍怎样实现一个易懂的Java线程池。

二、线程池的核心概念

线程池重点包括以下几个核心概念：

线程池大小：线程池中线程的数量。

任务队列：用于存放等待执行的任务。

线程工厂：用于创建新线程。

拒绝策略：当任务队列满时，怎样处理新提交的任务。

三、易懂线程池的实现

下面我们将实现一个易懂的线程池，重点包括以下几个步骤：

定义线程池类。

创建任务队列。

创建工作线程。

执行任务。

四、定义线程池类

首先，我们定义一个线程池类，包含以下属性：

线程池大小。

任务队列。

工作线程列表。


public class SimpleThreadPool {
    private final int poolSize;
    private final BlockingQueue workQueue;
    private final List workerThreads;
    public SimpleThreadPool(int poolSize) {
        this.poolSize = poolSize;
        this.workQueue = new LinkedBlockingQueue<>();
        this.workerThreads = new ArrayList<>();
    }
}

五、创建任务队列

任务队列用于存放等待执行的任务，我们使用Java的BlockingQueue实现：


private final BlockingQueue workQueue;
public SimpleThreadPool(int poolSize) {
    // ...
    this.workQueue = new LinkedBlockingQueue<>();
    // ...
}

六、创建工作线程

工作线程用于执行任务，我们定义一个内部类WorkerThread，继承自Thread类，并重写run方法：


private class WorkerThread extends Thread {
    public WorkerThread() {
        super();
    }
    @Override
    public void run() {
        while (!Thread.currentThread().isInterrupted()) {
            try {
                Runnable task = workQueue.take();
                task.run();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

在SimpleThreadPool类中，创建并启动工作线程：


public void start() {
    for (int i = 0; i < poolSize; i++) {
        WorkerThread workerThread = new WorkerThread();
        workerThread.start();
        workerThreads.add(workerThread);
    }
}

七、执行任务

在SimpleThreadPool类中，定义一个方法用于提交任务到线程池：


public void execute(Runnable task) {
    if (task != null) {
        try {
            workQueue.put(task);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

八、完整代码示例

以下是易懂线程池的完整代码示例：


import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
public class SimpleThreadPool {
    private final int poolSize;
    private final BlockingQueue workQueue;
    private final List workerThreads;
    public SimpleThreadPool(int poolSize) {
        this.poolSize = poolSize;
        this.workQueue = new LinkedBlockingQueue<>();
        this.workerThreads = new ArrayList<>();
    }
    private class WorkerThread extends Thread {
        public WorkerThread() {
            super();
        }
        @Override
        public void run() {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Runnable task = workQueue.take();
                    task.run();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
    public void start() {
        for (int i = 0; i < poolSize; i++) {
            WorkerThread workerThread = new WorkerThread();
            workerThread.start();
            workerThreads.add(workerThread);
        }
    }
    public void execute(Runnable task) {
        if (task != null) {
            try {
                workQueue.put(task);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}