自定义线程池

最新推荐文章于 2023-09-21 10:41:56 发布
最新推荐文章于 2023-09-21 10:41:56 发布
阅读量209 收藏 1
点赞数
分类专栏： java 文章标签： 自定义线程池 线程池
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mahao25/article/details/99656246
版权

线程池的代码是简单线程池的实现，里面功能完成了：

  • 1.使用固定线程，执行任务
  • 2.实现线程池的拒绝策略，以及停止线程池
  • 3.线程池的扩容以及回收

上面的功能分成三部分完成，有三个版本的代码实现，具体步骤，在代码上有描述：

1.使用固定线程，执行任务

 1.封装Thread对象WorkThread，使其具有生命状态;
 2.初始化创建size个WorkThread,存储到WORK_THREAD_QUEUE;
 3.创建任务（Runnable）提交接口，将任务提交到TASK_QUEUE;

import chapter3.ThreadUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

/**
 * 实现线程池基本功能，使用固定线程，执行任务
 *
 * @author: mahao
 * @date: 2019/8/15
 */
public class ThreadPool1 {

    /*
    1.封装Thread对象WorkThread，使其具有生命状态;
    2.初始化创建size个WorkThread,存储到WORK_THREAD_QUEUE;
    3.创建任务（Runnable）提交接口，将任务提交到TASK_QUEUE;
     */

    private static final int DEFAULT_SIZE = 10;//默认线程中的数量
    private static long seq = 0;
    private static final String WORK_THREAD_PREFIX = "WORK_THREAD_";//默认线程中的数量

    private final int size;//线程池中的线程数量

    private final LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//任务队列
    private final List<WorkThread> WORK_THREAD_QUEUE = new ArrayList<>(DEFAULT_SIZE);//线程队列

    public ThreadPool1() {
        this(DEFAULT_SIZE);
    }

    public ThreadPool1(int size) {
        this.size = size;
        init();
    }

    //初始化创建size个工作线程，并启动
    private void init() {
        for (int i = 0; i < size; i++) {
            WorkThread wt = createWorkThread();
            wt.start();
        }
    }

    //提交任务
    public void submit(Runnable task) {

        synchronized (TASK_QUEUE) {
            // System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> begin");
            TASK_QUEUE.addLast(task);
            TASK_QUEUE.notifyAll();//唤醒等待的workThread
            //System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> end");
        }


    }


    //创建工作线程
    private WorkThread createWorkThread() {
        WorkThread workThread = new WorkThread(WORK_THREAD_PREFIX + (seq++));
        WORK_THREAD_QUEUE.add(workThread);
        return workThread;
    }

    private class WorkThread extends Thread {

        public Status statu = Status.FREE;//初始创建是空闲的
        private Runnable task;//工作线程负责执行的任务

        public WorkThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            //当线程未被关闭是，就一直运行
            OUTLINE:
            while (this.statu != Status.DEAD) {
                synchronized (TASK_QUEUE) {
                    while (TASK_QUEUE.isEmpty()) {//任务队列中为空，线程等待
                        try {
                            System.err.println(ThreadUtil.getName() + " be waiting, status: " + statu);
                            this.statu = Status.WAITING;//为以后中断线程使用，标记线程可中断，没有任务执行
                            TASK_QUEUE.wait();
                        } catch (InterruptedException e) {
                            System.err.println(ThreadUtil.getName() + " be interrupted, status: " + statu);
                            e.printStackTrace();
                            //当前线程发生中断请求，就跳转到线程循环外，判断是否线程状态是关闭了；
                            break OUTLINE;
                        }
                    }
                    //不为空，取出任务，然后设置工作线程状态
                    task = TASK_QUEUE.removeFirst();
                }

                //可以与其他线程并发执行任务，放在同步代码块之外
                if (task != null) {
                    this.statu = Status.RUNNING;
                    task.run();//运行任务
                    //运行结束后，任务值为空，线程状态置为空闲
                    this.statu = Status.FREE;
                    task = null;
                }

            }
        }

        public void close() {
            System.out.println("WorkThread.close -#- be close, current status :" + statu);
            this.statu = Status.DEAD;
        }
    }

    private enum Status {

        FREE, RUNNING, WAITING, DEAD
    }

}

class TestThreadPool1 {

    public static void main(String[] args) {
        ThreadPool1 threadPool1 = new ThreadPool1(10);
        for (int i = 0; i < 40; i++) {
            final int no = i;
            threadPool1.submit(() -> {
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> start");
                System.out.println("main -#- task submit ,no : " + no);
                ThreadUtil.sleep(new Random().nextInt(10) * 1000);
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> end");
            });
        }
    }
}

2.实现线程池的拒绝策略，以及停止线程池

拒绝策略：
      1.在提交任务的接口，检测线程池中任务队列的个数，大于限制，就不允许添加
停止线程：
      1.创建线程池对外暴露接口，外部调用
      2.在关闭接口中，遍历工作线程，中断workThread线程

import chapter3.ThreadUtil;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * 实现线程池的拒绝策略，以及停止线程池
 *
 * @author: mahao
 * @date: 2019/8/15
 */
public class ThreadPool2 {
     /*
    拒绝策略：
        1.在提交任务的接口，检测线程池中任务队列的个数，大于限制，就不允许添加
    停止线程：
        1.创建线程池对外暴露接口，外部调用
        2.在关闭接口中，遍历工作线程，中断workThread线程
     */

    private static final int DEFAULT_SIZE = 10;//默认线程中的数量
    private static long seq = 0;
    private static final String WORK_THREAD_PREFIX = "WORK_THREAD_";//默认线程中的数量
    private static final int DEFAULT_TASK_QUEUE_LIMIT_SIZE = 100;
    public static final DiscardPolicy default_discardPolicy = (task) -> {
        throw new DiscardException("discard the submit and throw exception... ");
    };

    private final int size;//线程池中的线程数量
    private final int taskQueueSize;//限制任务队列数
    private final LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//任务队列
    private final List<WorkThread> WORK_THREAD_QUEUE = new ArrayList<>(DEFAULT_SIZE);//线程队列
    private final DiscardPolicy discardPolicy;
    private boolean isClose = false;

    public ThreadPool2() {
        this(DEFAULT_SIZE, DEFAULT_TASK_QUEUE_LIMIT_SIZE, default_discardPolicy);
    }

    /**
     * @param size          执行线程的数量
     * @param taskQueueSize 任务队列限制的大小
     * @param discardPolicy 拒绝策略
     */
    public ThreadPool2(int size, int taskQueueSize, DiscardPolicy discardPolicy) {
        this.size = size;
        this.taskQueueSize = taskQueueSize;
        this.discardPolicy = discardPolicy;
        init();
    }

    //初始化创建size个工作线程，并启动
    private void init() {
        for (int i = 0; i < size; i++) {
            WorkThread wt = createWorkThread();
            wt.start();
        }
    }

    //提交任务
    public void submit(Runnable task) {
        if (isClose) {
            throw new IllegalStateException("Thread pool be closed ... ");
        }
        synchronized (TASK_QUEUE) {
            if (TASK_QUEUE.size() > taskQueueSize) {
                discardPolicy.discard(task);
            } else {
                // System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> begin");
                TASK_QUEUE.addLast(task);
                TASK_QUEUE.notifyAll();//唤醒等待的workThread
                //System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> end");
            }
        }
    }

    /**
     * 关闭线程池：
     * 1.中断所有没有执行任务的线程
     * 2.等待正在执行任务的线程，然后关闭
     */
    public void shutdown() throws InterruptedException {
        System.out.println("begin shutdowm thread pool ... ");
        while (!TASK_QUEUE.isEmpty()) {//等待任务队列，执行结束
            Thread.sleep(20);
        }
        int size = WORK_THREAD_QUEUE.size();
        while (size > 0) {
            for (WorkThread w : WORK_THREAD_QUEUE) {
                if (w.statu == Status.WAITING) {
                    w.interrupt();
                    w.close();
                    size--;
                } else {
                    Thread.sleep(20);
                }
            }
        }
        isClose = true;
    }

    //创建工作线程
    private WorkThread createWorkThread() {
        WorkThread workThread = new WorkThread(WORK_THREAD_PREFIX + (seq++));
        WORK_THREAD_QUEUE.add(workThread);
        return workThread;
    }

    private class WorkThread extends Thread {

        public Status statu = Status.FREE;//初始创建是空闲的
        private Runnable task;//工作线程负责执行的任务

        public WorkThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            //当线程未被关闭是，就一直运行
            OUTLINE:
            while (this.statu != Status.DEAD) {
                synchronized (TASK_QUEUE) {
                    while (TASK_QUEUE.isEmpty()) {//任务队列中为空，线程等待
                        try {
                            System.err.println(ThreadUtil.getName() + " be waiting, status: " + statu);
                            this.statu = Status.WAITING;//为以后中断线程使用，标记线程可中断，没有任务执行
                            TASK_QUEUE.wait();
                        } catch (InterruptedException e) {
                            System.err.println(ThreadUtil.getName() + " be interrupted, status: " + statu);
                            //e.printStackTrace();
                            //当前线程发生中断请求，就跳转到线程循环外，判断是否线程状态是关闭了；
                            break OUTLINE;
                        }
                    }
                    //不为空，取出任务，然后设置工作线程状态
                    task = TASK_QUEUE.removeFirst();
                }

                //可以与其他线程并发执行任务，放在同步代码块之外
                if (task != null) {
                    this.statu = Status.RUNNING;
                    task.run();//运行任务
                    //运行结束后，任务值为空，线程状态置为空闲
                    this.statu = Status.FREE;
                    task = null;
                }

            }
        }

        public void close() {
            System.out.println("**  ** WorkThread.close -#-  " + getName() + " is closeing , current status :" + statu);
            this.statu = Status.DEAD;
        }
    }

    private enum Status {

        FREE, RUNNING, WAITING, DEAD
    }

    //拒绝策略接口
    public interface DiscardPolicy {
        void discard(Runnable task) throws DiscardException;
    }

    public static class DiscardException extends RuntimeException {
        public DiscardException(String msg) {
            super(msg);
        }
    }
}

class TestThreadPool2 {

    public static void main(String[] args) throws InterruptedException {
        ThreadPool2 threadPool2 = new ThreadPool2(10, 40, ThreadPool2.default_discardPolicy);

        for (int i = 0; i < 40; i++) {
            final int no = i;
            threadPool2.submit(() -> {
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> start");
                System.out.println("main -#- task submit ,no : " + no);
                ThreadUtil.sleep(3_000);
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> end");
            });
        }
        ThreadUtil.sleep(10000);

        threadPool2.shutdown();

        threadPool2.submit(() -> {
        });
    }
}

3.增加线程池的扩容以及回收

扩容与回收
        1.更改线程池也为线程，当初始化线程完毕后，启动扩容方法
        2.扩容：
            1.当TASK_QUEUE大于当前线程数量，扩容到指定大小
            2.当TASK_QUEUE为空时，减少工作线程数量

import chapter3.ThreadUtil;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
 * 增加线程池的扩容以及回收
 *
 * @author: mahao
 * @date: 2019/8/15
 */
public class ThreadPool3 extends Thread {

    /*
        扩容与回收
        1.更改线程池也为线程，当初始化线程完毕后，启动扩容方法
        2.扩容：
            1.当TASK_QUEUE大于当前线程数量，扩容到指定大小
            2.当TASK_QUEUE为空时，减少工作线程数量

     */

    //private static final int DEFAULT_SIZE = 10;//默认线程中的数量
    private static long seq = 0;
    private static final String WORK_THREAD_PREFIX = "WORK_THREAD_";//默认线程中的数量
    private static final int DEFAULT_TASK_QUEUE_LIMIT_SIZE = 100;
    public static final ThreadPool3.DiscardPolicy default_discardPolicy = (task) -> {
        throw new ThreadPool3.DiscardException("discard the submit and throw exception... ");
    };

    private int size;//线程池中的线程数量
    private final int taskQueueSize;//限制任务队列数
    private final LinkedList<Runnable> TASK_QUEUE = new LinkedList<>();//任务队列
    private final List<WorkThread> WORK_THREAD_QUEUE = new ArrayList<>();//线程队列
    private final ThreadPool3.DiscardPolicy discardPolicy;
    private boolean isClose = false;//标记线程池是否已经关闭

    private final int min;
    private int active;
    private final int max;

    public ThreadPool3() {
        this(3, 5, 10, DEFAULT_TASK_QUEUE_LIMIT_SIZE, default_discardPolicy);
    }

    /**
     * @param min           线程池中的最小数量
     * @param active        线程中的活跃数量
     * @param max           线程池中的最大数量
     * @param taskQueueSize 任务队列限制的大小
     * @param discardPolicy 拒绝策略
     */
    public ThreadPool3(int min, int active, int max, int taskQueueSize, DiscardPolicy discardPolicy) {
        this.size = size;
        this.taskQueueSize = taskQueueSize;
        this.discardPolicy = discardPolicy;
        this.min = min;
        this.active = active;
        this.max = max;

        init();

        this.start();//初始化完毕后，启动维护线程池大小的线程
    }

    //初始化创建size个工作线程，并启动
    private void init() {
        for (int i = 0; i < min; i++) {
            System.out.println("init --create -- " + i);
            WorkThread wt = createWorkThread();
            wt.start();
        }
        this.size = min;
    }

    @Override
    public void run() {
        while (!isClose) {//当线程池没被关闭

            System.out.printf("-- Pool#Min:%d , Active:%d , Max:%d; current:%d ， WORK_THREAD_QUEUE size:%d , TASK_QUEUE size:%d\n",
                    min, active, max, size, WORK_THREAD_QUEUE.size(), TASK_QUEUE.size());
            try {
                Thread.sleep(2000);
                //扩容
                if (TASK_QUEUE.size() > active && size < active) {
                    for (int i = size; i < active; i++) {
                        WorkThread w = createWorkThread();
                        w.start();
                    }
                    size = active;
                    System.out.println("--- TASK_QUEUE.size() > active  ---");
                } else if (TASK_QUEUE.size() > max && size < max) {
                    for (int i = size; i < max; i++) {
                        WorkThread w = createWorkThread();
                        w.start();
                    }
                    size = max;
                    System.out.println("---  TASK_QUEUE.size() > max  ---");
                }

                //减容
                if (TASK_QUEUE.isEmpty() && active < size) {
                    System.out.println("===========Reduce===========");
                    synchronized (TASK_QUEUE) {
                        int releaseSize = size - active;
                        for (Iterator<WorkThread> it = WORK_THREAD_QUEUE.iterator(); it.hasNext(); ) {
                            if (releaseSize <= 0)
                                break;
                            WorkThread w = it.next();
                            if (w.statu == Status.WAITING) {
                                w.close();
                                w.interrupt();
                                it.remove();
                                releaseSize--;
                            }
                            size = WORK_THREAD_QUEUE.size();

                        }
                    }
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //提交任务
    public void submit(Runnable task) {
        if (isClose) {
            throw new IllegalStateException("Thread pool be closed ... ");
        }
        synchronized (TASK_QUEUE) {
            if (TASK_QUEUE.size() > taskQueueSize) {
                discardPolicy.discard(task);
            } else {
                // System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> begin");
                TASK_QUEUE.addLast(task);
                TASK_QUEUE.notifyAll();//唤醒等待的workThread
                //System.out.println("submit -#- add task,current TASK_QUEUE size : " + TASK_QUEUE.size() + " >> end");
            }
        }
    }

    /**
     * 关闭线程池：
     * 1.中断所有没有执行任务的线程
     * 2.等待正在执行任务的线程，然后关闭
     */
    public void shutdown() throws InterruptedException {
        System.out.println("begin shutdowm thread pool ... ");
        while (!TASK_QUEUE.isEmpty()) {//等待任务队列，执行结束
            Thread.sleep(20);
        }
        int size = WORK_THREAD_QUEUE.size();
        while (size > 0) {
            for (ThreadPool3.WorkThread w : WORK_THREAD_QUEUE) {
                if (w.statu == ThreadPool3.Status.WAITING) {
                    w.interrupt();
                    w.close();
                    size--;
                } else {
                    Thread.sleep(20);
                }
            }
        }
        isClose = true;
    }

    //创建工作线程
    private ThreadPool3.WorkThread createWorkThread() {
        ThreadPool3.WorkThread workThread = new ThreadPool3.WorkThread(WORK_THREAD_PREFIX + (seq++));
        WORK_THREAD_QUEUE.add(workThread);
        return workThread;
    }

    private class WorkThread extends Thread {

        public ThreadPool3.Status statu = ThreadPool3.Status.FREE;//初始创建是空闲的
        private Runnable task;//工作线程负责执行的任务

        public WorkThread(String name) {
            super(name);
        }

        @Override
        public void run() {
            //当线程未被关闭是，就一直运行
            OUTLINE:
            while (this.statu != ThreadPool3.Status.DEAD) {
                synchronized (TASK_QUEUE) {
                    while (TASK_QUEUE.isEmpty()) {//任务队列中为空，线程等待
                        try {
                            //System.err.println(ThreadUtil.getName() + " be waiting, status: " + statu);
                            this.statu = ThreadPool3.Status.WAITING;//为以后中断线程使用，标记线程可中断，没有任务执行
                            TASK_QUEUE.wait();
                        } catch (InterruptedException e) {
                            System.err.println(ThreadUtil.getName() + " be interrupted, status: " + statu);
                            //e.printStackTrace();
                            //当前线程发生中断请求，就跳转到线程循环外，判断是否线程状态是关闭了；
                            break OUTLINE;
                        }
                    }
                    //不为空，取出任务，然后设置工作线程状态
                    task = TASK_QUEUE.removeFirst();
                }

                //可以与其他线程并发执行任务，放在同步代码块之外
                if (task != null) {
                    this.statu = ThreadPool3.Status.RUNNING;
                    task.run();//运行任务
                    //运行结束后，任务值为空，线程状态置为空闲
                    this.statu = ThreadPool3.Status.FREE;
                    task = null;
                }

            }
        }

        public void close() {
            System.out.println("**  ** WorkThread.close -#-  " + getName() + " is closeing , current status :" + statu);
            this.statu = ThreadPool3.Status.DEAD;
        }
    }

    private enum Status {

        FREE, RUNNING, WAITING, DEAD
    }

    //拒绝策略接口
    public interface DiscardPolicy {
        void discard(Runnable task) throws ThreadPool3.DiscardException;
    }

    public static class DiscardException extends RuntimeException {
        public DiscardException(String msg) {
            super(msg);
        }
    }
}

class TestThreadPool3 {

    public static void main(String[] args) throws InterruptedException {
        ThreadPool3 threadPool3 = new ThreadPool3(3, 10, 20, 200, ThreadPool3.default_discardPolicy);

        for (int i = 0; i < 40; i++) {
            final int no = i;
            threadPool3.submit(() -> {
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> start");
                //System.out.println("main -#- task submit ,no : " + no);
                ThreadUtil.sleep(5_000);
                //System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> end");
            });
        }

        ThreadUtil.sleep(15_000);

        for (int i = 40; i < 100; i++) {
            final int no = i;
            threadPool3.submit(() -> {
                System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> start");
                // System.out.println("main -#- task submit ,no : " + no);
                ThreadUtil.sleep(3_000);
                // System.out.println("WorkThread.run -#- is running , current WorkThread name ：" + ThreadUtil.getName() + " , task no : " + no + "  >> end");
            });
        }

        ThreadUtil.sleep(15_000);
        threadPool3.shutdown();

        threadPool3.submit(() -> {

        });
    }
}

GitHub源码地址

小么嘛小二郎
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# ——自定义线程池
04-16
用C#自己实现的线程池。很好的范例。有助于对线程池，线程同步，线程锁的学习。很真研究通这个例子之后，我相信你对线程肯定有深刻的了解
【Thread】线程池的 7 种创建方式及自定义线程池
热门推荐
sco5282的博客
11-06 1万+
1. 什么是线程池 线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制。它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。 使用线程池主要有以下优点： 降低资源消耗 提高响应速度 提高线程的可管理性 同时，阿里巴巴在其《Java开发手册》中也强制规定：线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 2. 使用线程池 线程池的创建方法总共有 7 种，但总体来说可分为 2 类：
【详解】线程池及其自定义线程池的实现
Money、坤的博客
07-08 2040
1. 为什么使用线程池？线程池是运用场景最多的并发框架，几乎所有需要一步或者并发执行任务的程序都可以使用线程池。使用线程池一般有以下三个好处：①降低资源的消耗，通过重复利用已经创建的线程降低线程创建和销毁造成的消耗。②提高相应速度，当任务到达的时候，任务可以不需要等到线程创建就能立刻执行。③提高线程的可管理性，线程是稀缺资源，使用线程池可以统一的分配、调优和监控。2. Java中的线程池ThreadPool 线程池参数介绍 1）corePoolSize（线程池的基本大小）：当提交一个任务到线程池时，线程
Java8并行流中自定义线程池操作示例
08-26
主要介绍了Java8并行流中自定义线程池操作,结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧,需要的朋友可以参考下
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
java自定义线程池的原理简介
08-25
主要介绍了java自定义线程池的原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Android编程自定义线程池与用法示例
08-28
主要介绍了Android编程自定义线程池与用法,结合实例形式分析了Android线程池的功能、定义及简单使用方法,需要的朋友可以参考下
java多线程学习笔记之自定义线程池
08-29
本篇文章主要介绍了java多线程学习笔记之自定义线程池 ，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
JAVA 自定义线程池的最大线程数设置方法
08-18
主要介绍了JAVA 自定义线程池的最大线程数设置方法，文中示例代码非常详细，供大家参考和学习，感兴趣的朋友可以了解下
在C＃中创建自定义线程池
04-11
初学者创建自定义线程池的方法，以了解多线程和同步的概念。
JUC–自定义线程池
12-20
自定义线程线程池 如果当前线程池中的线程数目小于corePoolSize，则每来一个任务，就会创建一个线程去执行这个任务； 如果当前线程池中的线程数目>=corePoolSize，则每来一个任务，会尝试将其添加到任务缓存队列当中...
Python自定义线程池实现方法分析
09-20
主要介绍了Python自定义线程池实现方法,结合实例形式较为详细的分析了Python自定义线程池的概念、原理、实现方法及相关注意事项,需要的朋友可以参考下
线程池使用之自定义线程池
最新发布
qq_61313896的博客
09-21 592
线程池使用之自定义线程池
Java自定义线程池
今天又是充满希望的一天
02-20 1万+
一、Java语言本身也是多线程，回顾Java创建线程方式如下： 1、继承Thread类,(Thread类实现Runnable接口)，来个类图加深印象。 2、实现Runnable接口实现无返回值、实现run()方法，啥时候run，黑话了。 3、实现Callable接口重写call()+FutureTask获取. public class CustomThread { public static void main(String[] args) { // 自定义线程 .
线程池自定义线程池工厂
09-16
线程池的自定义线程池工厂指的是我们可以通过自定义工厂类来创建线程池。在Java中，我们可以通过实现ThreadFactory接口来自定义线程池工厂。通过自定义工厂类，我们可以定制线程的创建方式，例如给线程设置特定的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值