Java中使用Hutool的ExecutorBuilder实现自定义线程池

文档说明

自定义线程池ExecutorBuilder

在JDK中，提供了Executors用于创建自定义的线程池对象ExecutorService，但是考虑到线程池中存在众多概念，这些概念通过不同的搭配实现灵活的线程管理策略，单独使用Executors无法满足需求，构建了ExecutorBuilder。
概念

corePoolSize 初始池大小
maxPoolSize 最大池大小（允许同时执行的最大线程数）
workQueue 队列，用于存在未执行的线程
handler 当线程阻塞（block）时的异常处理器，所谓线程阻塞即线程池和等待队列已满，无法处理线程时采取的策略
线程池对待线程的策略

1、如果池中任务数<corePoolSize，放入立即执行。

2、如果池中任务数>corePoolSize,放入队列等待。

3、队列满，新建线程立即执行。

4、执行中的线程>maxPoolSize,触发handler(RejectedExecutionHandler)异常。
workQuene线程池策略

SynchronousQueue它将任务直接提交给线程而不保持他们。当运行线程小于maxPoolSize时会创建新线程，否则触发异常策略。

LinkedBlockingQueue默认无界队列，当运行线程大于corePoolSize时始终放入此队列，此时maxPoolSize无效。当构造LinkedBlockingQuene

对象时传入参数，变成有界队列，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略。

ArrayBlockingQuene有界队列，相对无界队列有利于控制队列大小，队列满时，运行线程小于maxPoolSize时会创建新线程，否则触发异常策略。

引入项目依赖

<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.3</version>
</dependency>

使用示例

private static ExecutorService pool = ExecutorBuilder.create()
        .setCorePoolSize(20)//初始20个线程
        .setMaxPoolSize(40)//最大40个线程
        .setWorkQueue(new LinkedBlockingQueue<>(60))//有界等待队列，最大等待数是60
        .setThreadFactory(ThreadFactoryBuilder.create().setNamePrefix("IM-Pool-").build())//设置线程前缀
        .build();

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

package sms.reyo.cn;
  
import cn.hutool.core.thread.ExecutorBuilder;
import cn.hutool.core.thread.ThreadFactoryBuilder;
import com.chrisf.sdk.protocal.Protocal;
import com.chrisf.sdk.utils.LocalSendHelper;
import io.netty.channel.Channel;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
  
/**
 * im 客户端用户集
 *
 * @author yansh
 */
public class ImUsers {
  
    private static ExecutorService pool = ExecutorBuilder.create()
            .setCorePoolSize(20)//初始20个线程
            .setMaxPoolSize(40)//最大40个线程
            .setWorkQueue(new LinkedBlockingQueue<>(60))//有界等待队列，最大等待数是60
            .setThreadFactory(ThreadFactoryBuilder.create().setNamePrefix("IM-Pool-").build())//设置线程前缀
            .build();
  
    /**
     * 用户集
     */
    private static Map<String, Channel> USERS = new ConcurrentHashMap<String, Channel>();
  
    /**
     * 存储用户
     *
     * @param key     唯一键
     * @param session 用户信息
     */
    public static void put(String key, Channel session) {
        USERS.put(key, session);
    }
  
    /**
     * 移除用户
     *
     * @param session 用户信息
     * @return 移除结果
     */
    public static boolean remove(Channel session) {
        String key = null;
        boolean flag = USERS.containsValue(session);
        if (flag) {
            Set<Map.Entry<String, Channel>> entries = USERS.entrySet();
            for (Map.Entry<String, Channel> entry : entries) {
                Channel value = entry.getValue();
                if (value.equals(session)) {
                    key = entry.getKey();
                    break;
                }
            }
        } else {
            return true;
        }
        return remove(key);
    }
  
    /**
     * 移出用户
     *
     * @param key 键
     */
    public static boolean remove(String key) {
        Channel remove = USERS.remove(key);
        if (remove != null) {
            boolean containsValue = USERS.containsValue(remove);
            return containsValue;
        } else {
            return true;
        }
    }
  
    /**
     * 获取在线用户列表
     *
     * @return 返回用户集合
     */
    public static Map<String, Channel> getUsers() {
        return USERS;
    }
  
    /**
     * 群发消息文本消息
     *
     * @param protocal 消息内容
     */
    public static void sendMessageToUsersByText(Protocal protocal) {
        Collection<Channel> values = USERS.values();
        for (Channel value : values) {
            pool.submit(() -> sendMessageToUserByText(value, protocal));
        }
    }
  
    /**
     * 发送消息
     *
     * @param session
     * @param protocal
     */
    public static void sendMessageToUserByText(Channel session, Protocal protocal) {
        if (session != null) {
            synchronized (session) {
                try {
                    LocalSendHelper.sendData(session,protocal,null);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        } else {
  
        }
    }
}