【java】实现一个简陋的线程池

最新推荐文章于 2024-04-28 13:42:01 发布
最新推荐文章于 2024-04-28 13:42:01 发布
阅读量848 收藏
点赞数
分类专栏： # Java题解 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48180029/article/details/123840787
版权

现在我有一个任务，希望异步执行，首先就考虑创建一个线程嘛

第一版

package com.su.demo.test;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;

/**
 * @ClassName Demo
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/30 10:32
 **/

@Slf4j
public class Demo {
    public static void main(String[] args) {
        FlashExecutor flashExecutor = new FlashExecutor();

        for (int i = 0; i < 10; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{}",Thread.currentThread().getName());
                log.debug("打印当前数值:{}",temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }

    }

}


class FlashExecutor implements Executor{
    @Override
    public void execute(Runnable command) {
        new Thread(command).start();
    }
}

就是一个任务对应创建一个线程去执行，显而易见，缺点是十分明显的。

在这里插入图片描述

第二版

package com.su.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName Server
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/10 8:52
 **/

@Slf4j
public class Main {
    public static void main(String[] args) {


        /**
         * 任务队列容量为10，但是有一百个任务需要执行
         */
        FlashExecutor flashExecutor = new FlashExecutor(10);

        for (int i = 0; i < 100; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{}",Thread.currentThread().getName());
                log.debug("打印当前数值:{}",temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });

            log.info("主线程循环次数:{}",temp);
        }

    }
}

@Slf4j
class FlashExecutor implements Executor {
    Worker worker;

    //任务队列
    ArrayBlockingQueue<Runnable> taskQueue;

    int queueCapacity;

    public FlashExecutor(int queueCapacity) {

        this.queueCapacity = queueCapacity;
        taskQueue = new ArrayBlockingQueue<>(queueCapacity);

        worker = new Worker(null);
        worker.start();
    }

    @Override
    public void execute(Runnable command) {

        //当任务队列不满的时候
        if(taskQueue.size() < queueCapacity){
            try {
                taskQueue.add(command);
            } catch (Exception e) {
                log.debug("任务队列已满，无法继续添加任务");
                e.printStackTrace();
            }
            log.debug("向任务队列中添加一个任务:{}",command);
        }


    }

    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //task不为空直接执行task
            //task执行完毕，从任务队列里获取任务

            while (true){
                if(task != null ){
                    try{
                        log.debug("正在执行...{}",task);
                        task.run();


                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        task = null;
                    }
                }else{

                    if(!taskQueue.isEmpty()){
                        try {
                            task = taskQueue.remove();
                        } catch (Exception e) {
                            log.info("任务队列为空，无法获取任务");
                            e.printStackTrace();
                        }
                    }
                }

            }
        }

    }
}

把任务丢到一个任务队列中，然后只启动一个worker线程，不断地从任务队列中获取任务，执行任务
缺点：当任务队列满了之后，会抛弃任务。

小步前进，实现不会丢弃任务

调用put()、take()方法

package com.su.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName Server
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/10 8:52
 **/

@Slf4j
public class Main {
    public static void main(String[] args) {


        /**
         * 任务队列容量为10，但是有一百个任务需要执行
         */
        FlashExecutor flashExecutor = new FlashExecutor(10);

        for (int i = 0; i < 100; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{}",Thread.currentThread().getName());
                log.debug("打印当前数值:{}",temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });

            log.info("主线程循环次数:{}",temp);
        }

    }
}

@Slf4j
class FlashExecutor implements Executor {
    Worker worker;

    //任务队列
    ArrayBlockingQueue<Runnable> taskQueue;

    int queueCapacity;

    public FlashExecutor(int queueCapacity) {

        this.queueCapacity = queueCapacity;
        taskQueue = new ArrayBlockingQueue<>(queueCapacity);

        worker = new Worker(null);
        worker.start();
    }

    @Override
    public void execute(Runnable command) {


        try {
            //当任务队列满时，会进入阻塞状态
            taskQueue.put(command);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.debug("向任务队列中添加一个任务:{}",command);


    }

    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //task不为空直接执行task
            //task执行完毕，从任务队列里获取任务

            while (true){
                if(task != null){
                    try{
                        log.debug("正在执行...{}",task);
                        task.run();


                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        task = null;
                    }
                }else{
                    try {
                        //当任务队列为空时，会阻塞
                        task = taskQueue.take();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }

    }
}

在这里插入图片描述

缺点：只有一个线程执行任务，太慢。如果有多个线程执行任务就好了。
还有就是线程一直死循环从任务队列中获取任务。

小步前进 自己实现一个阻塞队列

package com.su.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName Server
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/10 8:52
 **/

@Slf4j
public class Main {
    public static void main(String[] args) {

        FlashExecutor flashExecutor = new FlashExecutor(10);

        for (int i = 0; i < 5; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{}",Thread.currentThread().getName());
                log.debug("打印当前数值:{}",temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }

    }
}

@Slf4j
class FlashExecutor implements Executor {
    Worker worker;
    BlockQueue<Runnable> taskQueue;

    public FlashExecutor(int queueCapacity) {
        taskQueue = new BlockQueue<>(queueCapacity);
    }

    @Override
    public void execute(Runnable command) {

        if(worker == null){
            worker = new Worker(command);
            worker.start();
        }else{
            taskQueue.put(command);
        }

    }

    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //task不为空直接执行task
            //task执行完毕，从任务队列里获取任务

            while (true){
                if(task != null || (task = taskQueue.take()) != null){
                    try{
                        log.debug("正在执行...{}",task);
                        task.run();
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        task = null;
                    }
                }
            }
        }

    }
}

class BlockQueue<T>{
    private Deque<T> queue = new ArrayDeque<>();

    //锁
    private ReentrantLock lock = new ReentrantLock();


    //两个条件变量
    private Condition fullWaitSet = lock.newCondition();

    private Condition emptyWaitSet = lock.newCondition();

    //容量
    private int capacity;


    public BlockQueue(int capacity) {
        this.capacity = capacity;
    }




    public T take(){
        lock.lock();

        try{
            while (queue.isEmpty()) {
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            fullWaitSet.signal();
            return queue.removeFirst();
        }finally {
            lock.unlock();
        }

    }

    public void put(T element){
        lock.lock();
        try{
            while (queue.size() == capacity) {
                try {
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            queue.addLast(element);
            emptyWaitSet.signal();


        }finally {
            lock.unlock();
        }

    }

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




}

在这里插入图片描述

这个时候只有一个线程执行任务，它说它太累了啊。短时间内处理不完太多任务，万一任务队列满了。

@Slf4j
public class Main {
    public static void main(String[] args) {


        /**
         * 任务队列容量为10，但是有一百个任务需要执行
         */
        FlashExecutor flashExecutor = new FlashExecutor(10);

        for (int i = 0; i < 100; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{}",Thread.currentThread().getName());
                log.debug("打印当前数值:{}",temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });
        }

    }
}

第三版

希望实现可以有多个线程同时执行任务队列中的任务
初始化时，直接启动corePoolSize个工作线程先跑着，
然后死循环不断地从任务队列中获取任务，执行任务。

package com.su.demo;

import lombok.extern.slf4j.Slf4j;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @ClassName Server
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/10 8:52
 **/

@Slf4j
public class Main {
    public static void main(String[] args) {


        /**
         * 任务队列容量为10，但是有一百个任务需要执行
         */
        FlashExecutor flashExecutor = new FlashExecutor(2,10);

        for (int i = 0; i < 100; i++) {
            int temp = i;
            flashExecutor.execute(()->{
                log.debug("当前线程名称:{},打印当前数值:{}",Thread.currentThread().getName(),temp);
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });

            log.info("主线程循环次数:{}",temp);
        }

    }
}

@Slf4j
class FlashExecutor implements Executor {
    Worker[] workers;

    //任务队列
    ArrayBlockingQueue<Runnable> taskQueue;

    //队列容量
    int queueCapacity;


    //核心线程数
    int corePoolSize;

    public FlashExecutor(int corePoolSize,int queueCapacity) {

        this.queueCapacity = queueCapacity;
        taskQueue = new ArrayBlockingQueue<>(queueCapacity);
        this.corePoolSize =corePoolSize;

        workers = new Worker[corePoolSize];

        for (int i = 0; i < this.corePoolSize; i++) {
            workers[i] = new Worker(null);
            workers[i].start();
        }


    }

    @Override
    public void execute(Runnable command) {


        try {
            //当任务队列满时，会进入阻塞状态
            taskQueue.put(command);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        log.debug("向任务队列中添加一个任务:{}",command);


    }

    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //task不为空直接执行task
            //task执行完毕，从任务队列里获取任务

            while (true){
                if(task != null){
                    try{
                        log.debug("正在执行...{}",task);
                        task.run();


                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        task = null;
                    }
                }else{
                    try {
                        //当任务队列为空时，会阻塞
                        task = taskQueue.take();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

            }
        }

    }
}

第四版

package com.su.demo.test;

import lombok.extern.slf4j.Slf4j;

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

/**
 * @ClassName Main
 * @Description TODO
 * @Author Hangover
 * @Date 2022/3/27 16:26
 **/
@Slf4j(topic = "hang.Main")
public class Main {
    public static void main(String[] args) {
        ThreadPool threadPool = new ThreadPool(2, 1000, TimeUnit.MICROSECONDS, 10);


        for (int i = 0; i < 5; i++) {
            int temp = i;
            threadPool.execute(()->{
                log.debug("打印当前值:{}",temp);
            });
        }
    }
}

@Slf4j(topic = "hang.ThreadPool")
class ThreadPool{

    //任务队列
    private BlockQueue<Runnable> taskQueue;


    //线程集合
    private HashSet<Worker> workers = new HashSet<>();

    //核心线程数
    private int coreSize;

    //超时时间，没有任务时，
    private long timeout;

    private TimeUnit timeUnit;

    public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit,int queueCapacity) {
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;

        this.taskQueue = new BlockQueue<>(queueCapacity);
    }

    //执行任务
    public void execute(Runnable task){
        //任务数没有超过核心线程数，直接交给worker对象
        if(workers.size() < coreSize){

            Worker worker = new Worker(task);
            log.debug("新增 worker:{},任务:{}",worker,task);
            workers.add(worker);

            worker.start();
        }else{
            log.debug("加入任务队列{}",task);
            taskQueue.put(task);
        }


        //否则加入任务队列

    }

    class Worker extends Thread{

        private Runnable task;

        public Worker(Runnable task) {
            this.task = task;
        }

        @Override
        public void run() {
            //task不为空直接执行task
            //task执行完毕，从任务队列里获取任务

            while (task != null || (task = taskQueue.take()) != null){
                try{
                    log.debug("正在执行...{}",task);
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            synchronized (workers){
                log.debug("worker被移除...{}",this);
                workers.remove(this);
            }
        }
    }

}

class BlockQueue<T>{
    private Deque<T> queue = new ArrayDeque<>();

    //锁
    private ReentrantLock lock = new ReentrantLock();


    //两个条件变量
    private Condition fullWaitSet = lock.newCondition();

    private Condition emptyWaitSet = lock.newCondition();

    //容量
    private int capacity;


    public BlockQueue(int capacity) {
        this.capacity = capacity;
    }

    /**
     * 带超时的阻塞获取
     */

    public T poll(long timeout, TimeUnit unit){
        lock.lock();

        try{
            //将timeout统一转换为纳秒
            long nanos = unit.toNanos(timeout);

            while (queue.isEmpty()) {
                try {
                    //虚假等待问题
                    if(nanos <= 0){
                        return null;
                    }

                    nanos = emptyWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            fullWaitSet.signal();
            return queue.removeFirst();
        }finally {
            lock.unlock();
        }


    }



    public T take(){
        lock.lock();

        try{
            while (queue.isEmpty()) {
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            fullWaitSet.signal();
            return queue.removeFirst();
        }finally {
            lock.unlock();
        }

    }

    public void put(T element){
        lock.lock();
        try{
            while (queue.size() == capacity) {
                try {
                    fullWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            queue.addLast(element);
            emptyWaitSet.signal();


        }finally {
            lock.unlock();
        }

    }

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




}
繁星伴晚安
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 线程池封装_JAVA线程池及公共线程池的实现
weixin_30025473的博客
02-13 1378
一、为什么要使用线程池1、线程池比单线程的好处a. 重用存在的线程，减少对象创建、消亡的开销，性能佳。b. 可有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞。c. 提供定时执行、定期执行、单线程、并发数控制等功能。2、使用场景(1)当你的任务是非必要的时候。比如记录操作日志、通知第三方服务非必要信息等，可以使用线程池处理非阻塞任务(2)当你的任务非常耗时时候，可以采用...
Java中的线程池如何实现，一文彻底搞懂
程序媛小琬的博客
10-13 1989
在 HotSpot VM 的线程模型中，Java 线程被一对一映射为内核线程。 Java 在使用线程执行程序时，需要调用操作系统内核的 API，创建一个内核线程，操作系统要为线程分配一系列的资源；当该 Java 线程被终止时，这个内核线程也会被回收。因此 Java 线程的创建与销毁的成本很高，从而增加系统的性能开销。 除此之外，无限制地创建线同样会给系统带来性能问题。因为 CPU核数是有限的，大量的线程上下文切换会增加系统的性能开销。同时无限制地创建线程还可能导致 OOM。
【Java】实现一个简单的线程池
最新发布
qq_61024956的博客
04-28 4563
Java中自己实现一个简易的线程池。大家有兴趣可以在b站上看一看黑马的课程。
用Java实现一个简单的线程池
merrc的博客
03-15 1357
用java手写一个简单的线程池
Java线程池七个参数详解
热门推荐
IT小跟班
04-23 28万+
java多线程开发时，常常用到线程池技术，这篇文章是对创建java线程池时的七个参数的详细解释。 从源码中可以看出，线程池的构造函数有7个参数，分别是corePoolSize、maximumPoolSize、keepAliveTime、unit、workQueue、threadF...
Java简单实现线程池
weixin_44024891的博客
04-21 2393
一、线程池 线程池是一种缓冲提高效率的技术。 相当于一个池子，里面存放大量已经创建好的线程，当有一个任务需要处理时， 可以直接从池子里面取一个线程去执行它。 包括内存池，很多缓冲的技术都是采用这种技术。 其实理解起来很简答！ 为什么需要线程池，这种池的技术？ 1.1 减少开辟资源和销毁资源带来的损耗。 开辟线程，申请内存（具体的可以看C语言中malloc底层实现原理），销毁线程、释放内存资源等一些操作都是有时间消耗的。 因此一开始开辟大量的资源进行管理，需要使用时从池中取一个去使用， 使用完毕后再放回池中
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
qq_35716689的博客
03-25 14万+
开个新坑-手搓简易线程池。本系列文章将从零开始,一步步手工编码实现一个简单但功能完备的线程池。我们将逐步介绍线程池的各个核心组件,并分析它们的作用和实现思路。通过这个过程,我们可以更好地掌握多线程编程的技巧,并培养编码能力和系统性思维。
Java多线程案例之线程池
trong_ 的烂笔头
01-30 5438
介绍线程池的原理和简单实现, 进一步提高并发编程的效率.
Java多线程实现-线程池
kking_edc的博客
08-28 1451
在《阿里巴巴Java手册》里有这样一条： 【强制】线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 说明：使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销，解决资源不足的问题。如果不使用线程池，有可能造成系统创建大量同类线程而导致消耗完内存或者“过度切换”的问题。 简单来说使用线程池有以下几个目的： 线程是稀缺资源，不能频繁的创建 解耦作用：线程创建时执行完全分开，方便维护 可以将其放入一个池子中，方便给其他任务进行复用 一、线程池原理 谈到线程池就会想到池化技术，其中最
Java线程池实现原理
IT从业者，生活精致一点，工作认真一点！
04-30 2606
Java线程池运行原理
java 定时器线程池（ScheduledThreadPoolExecutor）的实现
08-19
Java定时器线程池，即`ScheduledThreadPoolExecutor`，是Java并发编程中一个重要的工具，它继承自`ThreadPoolExecutor`并扩展了定时和周期性任务的执行能力。`ScheduledThreadPoolExecutor`提供了定时执行、延迟执行...
一种类似JAVA线程池的C++线程池实现方法
08-25
4. **CommonThread**：这是一个具体的线程实现类，类似于Java的`Thread`类，但通常不直接使用，而是作为其他线程类的基础。 5. **DefaultThread**：这个类将`IRunnable`对象转化为线程，使得线程池可以处理这些任务...
java 注解实现一个可配置线程池的方法示例
08-26
Java 注解实现一个可配置线程池的方法示例 在 Java 中，使用注解实现一个可配置线程池的方法示例是非常有实践价值的。下面，我们将详细介绍如何使用 Java 注解实现一个可配置线程池。 PoolConfig 类 PoolConfig ...
java简单实现多线程及线程池实例详解
08-27
线程池是java中的一个高级多线程技术，它可以有效地提高程序的执行效率和性能。下面是一个简单的示例： ```java public class threadPoolTest { public static void main(String[] args) { //创建一个具有固定...
Java线程池运行状态监控实现解析
08-25
如果你想监控某一个线程池的执行状态，ThreadPoolExecutor类提供了相关的API，可以实时获取线程池的当前活动线程数、正在排队中的线程数、已经执行完成的线程数、总线程数等信息。 线程池使用示例代码如下： ```...
【基础题】【for循环】一行输出十个数
清风微醺的博客
12-16 5936
1.输出1~100，要求每行十个数 package com.itheima; public class Main { public static void main(String[] args) { int k=0; for(int i=1;i<101;i++){ System.out.print(i +" ");//输出不换行 k++; if(k == 10){ Sy
【Java】图形界面设计实战练习
清风微醺的博客
02-17 5713
图形化界面设计（GUI）实战练习 学生成绩管理系统实战练习之登陆界面 学生成绩管理系统 2.0（图形界面） 实例一 代码： package Gui; import javax.swing.*; import java.awt.*; public class MyFrame extends JFrame { JPanel jP1,jp2,jp3; JLabel label1,label2; JButton button1,button2; JTextField text.
【Java】【进阶篇】返回数组下标
清风微醺的博客
01-21 2852
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标 package com.itheima; import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int nums[] = {1,4,5,6,7,9,76,4
【java】手写一个HTTP服务器
清风微醺的博客
01-29 2692
练习1 客户端：发送数据 服务器：接收数据，并展示 客户端 package com.jvm.t1; import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.Socket; public class TCPClient { public static void main(String[] args) throws IOException {
使用Java实现一个动态线程池
02-21
可以使用Java的Executor框架来实现动态线程池。可以使用ThreadPoolExecutor类来创建线程池。可以设置核心线程数、最大线程数、线程存活时间等参数。 示例代码： ``` int corePoolSize = 5; int maximumPoolSize = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值