手写Java的线程池

最新推荐文章于 2023-08-09 12:35:59 发布
最新推荐文章于 2023-08-09 12:35:59 发布
阅读量315 收藏 2
点赞数
分类专栏： JUC 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43939924/article/details/126002263
版权

手写Java的线程池

简单实现了一个Java的线程池

拒绝策略

/**
 * 拒绝策略
 *
 * @author zhangqi
 * @date 2022/7/26 20:04
 */

@FunctionalInterface
public interface RejectPolicy<T> {
    /**
     * 拒绝策略
     *
     * @param taskQueue 任务队列
     * @param task      任务
     */
    void reject(BlockingQueue<T> taskQueue, T task);
}

阻塞队列

import lombok.extern.slf4j.Slf4j;

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 自定义的阻塞队列
 *
 * @param <T> 类型
 */
@Slf4j
@SuppressWarnings("unused")
public class BlockingQueue<T> {
    /**
     * 任务队列
     */
    private final Deque<T> deque = new ArrayDeque<>();
    /**
     * 锁 用于多线程获取任务队列中的任务 或 放任务
     */
    private final ReentrantLock lock = new ReentrantLock();
    /**
     * 生产者条件变量  队列满了不能在生产了
     */
    private final Condition fullWaitSet = lock.newCondition();
    /**
     * 消费者条件变量 队列空了不能在生产了
     */
    private final Condition emptyWaitSet = lock.newCondition();
    /**
     * 容量
     */
    private final int capacity;

    /**
     * 构造函数
     *
     * @param capacity 队列大小
     */
    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 获取任务 阻塞 带超时时间
     *
     * @param timeout 超时时间
     * @param unit    时间单位
     * @return 任务
     */
    public T poll(long timeout, TimeUnit unit) {
        long nanos = unit.toNanos(timeout);
        lock.lock();
        try {
            while (deque.isEmpty()) {
                if (nanos <= 0) {
                    return null;
                }
                nanos = emptyWaitSet.awaitNanos(nanos);
            }
            fullWaitSet.signalAll();
            return deque.removeFirst();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            lock.unlock();
        }
    }


    /**
     * 获取任务 阻塞
     *
     * @return 任务
     */
    public T take() {
        lock.lock();
        try {
            while (deque.isEmpty()) {
                emptyWaitSet.awaitUninterruptibly();
            }
            fullWaitSet.signalAll();
            return deque.removeFirst();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务 阻塞 带超时时间
     *
     * @param element 任务
     * @param timeout 超时时间
     * @param unit    时间单位
     */
    public boolean offer(T element, long timeout, TimeUnit unit) {
        lock.lock();
        long nanos = unit.toNanos(timeout);
        try {
            while (deque.size() == capacity) {
                log.info("等待 [{}]", element);
                if (nanos <= 0) {
                    return false;
                }
                nanos = fullWaitSet.awaitNanos(nanos);
            }
            deque.addLast(element);
            log.info("添加任务 [{}]", element.toString());
            emptyWaitSet.signalAll();
            return true;
        } catch (InterruptedException e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
            return false;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 添加任务 阻塞
     *
     * @param element 任务
     */
    public void put(T element) {
        lock.lock();
        try {
            while (deque.size() == capacity) {
                log.info("等待 [{}]", element);
                fullWaitSet.awaitUninterruptibly();
            }
            deque.addLast(element);
            log.info("添加 [{}]", element);
            emptyWaitSet.signalAll();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 获取队列大小
     *
     * @return 队列大小
     */
    public int size() {
        lock.lock();
        try {
            return deque.size();
        } finally {
            lock.unlock();
        }
    }

    /**
     * 尝试添加
     *
     * @param rejectPolicy 拒绝策略
     * @param element      任务
     */
    public void tryPut(RejectPolicy<T> rejectPolicy, T element) {
        lock.lock();
        try {
            if (deque.size() >= capacity) {
                rejectPolicy.reject(this, element);
            } else {
                deque.addLast(element);
                log.info("添加 [{}]", element);
                emptyWaitSet.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }
}

线程池

import lombok.extern.slf4j.Slf4j;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * 线程池
 *
 * @author zhangqi
 * @date 2022/7/26 20:06
 */
@Slf4j
@SuppressWarnings("unused")
public class ThreadPool {
    /**
     * 阻塞队列
     */
    private final BlockingQueue<Runnable> taskQueue;
    /**
     * 线程集合
     */
    private final Set<Worker> workers = new HashSet<>();
    /**
     * 核心线程数
     */
    private final int coreSize;
    /**
     * 超时时间
     */
    private final long timeout;
    /**
     * 时间单位
     */
    private final TimeUnit unit;
    /**
     * 拒绝策略
     */
    private final RejectPolicy<Runnable> rejectPolicy;

    /**
     * 构造函数
     *
     * @param coreSize      核心线程数
     * @param timeout       超时时间
     * @param unit          时间单位
     * @param queueCapacity 阻塞队列大小
     * @param rejectPolicy  拒绝策略
     */
    public ThreadPool(int coreSize, long timeout, TimeUnit unit, int queueCapacity, RejectPolicy<Runnable> rejectPolicy) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.unit = unit;
        this.rejectPolicy = rejectPolicy;
        this.taskQueue = new BlockingQueue<>(queueCapacity);
    }

    /**
     * 执行线程池方法
     *
     * @param task 任务
     */
    public void execute(Runnable task) {
        synchronized (workers) {
            // 没有超过核心线程数
            if (coreSize > workers.size()) {
                Worker worker = new Worker(task);
                log.info("执行任务 = " + worker);
                workers.add(worker);
                worker.start();
                return;
            }
            log.info("加入任务队列 = " + task);
            // 超过核心线程数

            // 1. 死等
            // 2. 等待超时
            // 3. 调用者放弃任务
            // 4. 调用者抛出异常
            // 5. 调用者自己执行任务

            taskQueue.tryPut(rejectPolicy, task);
        }
    }

    /**
     * 工作线程
     */
    private class Worker extends Thread {
        /**
         * 工作线程的任务
         */
        private Runnable task;

        /**
         * 构造方法
         *
         * @param task 任务
         */
        public Worker(Runnable task) {
            this.task = task;
        }

        /**
         * 执行任务
         * 1. task != null 执行task
         * 2. task 执行完成 判读阻塞队列是否为空 不为空 取出尾部 任务执行
         */
        @Override
        public void run() {
            /// 死等
            /// while (Objects.nonNull(task) || Objects.nonNull((task = taskQueue.take()))) {
            // 带超时时间
            while (Objects.nonNull(task) || Objects.nonNull((task = taskQueue.poll(timeout, unit)))) {
                try {
                    task.run();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    task = null;
                }
            }
            synchronized (workers) {
                log.info(" worker 移除" + workers);
                workers.remove(this);
            }
        }
    }
}

测试代码


    public static void main(String[] args) {
        // 死等
        // ThreadPool threadPool = new ThreadPool(2, 1, TimeUnit.SECONDS, 5, BlockingQueue::put);
        // 超时时间
        // ThreadPool threadPool = new ThreadPool(2, 2, TimeUnit.SECONDS, 5, (queue, take) -> queue.offer(take, 1, TimeUnit.SECONDS));
        // 放弃
        // ThreadPool threadPool = new ThreadPool(2, 2, TimeUnit.SECONDS, 5, (queue, take) -> System.out.println("放弃"));
        // 异常
        // ThreadPool threadPool = new ThreadPool(2, 2, TimeUnit.SECONDS, 5, (queue, take) -> {
        //     throw new RuntimeException();
        // });
        // 自己执行
        ThreadPool threadPool = new ThreadPool(2, 2, TimeUnit.SECONDS, 5, (queue, take) -> {
            take.run();
        });
        for (int i = 0; i < 15; i++) {
            int count = i;
            threadPool.execute(() -> {
                log.info("count = " + count);
                Sleep.sleep(2001);
            });
        }
    }

测试结果

2022-07-26 19:57:35.642  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 执行任务 = Thread[Thread-0,5,main]
2022-07-26 19:57:35.645  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 执行任务 = Thread[Thread-1,5,main]
2022-07-26 19:57:35.645  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 0
2022-07-26 19:57:35.646  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@4f7d0008
2022-07-26 19:57:35.646  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 1
2022-07-26 19:57:35.646  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@4f7d0008]
2022-07-26 19:57:35.648  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@402a079c
2022-07-26 19:57:35.648  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@402a079c]
2022-07-26 19:57:35.648  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@59ec2012
2022-07-26 19:57:35.648  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@59ec2012]
2022-07-26 19:57:35.648  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@4cf777e8
2022-07-26 19:57:35.648  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@4cf777e8]
2022-07-26 19:57:35.648  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@2f686d1f
2022-07-26 19:57:35.648  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@2f686d1f]
2022-07-26 19:57:35.648  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@3fee9989
2022-07-26 19:57:35.648  INFO   --- [           main] c.e.demo.hmjuc.day18.TestThreadPool      : count = 7
2022-07-26 19:57:37.651  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 3
2022-07-26 19:57:37.651  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@73ad2d6
2022-07-26 19:57:37.651  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 2
2022-07-26 19:57:37.651  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@73ad2d6]
2022-07-26 19:57:37.652  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@7085bdee
2022-07-26 19:57:37.652  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@7085bdee]
2022-07-26 19:57:37.652  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@1ce92674
2022-07-26 19:57:37.652  INFO   --- [           main] c.e.demo.hmjuc.day18.TestThreadPool      : count = 10
2022-07-26 19:57:39.653  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 4
2022-07-26 19:57:39.653  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@5700d6b1
2022-07-26 19:57:39.653  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 5
2022-07-26 19:57:39.654  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@5700d6b1]
2022-07-26 19:57:39.654  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@6fd02e5
2022-07-26 19:57:39.654  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@6fd02e5]
2022-07-26 19:57:39.654  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@5bcab519
2022-07-26 19:57:39.654  INFO   --- [           main] c.e.demo.hmjuc.day18.TestThreadPool      : count = 13
2022-07-26 19:57:41.657  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 8
2022-07-26 19:57:41.657  INFO   --- [           main] com.example.demo.hmjuc.day18.ThreadPool  : 加入任务队列 = com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@e45f292
2022-07-26 19:57:41.657  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 6
2022-07-26 19:57:41.657  INFO   --- [           main] c.e.demo.hmjuc.day18.BlockingQueue       : 添加 [com.example.demo.hmjuc.day18.TestThreadPool$$Lambda$2/1471868639@e45f292]
2022-07-26 19:57:43.658  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 11
2022-07-26 19:57:43.658  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 9
2022-07-26 19:57:45.660  INFO   --- [       Thread-1] c.e.demo.hmjuc.day18.TestThreadPool      : count = 12
2022-07-26 19:57:45.660  INFO   --- [       Thread-0] c.e.demo.hmjuc.day18.TestThreadPool      : count = 14
2022-07-26 19:57:48.662  INFO   --- [       Thread-1] com.example.demo.hmjuc.day18.ThreadPool  :  worker 移除[Thread[Thread-0,5,main], Thread[Thread-1,5,main]]
2022-07-26 19:57:48.662  INFO   --- [       Thread-0] com.example.demo.hmjuc.day18.ThreadPool  :  worker 移除[Thread[Thread-0,5,main]]

Process finished with exit code 0
Q z1997
关注
专栏目录
Java并发编程系列---线程池的实现原理
逆流而上的博客
02-06 2697
一、线程池简介 1.1 什么是线程池 所谓线程池，通俗的理解就是有一个池子，里面存放着已经创建好的线程，当有任务提交给线程池执行时，池子中的某个线程会主动执行该任务。如果池子中的线程数量不够应付数量众多的任务时，则需要自动扩充新的线程到池子中，但是该数量是有限的，就好比池塘的水界线一样。当任务比较少的时候，池子中的线程能够自动回收，释放资源。为了能够异步地提交任务和缓存未被处理的任务，需要有一个任...
手写Java线程池_超详细解说_绝对能运行_代码超详细注释
菜鸡逆袭的博客
09-26 748
线程池 问题背景 只是单纯使用 new Thread(runnable).start(); 的方式创建线程, 将会导致严重的程序性能问题: 1.线程创建, 销毁需要消耗很大的系统资源; 2.虚拟机创建线程的数量是有限的; 2.线程调度切换也将使程序性能下降; 针对这些问题, 对线程数量进行管理, 有效地重复利用线程, 将会很好地提高程序性能. 线程池原理 使用队列创建一定数量的线程, 当有任务的时...
Java手写线程池
qq_32486597的博客
03-10 5147
Java 手写线程池
手写JAVA线程池
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
07-12 1471
手写JAVA线程池
Java面试题(十九) 细说线程池秘境“七大参数”护法的身世
w_x_A__l__l的博客
06-25 1338
一. 线程池七大参数详解 1. 底层源码 /** * Creates a new {@code ThreadPoolExecutor} with the given initial * parameters. * * @param corePoolSize the number of threads to keep in the pool, even * if they are idle, unless {@code allowCoreThre
手写Java线程池
weixin_34107739的博客
12-19 150
练习手写线程池 import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.atomic.AtomicInteger; /** * ... * * @author : l...
线程池优化 手写java 线程池
最新发布
09-08
当手写一个简单的Java线程池时，你可以按照以下步骤进行: ...这是一个简单的手写Java线程池的示例，但请注意，这个线程池的实现只是一个基本的框架，你可以根据自己的需求进行更复杂的优化和扩展。
手写Java线程池实现教程与代码示例
Java手写线程池的实现方法是一种技术实践，它允许开发者在Java中创建自定义线程池，以更有效地管理和调度任务执行。线程池的核心原理是预先创建一定数量的工作线程，当有新的任务到来时，将其添加到任务队列中，工作...
Java手写线程池的实现方法
08-27
Java手写线程池的实现方法 Java手写线程池的实现方法是指通过编写 Java 代码来实现一个线程池，线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台...
Java线程池实现原理详解,看完一篇，学会线程池？
m0_49496327的博客
04-11 1391
一、为什么要使用线程池？ 线程池提供了一种限制和管理资源（线程、任务）的方式。 这里借用《Java 并发编程的艺术》提到的来说一下使用线程池的好处： 降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗。 提高响应速度：当任务到达时，任务可以不需要等待创建线程就能立即执行。 提高线程的可管理性：线程是稀缺资源，如果无线的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。 二、ThreadPoolExecutor类分析 Java线程池主要由Ex
java 手写线程池
mhbsoft的博客
12-08 152
MyThreadPoolDemo.java public class MyThreadPoolDemo { public static void main(String[] args) { ExecutorService threadPool = new ThreadPoolExecutor( 2, 5, 1L, TimeUnit.SECONDS,
手写线程池（Java）
青鱼入云的博客
08-09 454
手写实现一个线程池
Java 手写线程池
希望能解决大家的问题，也欢迎老哥们来骚扰技术交流业务中的问题
08-05 422
源码：https://github.com/Bit-urd/knowledge-base/tree/master/java-se/src/com/biturd/knowledgebase/thread/pool 思路 类比数据库连接池。数据库连接池复用的是Connection，池化技术通用的：最小个数、最大个数、活跃时间、线程池容器[核心]:一般为队列。[通用的就不写了，写点特有的] 线程池复用的是线程，目的是减少向操作系统申请线程避免上下文切换。正常情况下线程执行完就结束了，就死亡了。无法复用。 要.
java 手写一个简单的线程池
小宝的博客
12-03 395
java 线程池 多线程
《Java动手撸源码》手写实现线程池
Turbo码先生
01-30 4704
《Java动手撸源码》手写实现线程池 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录《Java动手撸源码》手写实现线程池前言一、线程池的原理二、简易版本三、完善版本1.类图2.重点代码分析2.1 ThreadPool接口分析2.2 RunableQueue接口分析2.3 拒绝策略2.4 BasicThreadPool（重点）2.5 ThreadPool
java-手写线程池
epitomizelu的专栏
07-05 201
原理： ThreadPool包含两大组件：BlockQueue和ThreadPool 线程达到上线之后，新进的任务都会进入BlockQueue 线程完成当前任务后会从BlockQueue中获取新的任务 package thread.pool; import java.util.*; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Condition; import java.util.concurren.
【手写线程池】Java 语言手写线程池
GreyKa的博客
08-30 403
【代码】【手写线程池】Java 语言手写线程池。
Java手写实现简单线程池
KKK
04-28 547
手写简易线程池
java手写自定义线程池
quanjiao4514的博客
04-01 359
11
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值