es中的线程池模块

已于 2022-03-03 21:31:34 修改
阅读量1k 收藏
点赞数 1
分类专栏： elasticsearch 文章标签： elasticsearch 大数据 big data
于 2022-03-03 18:04:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexingshishu/article/details/123260518
版权

1、线程池类型

有四种类型

  • direct：调用线程直接调用
  • fixed：固定线程数
  • fixed_auto_queue_size：固定线程数，队列大小可以自动调节
  • scaling：线程数可调节，在[core,max]之间。

通过枚举类型ThreadPoolType来定义

public enum ThreadPoolType {
        DIRECT("direct"),
        FIXED("fixed"),
        FIXED_AUTO_QUEUE_SIZE("fixed_auto_queue_size"), // TODO: remove in 9.0
        SCALING("scaling");

        private final String type;

        public String getType() {
            return type;
        }

        ThreadPoolType(String type) {
            this.type = type;
        }

        private static final Map<String, ThreadPoolType> TYPE_MAP =
            Arrays.stream(ThreadPoolType.values()).collect(Collectors.toUnmodifiableMap(ThreadPoolType::getType, Function.identity()));

        public static ThreadPoolType fromType(String type) {
            ThreadPoolType threadPoolType = TYPE_MAP.get(type);
            if (threadPoolType == null) {
                throw new IllegalArgumentException("no ThreadPoolType for " + type);
            }
            return threadPoolType;
        }
    }

2、es中的线程池

es根据任务分配不同的线程池。支持的线程池有

名称类型
sameDIRECT
genericSCALING
getFIXED
analyzeFIXED
writeFIXED
searchFIXED
search_throttledFIXED
managementSCALING
flushSCALING
refreshSCALING
warmerSCALING
snapshotSCALING
force_mergeFIXED
fetch_shard_startedSCALING
fetch_shard_storeSCALING
system_readFIXED
system_writeFIXED

其名称定义如下

public static class Names {
        public static final String SAME = "same";
        public static final String GENERIC = "generic";
        public static final String GET = "get";
        public static final String ANALYZE = "analyze";
        public static final String WRITE = "write";
        public static final String SEARCH = "search";
        public static final String SEARCH_THROTTLED = "search_throttled";
        public static final String MANAGEMENT = "management";
        public static final String FLUSH = "flush";
        public static final String REFRESH = "refresh";
        public static final String WARMER = "warmer";
        public static final String SNAPSHOT = "snapshot";
        public static final String FORCE_MERGE = "force_merge";
        public static final String FETCH_SHARD_STARTED = "fetch_shard_started";
        public static final String FETCH_SHARD_STORE = "fetch_shard_store";
        public static final String SYSTEM_READ = "system_read";
        public static final String SYSTEM_WRITE = "system_write";
    }

对应关系定义如下

public static final Map<String, ThreadPoolType> THREAD_POOL_TYPES = Map.ofEntries(
        entry(Names.SAME, ThreadPoolType.DIRECT),
        entry(Names.GENERIC, ThreadPoolType.SCALING),
        entry(Names.GET, ThreadPoolType.FIXED),
        entry(Names.ANALYZE, ThreadPoolType.FIXED),
        entry(Names.WRITE, ThreadPoolType.FIXED),
        entry(Names.SEARCH, ThreadPoolType.FIXED),
        entry(Names.MANAGEMENT, ThreadPoolType.SCALING),
        entry(Names.FLUSH, ThreadPoolType.SCALING),
        entry(Names.REFRESH, ThreadPoolType.SCALING),
        entry(Names.WARMER, ThreadPoolType.SCALING),
        entry(Names.SNAPSHOT, ThreadPoolType.SCALING),
        entry(Names.FORCE_MERGE, ThreadPoolType.FIXED),
        entry(Names.FETCH_SHARD_STARTED, ThreadPoolType.SCALING),
        entry(Names.FETCH_SHARD_STORE, ThreadPoolType.SCALING),
        entry(Names.SEARCH_THROTTLED, ThreadPoolType.FIXED),
        entry(Names.SYSTEM_READ, ThreadPoolType.FIXED),
        entry(Names.SYSTEM_WRITE, ThreadPoolType.FIXED));

3、es线程池实现

ThreadPool的主要成员和方法有

 3.1 线程池的初始化

在node启动时，会创建线程池。

final ThreadPool threadPool = new ThreadPool(settings, executorBuilders.toArray(new ExecutorBuilder[0]));

后面将线程池传递给需要使用线程池的模块。

final ResourceWatcherService resourceWatcherService = new ResourceWatcherService(settings, threadPool);

在线程池的构造函数中，全部的线程池被初始化。

public ThreadPool(final Settings settings, final ExecutorBuilder<?>... customBuilders) {
        assert Node.NODE_NAME_SETTING.exists(settings);

        final Map<String, ExecutorBuilder> builders = new HashMap<>();
        final int allocatedProcessors = EsExecutors.allocatedProcessors(settings);
        final int halfProcMaxAt5 = halfAllocatedProcessorsMaxFive(allocatedProcessors);
        final int halfProcMaxAt10 = halfAllocatedProcessorsMaxTen(allocatedProcessors);
        final int genericThreadPoolMax = boundedBy(4 * allocatedProcessors, 128, 512);
        builders.put(Names.GENERIC, new ScalingExecutorBuilder(Names.GENERIC, 4, genericThreadPoolMax, TimeValue.timeValueSeconds(30)));
        builders.put(Names.WRITE, new FixedExecutorBuilder(settings, Names.WRITE, allocatedProcessors, 10000, false));
        builders.put(Names.GET, new FixedExecutorBuilder(settings, Names.GET, allocatedProcessors, 1000, false));
        builders.put(Names.ANALYZE, new FixedExecutorBuilder(settings, Names.ANALYZE, 1, 16, false));
        builders.put(Names.SEARCH, new FixedExecutorBuilder(settings, Names.SEARCH, searchThreadPoolSize(allocatedProcessors), 1000, true));
        builders.put(Names.SEARCH_THROTTLED, new FixedExecutorBuilder(settings, Names.SEARCH_THROTTLED, 1, 100, true));
        builders.put(Names.MANAGEMENT, new ScalingExecutorBuilder(Names.MANAGEMENT, 1, 5, TimeValue.timeValueMinutes(5)));
        builders.put(Names.FLUSH, new ScalingExecutorBuilder(Names.FLUSH, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
        builders.put(Names.REFRESH, new ScalingExecutorBuilder(Names.REFRESH, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5)));
        builders.put(Names.WARMER, new ScalingExecutorBuilder(Names.WARMER, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
        builders.put(Names.SNAPSHOT, new ScalingExecutorBuilder(Names.SNAPSHOT, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));
        builders.put(Names.FETCH_SHARD_STARTED,
                new ScalingExecutorBuilder(Names.FETCH_SHARD_STARTED, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5)));
        builders.put(Names.FORCE_MERGE, new FixedExecutorBuilder(settings, Names.FORCE_MERGE, 1, -1, false));
        builders.put(Names.FETCH_SHARD_STORE,
                new ScalingExecutorBuilder(Names.FETCH_SHARD_STORE, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5)));
        builders.put(Names.SYSTEM_READ, new FixedExecutorBuilder(settings, Names.SYSTEM_READ, halfProcMaxAt5, 2000, false));
        builders.put(Names.SYSTEM_WRITE, new FixedExecutorBuilder(settings, Names.SYSTEM_WRITE, halfProcMaxAt5, 1000, false));

        for (final ExecutorBuilder<?> builder : customBuilders) {
            if (builders.containsKey(builder.name())) {
                throw new IllegalArgumentException("builder with name [" + builder.name() + "] already exists");
            }
            builders.put(builder.name(), builder);
        }
        this.builders = Collections.unmodifiableMap(builders);

        threadContext = new ThreadContext(settings);

        final Map<String, ExecutorHolder> executors = new HashMap<>();
        for (final Map.Entry<String, ExecutorBuilder> entry : builders.entrySet()) {
            final ExecutorBuilder.ExecutorSettings executorSettings = entry.getValue().getSettings(settings);
            final ExecutorHolder executorHolder = entry.getValue().build(executorSettings, threadContext);
            if (executors.containsKey(executorHolder.info.getName())) {
                throw new IllegalStateException("duplicate executors with name [" + executorHolder.info.getName() + "] registered");
            }
            logger.debug("created thread pool: {}", entry.getValue().formatInfo(executorHolder.info));
            executors.put(entry.getKey(), executorHolder);
        }

        executors.put(Names.SAME, new ExecutorHolder(DIRECT_EXECUTOR, new Info(Names.SAME, ThreadPoolType.DIRECT)));
        this.executors = unmodifiableMap(executors);

        final List<Info> infos =
                executors
                        .values()
                        .stream()
                        .filter(holder -> holder.info.getName().equals("same") == false)
                        .map(holder -> holder.info)
                        .collect(Collectors.toList());
        this.threadPoolInfo = new ThreadPoolInfo(infos);
        this.scheduler = Scheduler.initScheduler(settings, "scheduler");
        TimeValue estimatedTimeInterval = ESTIMATED_TIME_INTERVAL_SETTING.get(settings);
        this.cachedTimeThread = new CachedTimeThread(EsExecutors.threadName(settings, "[timer]"), estimatedTimeInterval.millis());
        this.cachedTimeThread.start();
    }

首次将线程池名与线程池的Builder对应关系，以及插件中自定义的线程池对应关系放到Map中。然后遍历该Map调用Buidler的build方法创建ExecutorHolder,放到名称与ExecutorHolder的对应关系executors中，最后向executors添加SAME的。

3.2 ExecutorBuilder

是创建Executor的Builder抽象类，子类有FixedExecutorBuilder和ScalingExecutorBuidler

3.3 Fixed线程池的创建

FixedExecutorBuilder用于创建fixed类型的线程池，通过EsExecutors.newFixed来创建。

ThreadPool.ExecutorHolder build(final FixedExecutorSettings settings, final ThreadContext threadContext) {
        int size = settings.size;
        int queueSize = settings.queueSize;
        final ThreadFactory threadFactory = EsExecutors.daemonThreadFactory(EsExecutors.threadName(settings.nodeName, name()));
        final ExecutorService executor =
                EsExecutors.newFixed(settings.nodeName + "/" + name(), size, queueSize, threadFactory, threadContext, trackEWMA);
        final ThreadPool.Info info =
            new ThreadPool.Info(name(), ThreadPool.ThreadPoolType.FIXED, size, size, null, queueSize < 0 ? null : new SizeValue(queueSize));
        return new ThreadPool.ExecutorHolder(executor, info);
    }


public static EsThreadPoolExecutor newFixed(String name, int size, int queueCapacity,
                                                ThreadFactory threadFactory, ThreadContext contextHolder, boolean trackEWMA) {
        BlockingQueue<Runnable> queue;
        if (queueCapacity < 0) {
            queue = ConcurrentCollections.newBlockingQueue();
        } else {
            queue = new SizeBlockingQueue<>(ConcurrentCollections.<Runnable>newBlockingQueue(), queueCapacity);
        }
        if (trackEWMA) {
            return new EWMATrackingEsThreadPoolExecutor(name, size, size, 0, TimeUnit.MILLISECONDS,
                queue, TimedRunnable::new, threadFactory, new EsAbortPolicy(), contextHolder);
        } else {
            return new EsThreadPoolExecutor(name, size, size, 0, TimeUnit.MILLISECONDS,
                queue, threadFactory, new EsAbortPolicy(), contextHolder);
        }
    }

3.4 scaling线程池的创建

ScalingExecutorBuilder用于创建scaling类型的线程池，通过EsExecutors.newScaling来创建

ThreadPool.ExecutorHolder build(final ScalingExecutorSettings settings, final ThreadContext threadContext) {
        TimeValue keepAlive = settings.keepAlive;
        int core = settings.core;
        int max = settings.max;
        final ThreadPool.Info info = new ThreadPool.Info(name(), ThreadPool.ThreadPoolType.SCALING, core, max, keepAlive, null);
        final ThreadFactory threadFactory = EsExecutors.daemonThreadFactory(EsExecutors.threadName(settings.nodeName, name()));
        final ExecutorService executor =
            EsExecutors.newScaling(
                    settings.nodeName + "/" + name(),
                    core,
                    max,
                    keepAlive.millis(),
                    TimeUnit.MILLISECONDS,
                    threadFactory,
                    threadContext);
        return new ThreadPool.ExecutorHolder(executor, info);
    }


public static EsThreadPoolExecutor newScaling(String name, int min, int max, long keepAliveTime, TimeUnit unit,
                                                  ThreadFactory threadFactory, ThreadContext contextHolder) {
        ExecutorScalingQueue<Runnable> queue = new ExecutorScalingQueue<>();
        EsThreadPoolExecutor executor =
            new EsThreadPoolExecutor(name, min, max, keepAliveTime, unit, queue, threadFactory, new ForceQueuePolicy(), contextHolder);
        queue.executor = executor;
        return executor;
    }

3.5 direct线程池的创建

通过EsExecutors.newDirectExecutorService来创建。

public static ExecutorService newDirectExecutorService() {
        return DIRECT_EXECUTOR_SERVICE;
    }

private static final ExecutorService DIRECT_EXECUTOR_SERVICE = new DirectExecutorService();

private static final class DirectExecutorService extends AbstractExecutorService {

        @SuppressForbidden(reason = "properly rethrowing errors, see EsExecutors.rethrowErrors")
        DirectExecutorService() {
            super();
        }

        @Override
        public void shutdown() {
            throw new UnsupportedOperationException();
        }

        @Override
        public List<Runnable> shutdownNow() {
            throw new UnsupportedOperationException();
        }

        @Override
        public boolean isShutdown() {
            return false;
        }

        @Override
        public boolean isTerminated() {
            return false;
        }

        @Override
        public boolean awaitTermination(long timeout, TimeUnit unit) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void execute(Runnable command) {
            command.run();
            rethrowErrors(command);
        }
    }

3.6 支持优先级的线程池

PrioritizedEsThreadPoolExecutor通过EsExecutors.newSinglePrioritizing来创建，继承自EsThreadPoolExecutor，队列使用PriorityBlockingQueue

kgduu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
ES线程池详解
u014645192的博客
09-30 2794
ES线程池详解）前言：Java自带线程池回顾默认线程池参数详解：Executors类ES基于jdk构建自己线程池。Fixed类型线程池Fixed_auto_queue_size类型线程池Scaling类型线程池Direct类型线程池Prioritized 类型线程池 前言： ES的操作中充斥着不同的操作任务类型，如Index、Search、刷新合并、recover等等。各种类型任务之间不但有着不同...
Elasticsearch 技术解析与实战.zip
07-25
前言 第1章 Elasticsearch入门 1 1.1 Elasticsearch是什么 1 1.1.1 Elasticsearch的历史 2 1.1.2 相关产品 3 1.2 全文搜索 3 1.2.1 Lucene介绍 4 1.2.2 Lucene倒排索引 4 1.3 基础知识 6 1.3.1 Elasticsearch术语及...
java es线程池_【java并发编程实战】第六章：线程池
weixin_42168830的博客
02-27 114
1.线程池众所周知创建大量线程时代价是非常大的： - 线程的生命周期开销非常大：创建需要时间，导致延迟处理请求，jvm需要分配空间。 - 资源消耗:线程需要占用空间，如果线程数大于可用的处理器数量，那么线程就会闲置，这给Gc造成压力。线程在竞争cpu的时候也会造成性能开销,所以线程不是越多越好，使用不当并不会增加运行效率。 - 稳定性：使用不当会造成内存溢出。继而就引申出线程池。1.1线程池的创建...
ES 源码，线程池
09-24 425
public class org.elasticsearch.threadpool.ThreadPool implements Scheduler, Closeable { public static class Names { public static final String SAME = "same"; public static final S...
ElasticSearch之线程池
Jackie的家
12-09 408
ElasticSearch之线程池
对于es线程池使用的思考
weixin_30861797的博客
03-27 175
es有内置的线程池 在实际项目中，发现 使用client框架关闭连接太慢（其实是把连接归还到池子里），采用异步关闭。 随着连接的关闭，计算机内存在不断下降 ------------------- 使用netstat -an 查看 也发现了不少timewait 状态的tcp连接 说明连接的确在不断的关闭。 但是如果采用高并发压力测试，仍然会报错。这涉...
ElasticSearch中文学习教程
02-23
在单机环境中部署ElasticSearch相对简单，只需下载并解压ElasticSearch软件包即可运行。这种方式适合于测试和开发环境。 **2.2. 服务器环境** 在生产环境中部署ElasticSearch时，通常会采用集群架构。这种情况下，...
nagios-plugin-elasticsearch:Nagios和NRPE检查Elasticsearch集群和节点
05-15
nagios-plugin-elasticsearch Nagios NRPE和“常规”检查，用于检查Elasticsearch集群和节点状态 依存关系 CPAN模块 Debian / Ubuntu软件包 ...线程池中被拒绝的工作单元 断路器跳闸 断路器内存大小限制
puppet-jmxtrans:用于jmxtrans的Puppet模块
05-10
jmxtrans是一个强大的工具，用于从Java应用程序中提取JMX（Java Management Extensions）度量，并将这些数据转发到各种后端，如Graphite、InfluxDB或Elasticsearch等，以便进行监控和分析。 JMX是Java平台的一个...
分布式搜索 elasticsearch 方案研究 - 基础知识
11-21
深入源码有助于理解Elasticsearch内部工作机制，例如使用Guice进行依赖注入和模块化设计。 **十九、Index流程** 了解索引流程有助于优化索引性能，包括文档的分析、存储和索引构建等步骤。 综上所述，掌握Elastic...
顺丰面经1
08-08
9. **Elasticsearch提高搜索效率**：Elasticsearch利用倒排索引，全文搜索和分布式架构，支持实时搜索和大数据量处理。 10. **MyBatis创建数据库**：MyBatis是一个持久层框架，通过XML或注解配置SQL，简化数据库...
java常用工具类封装
09-14
Java高级客户端提供了与Elasticsearch服务器通信的能力，支持复杂的查询、索引和聚合操作。它比基于HTTP的RestHighLevelClient更强大，能够更好地处理网络异常和序列化问题，同时提供了更丰富的API来操作数据。 3. ...
ESSH整合Spring 定时器配置
11-12
1. **引入依赖**：在项目中添加Spring Task模块的依赖。如果你使用的是Maven，可以在pom.xml中添加如下依赖： ```xml <groupId>org.springframework <artifactId>spring-context-support <version>5.x.x....
appplication-monitoring-accelerator:该存储库包含用于在基于Spring的Web应用程序中生成应用程序监视日志的代码，而无需修改应用程序的代码
05-13
在实际应用中，"application-monitoring-accelerator"可以与各种日志管理系统和监控工具配合使用，如ELK（Elasticsearch、Logstash、Kibana）堆栈、Prometheus、Grafana等，将收集到的监控数据进行可视化展示和深度...
spring-boot-demo：springboot 2.1+整合各种技术
01-29
：测试spring初始注解：@Async，覆盖串行线程池自定义线程池，无返回值纯初始化，有返回值Future，有返回值CompletableFuture ：整合redis，7大数据类型：string，list，set，zset，hash，geo，hyperloglog ：...
一文搞懂ES中的线程池
大叶子不小的博客
01-11 467
比如说你的物理机的cpu core是64个，但是此时es会去使用的cpu core可能也就32个，最大限制，此时就是要手动设置processors是64。queue大小是10000。在ES中每个es节点内部多有很多个thread pool，不同的thread pool都分担不同的任务，比如有负责查询的，有负责写入的，还有负责执行段合并的，等等。用于系统索引的读取，一般是指以“.”开头的索引，比如.security.线程池类型是固定的，默认为5和cpu core数量除以2 这两者中的最小值。
ES 线程池（thread pool）
kamactor的专栏
06-11 1482
ES 线程池（thread pool） ES 中每个节点有多种线程池，各有用途。重要的有： generic ：通用线程池，后台的 node discovery，上述的分片恢复（node recovery）等等一些通用后台的操作都会用到该线程池。该线程池线程数量默认为配置的处理器数量（processors）* 4，最小128，最大512。 index ：index/delete 等索引操作会用到该线程池，包括自动创建索引等。默认线程数量为配置的处理器数量，默认队列大小：200. search ：查询请
线程池的使用场景--采集es数据
TreeCode的博客
06-25 289
场景： 从ElasticSearch的多个index中持续增量采集数据 初步解决方案： 因为search_after本身可以采集多index，所以使用search_after直接采集数据 遇到的问题： search_after采集多个index有限制，要么明确指定多个index的具体名称，要么使用*通配符，这两种方式中，前者太刻板，每次执行采集任务都需要手动输入很多index名称，后者不灵活，会匹配到用户不愿意或者不需要采集的index。 解决方案优化 使用正则表达式匹配index 使用search_af
使用线程池查询ES千万级数据索引遇到的问题
weixin_43422362的博客
03-27 3164
使用场景： 公司接到一个需求，需要查询ES索引A中所有数据，并根据查询到的数据中的某个字段再去查询另外一个索引B，整合并获取最终需要的数据，再生成excel、上传oss等等。其中索引A和索引B中都存储了千万条数据，之前的同事是用单线程写的，查询索引A使用的是limit、from深层分页，最终数据生成大概需要…不知道需要多久，可能一个月也生成不出来，后来这个需求就落在了我这里。 在做这个需求之前我从未使用过ES，对线程池也是一知半解。我想到了使用线程池会提高处理速度，经过了一番研究，终于将处理速度从4分钟处理
如何配置Elasticsearch的线程池？
最新发布
03-29
在Elasticsearch中，线程池是用于处理各种任务的重要组件。它负责管理线程的创建、销毁和调度，以确保系统的高效运行。Elasticsearch提供了几种不同类型的线程池，可以根据不同的需求进行配置。 要配置Elastic...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kgduu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值