自定义线程池

最新推荐文章于 2023-02-19 17:28:47 发布
最新推荐文章于 2023-02-19 17:28:47 发布
阅读量163 收藏
点赞数
分类专栏： 深入理解java多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43907800/article/details/104486398
版权

1. 为什么需要线程池

1.1 对于操作系统来说

在操作系统创建线程、切换线程状态、终结线程都要进行CPU调度，进行上下文切换——这是一个耗费时间和系统资源的事情。

大多数实际场景中是这样的：处理某一次请求的时间是非常短暂的，但是请求数量是巨大的。这种技术背景下，如果我们为每一个请求都单独创建一个线程，那么物理机的所有资源基本上都被操作系统创建线程、切换线程状态、销毁线程这些操作所占用，用于业务请求处理的资源反而减少了。

所以最理想的处理方式是，将处理请求的线程数量控制在一个范围，既保证后续的请求不会等待太长时间，又保证物理机将足够的资源用于请求处理本身。

另外，一些操作系统是有最大线程数量限制的。当运行的线程数量逼近这个值的时候，操作系统会变得不稳定。这也是我们要限制线程数量的原因

总结来说：① 反复创建线程开销大 ② 过多的线程会占用太多的内存

1.2 对于服务器

服务器应用程序中经常出现的情况是：单个任务处理的时间很短而请求的数目却是巨大的，为每个请求创建新线程的服务器在创建和销毁线程上花费的时间和消耗的系统资源要比花在处理实际的用户请求的时间和资源更多

除了创建和销毁线程的开销之外，活动的线程也消耗系统资源（线程的生命周期!）。在一个JVM 里创建太多的线程可能会导致系统由于过度消耗内存而用完内存或“切换过度”。为了防止资源不足，服务器应用程序需要一些办法来限制任何给定时刻处理的请求数目。

2. 线程池的基本原理

在这里插入图片描述
线程池实际上是一个生产者消费者模型，生产者不断生成任务放入阻塞队列，线程池作为消费者不断从阻塞队列中取出任务执行，所有可以看到，我们的线程池实际是由一个存放线程的wokers集合(消费者)和一个存放任务的workQueue实现的(阻塞队列)

2.1 阻塞队列的实现

class BlockingQueue<T>{
    //任务队列
    private Deque<T> queue = new ArrayDeque<>();//性能比LinkedList更高

    //锁 不能让多个线程同时去把队列头的任务取走
    private ReentrantLock lock = new ReentrantLock();

    //针对消费的条件变量 没有元素的时候 阻塞等待
    private Condition emptyWaitSet = lock.newCondition();

    //针对生产者的条件变量 不能无限制的往阻塞队列加
    private Condition fullWaitSet = lock.newCondition();

    //容量
    private int capacity;

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

    public T take(){
        //加锁
        //如果没有任务就要阻塞等待任务
        lock.lock();
        try{
            while(queue.isEmpty()){
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }
    //带超时的阻塞获取
    public T poll(long timeout, TimeUnit timeUnit){
        lock.lock();
        try{
            long nanos = timeUnit.toNanos(timeout);
            while(queue.isEmpty()){
                try {
                    if (nanos<=0){//如果等待的时间超时了，直接返回
                        return null;
                    }
                     nanos = emptyWaitSet.awaitNanos(nanos);//返回值是总需要等待的时间-以及等待了的时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        }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();
        }
    }
}

2.2 线程池的实现

首先是我们刚刚定义的阻塞队列，用来存放生产者生产的线程
注意，生产者传进来的是线程任务，所有可以抽象出来Runnable

private BlockingQueue<Runnable> taskQueue;//任务可以抽象为Runnable

线程池的线程集合wokers

private HashSet wokers = new HashSet();

线程池的线程数

private int coreSize;

执行任务的方法
可以看到我们在任务数没有超过coresize，交给woker对象执行，woker对象是我们自己定义的线程池中的线程，下面会说，目的就是为了让传进来的任务使用线程池中的线程执行
如果现在线程池中的线程都在忙，那么会把任务加到阻塞队列等待

public void execute(Runnable task){
        //当任务数没有超过coresize，则交给woker对象执行
        //否则加入任务队列暂存
        synchronized (wokers){
            if(wokers.size()<coreSize){
                Woker woker = new Woker(task);
                wokers.add(woker);
                woker.start();//会调用run方法
            }else{
                taskQueue.put(task);
            }
        }

    }

我们在ThreadPool里面创造了一个内部类Woker ，这是我们线程池里面一直在运行的线程
我们的任务是要把生产者要运行的任务(线程)使用线程池里的线程运行，而不让他自己新起线程，所有我们在这里对外部传递的任务线程进行了包装，包装成了我们的Woker线程类，在Woker的run方法中调用任务线程的run方法(注意直接调用run方法是不会新启线程的，要调用start)

	class Woker extends Thread{
        private Runnable task;

        public Woker(Runnable task) {
            this.task = task;
        }
        @Override
        public void run(){
            //如果传来的有task，直接执行
            //如果没有 我们想到是想让这个线程不停止去执行，避免上下文切换，去取任务执行任务
            while(task!=null||(task= taskQueue.take())!=null){
                try{
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            //上面使用taskQueue.take()并不会移除，因为会在take一直阻塞等待
            synchronized (wokers){
                wokers.remove(this);
            }
        }
    }

再看上面的run方法取阻塞队列中取任务的时候使用的是take方法，还记不记得在实现阻塞队列的时候，take方法是无时间限制的等待，所有如果任务队列没有任务，我们就会一直等待，程序不会结束

想改变可以使用我们阻塞队列实现的带超时的阻塞获取poll()方法

完整代码

class ThreadPool{
	//阻塞队列
    private BlockingQueue<Runnable> taskQueue;//任务可以抽象为Runnable
    //线程集合
    private HashSet wokers = new HashSet();

    //规定线程数
    private int coreSize;

    //超时时间 一旦超过了超时时间还没有任务，可以让线程报废，不然让他一直跑会占用cpu
    private long timeout;

    private TimeUnit timeUnit;
    //执行任务
    public void execute(Runnable task){
        //当任务数没有超过coresize，则交给woker对象执行
        //否则加入任务队列暂存
        synchronized (wokers){
            if(wokers.size()<coreSize){
                Woker woker = new Woker(task);
                wokers.add(woker);
                woker.start();//会调用run方法
            }else{
                taskQueue.put(task);
            }
        }

    }

    public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity) {
        this.taskQueue = new BlockingQueue<>(queueCapacity);
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
    }

    class Woker extends Thread{
        private Runnable task;

        public Woker(Runnable task) {
            this.task = task;
        }
        @Override
        public void run(){
            //如果传来的有task，直接执行
            //如果没有 我们想到是想让这个线程不停止去执行，避免上下文切换，去取任务执行任务
            while(task!=null||(task= taskQueue.take())!=null){
                try{
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            //上面使用taskQueue.take()并不会移除，因为会在take一直阻塞等待
            synchronized (wokers){
                wokers.remove(this);
            }
        }
    }
}

使用

public class TestPool {
    public static void main(String[] args) {
    	//核心线程数为2
        //阻塞队列的容量为10
        ThreadPool pool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS,10);
        for(int i = 0; i < 15; i++){
            pool.execute(() ->{
                //任务
            });
        }
    }
}

2.3 offer增强

上面的代码有个问题，我们把线程池的核心线程数设置为2，阻塞队列的容量为10，再往线程池中添加15个任务，并让每个任务执行的时间足够长

那么可以看到，只会有12个任务运行和加到阻塞队列等待(核心线程数 + 任务队列的容量)，而另外的3个任务无法加到阻塞队列，那么主线程就会死等

那他们是在哪里阻塞的呢，再看一下put的代码，可以看到是在put的 fullWaitSet.await()一直等待

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 boolean offer(T task, long timeout, TimeUnit timeUnit){
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while(queue.size() == capacity){
                try {
                    if(nanos<0){
                        return false;
                    }
                    fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(task);
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
        return true;
    }

我们在队列满了以后可以有多种不同的选择策略
① 死等
② 超时等待，等不到就算啦
③ 让调用者自己执行
④ 让调用者抛出异常
⑤ 让给调用者放弃

我们希望可以自己选择添加的策略

这里可以使用策略模式，把队列满了以后的操作单独抽象出来，以后可以让操作者自己选择，而不是写死在线程池

//拒绝策略
interface RejectPolicy<T>{
    void reject(BlockingQueue<T> queue, T task);
}

在BlockingQueue改进一下加入的操作，新增tryPut方法

public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            if(queue.size() == capacity) {
                rejectPolicy.reject(this, task);
            } else {  // 有空闲
                   queue.addLast(task);
                   emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }
    }

在线程池中加入rejectPolicy成员变量，并更改构造方法

private RejectPolicy<Runnable> rejectPolicy;

public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity, RejectPolicy<Runnable> rejectPolicy) {
        this.taskQueue = new BlockingQueue<>(queueCapacity);
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.rejectPolicy = rejectPolicy;
    }

改进execute方法，我们就可以通过在构造方法传递进来的测量进行执行

public void execute(Runnable task){
        //当任务数没有超过coresize，则交给woker对象执行
        //否则加入任务队列暂存
        synchronized (wokers){
            if(wokers.size()<coreSize){
                Woker woker = new Woker(task);
                wokers.add(woker);
                woker.start();//会调用run方法
            }else{
                taskQueue.tryPut(rejectPolicy,task);
            }
        }
    }

测试

     ThreadPool pool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS,10,(queue, task) -> {
            // 1) 死等 
            //queue.put(task);  
            // 2) 带超时等待 
            //queue.offer(task, 1500, TimeUnit.MILLISECONDS);            
            // 3) 让调用者放弃任务执行     
            // log.debug("放弃{}", task);           
            // 4) 让调用者抛出异常         
            // throw new RuntimeException("任务执行失败 " + task);            
            // 5) 让调用者自己执行任务            
            // task.run();
        });

3. 完整代码

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

public class TestPool {
    public static void main(String[] args) {
        //核心线程数为2
        //阻塞队列的容量为10
        ThreadPool pool = new ThreadPool(2, 1000, TimeUnit.MILLISECONDS,10,(queue, task) -> {
            // 1) 死等
            //queue.put(task);
            // 2) 带超时等待
            //queue.offer(task, 1500, TimeUnit.MILLISECONDS);
            // 3) 让调用者放弃任务执行
            // log.debug("放弃{}", task);
            // 4) 让调用者抛出异常
            // throw new RuntimeException("任务执行失败 " + task);
            // 5) 让调用者自己执行任务
            // task.run();
        });
        for(int i = 0; i < 10; i++){
            pool.execute(() ->{
                //任务
            });
        }
    }

}

class ThreadPool{
    private RejectPolicy<Runnable> rejectPolicy;
    private BlockingQueue<Runnable> taskQueue;//任务可以抽象为Runnable
    //线程集合
    private HashSet wokers = new HashSet();

    //线程数
    private int coreSize;

    //超时时间 一旦超过了超时时间还没有任务，可以让线程报废，不然让他一直跑会占用cpu
    private long timeout;

    private TimeUnit timeUnit;
    //执行任务
    public void execute(Runnable task){
        //当任务数没有超过coresize，则交给woker对象执行
        //否则加入任务队列暂存
        synchronized (wokers){
            if(wokers.size()<coreSize){
                Woker woker = new Woker(task);
                wokers.add(woker);
                woker.start();//会调用run方法
            }else{
                taskQueue.tryPut(rejectPolicy,task);
            }
        }

    }

    public ThreadPool(int coreSize, long timeout, TimeUnit timeUnit, int queueCapacity, RejectPolicy<Runnable> rejectPolicy) {
        this.taskQueue = new BlockingQueue<>(queueCapacity);
        this.coreSize = coreSize;
        this.timeout = timeout;
        this.timeUnit = timeUnit;
        this.rejectPolicy = rejectPolicy;
    }

    class Woker extends Thread{
        private Runnable task;

        public Woker(Runnable task) {
            this.task = task;
        }
        @Override
        public void run(){
            //如果传来的有task，直接执行
            //如果没有 我们想到是想让这个线程不停止去执行，避免上下文切换，去取任务执行任务

            while(task!=null||(task= taskQueue.take())!=null){
                try{
                    task.run();
                }catch (Exception e){
                    e.printStackTrace();
                }finally {
                    task = null;
                }
            }
            //上面使用taskQueue.take()并不会移除，因为会在take一直阻塞等待
            synchronized (wokers){
                wokers.remove(this);
            }
        }
    }
}

class BlockingQueue<T>{
    //任务队列
    private Deque<T> queue = new ArrayDeque<>();//性能比LinkedList更高

    //锁 不能让多个线程同时去把队列头的任务取走
    private ReentrantLock lock = new ReentrantLock();

    //针对消费的条件变量 没有元素的时候 阻塞等待
    private Condition emptyWaitSet = lock.newCondition();

    //针对生产者的条件变量 不能无限制的往阻塞队列加
    private Condition fullWaitSet = lock.newCondition();

    //容量
    private int capacity;

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

    public T take(){
        //加锁
        //如果没有任务就要阻塞等待任务
        lock.lock();
        try{
            while(queue.isEmpty()){
                try {
                    emptyWaitSet.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        }finally {
            lock.unlock();
        }
    }
    //带超时的阻塞获取
    public T poll(long timeout, TimeUnit timeUnit){
        lock.lock();
        try{
            long nanos = timeUnit.toNanos(timeout);
            while(queue.isEmpty()){
                try {
                    if (nanos<=0){//如果等待的时间超时了，直接返回
                        return null;
                    }
                     nanos = emptyWaitSet.awaitNanos(nanos);//返回值是总需要等待的时间-以及等待了的时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            T t = queue.removeFirst();
            fullWaitSet.signal();
            return t;
        }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 boolean offer(T task, long timeout, TimeUnit timeUnit){
        lock.lock();
        try {
            long nanos = timeUnit.toNanos(timeout);
            while(queue.size() == capacity){
                try {
                    if(nanos<0){
                        return false;
                    }
                    fullWaitSet.awaitNanos(nanos);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            queue.addLast(task);
            emptyWaitSet.signal();
        }finally {
            lock.unlock();
        }
        return true;
    }

    public int size(){
        lock.lock();
        try{
            return queue.size();
        }finally {
            lock.unlock();
        }
    }

    public void tryPut(RejectPolicy<T> rejectPolicy, T task) {
        lock.lock();
        try {
            if(queue.size() == capacity) {
                rejectPolicy.reject(this, task);
            } else {  // 有空闲
                   queue.addLast(task);
                   emptyWaitSet.signal();
            }
        } finally {
            lock.unlock();
        }
    }
}

//拒绝策略
interface RejectPolicy<T>{
    void reject(BlockingQueue<T> queue, T task);
}
今天你学习了么
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java8并行流中自定义线程池操作示例
08-26
主要介绍了Java8并行流中自定义线程池操作,结合实例形式分析了并行流的相关概念、定义及自定义线程池的相关操作技巧,需要的朋友可以参考下
Java线程池配置由繁至简，找到适合自己的天命线程池（二）
一名Java小学生
08-22 872
上一篇我们简单介绍了下线程池的一些基本内容，不清楚或者想回顾的同学可以点进主页里查看，或者后面把链接🔗贴在评论里。我们这篇主要来解决上一篇最后提出的问题：根据项目，自己来设置合适的参数。这个合适到底要怎么来定义？且往下看。
线程池使用的场景和意义
cbb
09-18 344
java 线程池 java 提供了四种线程池 ： newCachedThreadPool newFixedThreadPool newScheduledThreadPool newSingleThreadExecutor
线程池最佳线程数量到底要如何配置？
HollisChuang's Blog
11-18 2198
一、前言对于从事后端开发的同学来说，线程是必须要使用了，因为使用它可以提升系统的性能。但是，创建线程和销毁线程都是比较耗时的操作，频繁的创建和销毁线程会浪费很多CPU的资源。此外，如果每...
22、7大参数自定义线程池（核心线程数，最大核心线程数。。。拒绝策略（4种））
分享java学习路上的一些笔记，不足之处多多见谅。
11-16 1069
第二种拒绝策略：（CallerRunsPolicy（哪来的去哪里））这里我们是main线程创建的，所以就是main线程去处理。第一步：5个人进去（2个核心数处理，3个再阻塞队列里面，最大5个个核心线程数（3个在等待阻塞队列满了唤醒））第三个拒绝策略（DisCarPolict（队列满了，丢掉任务（不处理）不会抛出异常））第二步：进去6个人（就会使用2个核心线程和，一个最大线程数里的了，（3个再阻塞队列里））7大参数模型：（这里也说下线程池的运行逻辑）走this方法里（可以看到有7个参数）
自定义线程池如何设置线程数量
u012897318的博客
02-19 707
线程池线程数设置
Spring Boot利用@Async如何实现异步调用：自定义线程池
08-27
主要给大家介绍了关于Spring Boot利用@Async如何实现异步调用：自定义线程池的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友可以参考下
java自定义线程池的原理简介
08-25
主要介绍了java自定义线程池的原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Android编程自定义线程池与用法示例
08-28
主要介绍了Android编程自定义线程池与用法,结合实例形式分析了Android线程池的功能、定义及简单使用方法,需要的朋友可以参考下
自定义线程池（一）核心参数
yywuzc123的博客
06-06 131
核心参数 核心线程数 corePoolSize 如果没有设置允许主线程过期，核心线程数为线程池中保留的最大线程数 最大线程数 maximumPoolSize 线程池能创建的最大工作线程数 线程存活时间 keepAliveTime，时间类型unit 即超过核心线程数的线程过期的时间，在指定时间内未获取到任务的话，则会回收线程。 任务队列 BlockingQueue 存放任务的阻塞队列，符合先进先出原则。有ArrayListBlockingQueue和LinkedBlockQueue两种。 线程工厂 Threa
什么是CPU密集型？什么是IO密集型？
李振伟的博客
04-15 1万+
1、CPU密集型 CPU密集型也叫计算密集型，指的是系统的硬盘、内存性能相对CPU要好很多，此时，系统运作大部分的状况是CPU Loading 100%，CPU要读/写I/O(硬盘/内存)，I/O在很短的时间就可以完成，而CPU还有许多运算要处理，CPU Loading很高。 CPU密集的意思是该任务需要大量的运算，而没有阻塞，CPU一直全速运行。CPU密集任务只有在真正的多核CPU上才可能得到加速（通过多线程），而在单核CPU上，无论你开几个模拟的多线程该任务都不可能得到加速，因为CPU总的运算能力就那些
【Thread】线程池的 7 种创建方式及自定义线程池
sco5282的博客
11-06 1万+
1. 什么是线程池 线程池（ThreadPool）是一种基于池化思想管理和使用线程的机制。它是将多个线程预先存储在一个“池子”内，当有任务出现时可以避免重新创建和销毁线程所带来性能开销，只需要从“池子”内取出相应的线程执行对应的任务即可。 使用线程池主要有以下优点： 降低资源消耗 提高响应速度 提高线程的可管理性 同时，阿里巴巴在其《Java开发手册》中也强制规定：线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。 2. 使用线程池 线程池的创建方法总共有 7 种，但总体来说可分为 2 类：
自定义线程池线程数量设置
Insect_boy的博客
01-03 232
IO密集型和cpu密集型
线程池原理之自定义线程池
zimo_1993的博客
09-27 879
一、队列 先说一下线程池底层的数据结构 队列：一种线性表，它的特性是先进先出，插入在一端，删除在另一端。 队列又分为阻塞队列BlockingQueue和非阻塞队列ConcurrentLinkedQueue                                      生产者生产元素插入队列，消费者消费元素在另一端删除（假定队列的容量为10） 它们两者的区别： 1、非阻塞队...
线程池各个参数详解以及如何自定义线程池
热门推荐
hello world
01-06 2万+
一：为什么要自己定义线程池 虽然jdk提供了几种常用特性的线程池给我们，但是很多时候，我还是需要自己去自定义自己需要特征的线程池。并且阿里巴巴规范手册里面，就是不建议使用jdk的线程池，而是建议程序员手动创建线程池。 为什么呢？原文如下 【强制】线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规...
生产上使用自定义线程池控制socket短连接需要注意的事项
MonkeyBrothers的博客
02-24 205
    欢迎大家搜索“小猴子的技术笔记”关注我的公众号，有问题可以及时和我交流。     对于一些平台业务对接除了http还有就是socket用的比较多了，特别软件是跟硬件设备做对接。在并发要求不是很高的时候，可以使用BIO的socket，因为它足够简单，足够方便。如果并发量很高的话，推荐使用NIO的socket，因为它能够支持较高的并发。     如果使用的是长连接的话，那么需要注意的是长连接的心跳保持，客户端的断线重连，报文格式的定义等。     如果可以的话，还是建议使用netty这个强大的框架，因
自定义线程池（仅使用）
weixin_42630616的博客
09-28 272
自定义线程池（我也不是很了解，但是我在公司组长教我用的，着急用暂时不用了解的（速食快餐），可以看一下） 第一步(导入这个类，关于线程池的一些配置) import java.util.concurrent.Executor; import java.util.concurrent.ThreadPoolExecutor; import org.slf4j.Logger; import org.sl...
线程池自定义线程池工厂
最新发布
09-16
线程池的自定义线程池工厂指的是我们可以通过自定义工厂类来创建线程池。在Java中，我们可以通过实现ThreadFactory接口来自定义线程池工厂。通过自定义工厂类，我们可以定制线程的创建方式，例如给线程设置特定的命名规则、设置线程的优先级等。 自定义线程池工厂的步骤如下： 1. 创建一个实现ThreadFactory接口的自定义工厂类，并实现其`newThread(Runnable r)`方法。 2. 在`newThread`方法中，我们可以通过`Thread`类的构造方法来创建线程，并进行一些定制化的操作，比如设置线程的名称、优先级等。 3. 自定义线程池工厂类的实例化后，我们可以将其作为参数传递给线程池创建方法中，以便使用自定义的线程池工厂来创建线程池。 举个例子，假设我们需要自定义线程池工厂来创建线程池，可以按照以下步骤进行： 1. 创建一个自定义线程池工厂类，例如`CustomThreadFactory`，并实现ThreadFactory接口。 2. 在`CustomThreadFactory`类中，实现`newThread(Runnable r)`方法，并在该方法中创建线程，并设置线程的名称。 3. 在使用线程池的地方，例如`Executors.newFixedThreadPool()`方法中，将`CustomThreadFactory`类的实例传递给`newFixedThreadPool()`方法，以使用自定义的线程池工厂来创建线程池。 通过自定义线程池工厂，我们可以更加灵活地控制线程的创建过程，并根据实际需求进行定制化操作。这样可以提高线程池的灵活性和可扩展性，使其更好地适用于各种场景的需求。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值