【ElasticSearch】es 线程池 ThreadPool 的封装

已于 2023-04-13 15:59:46 修改
阅读量1.5k 收藏
点赞数 1
分类专栏： 大数据-Elasticsearch 文章标签： elasticsearch 线程池 ThreadPool
于 2021-04-22 21:44:53 首次发布
原文链接：https://www.jianshu.com/p/835671c34354
版权
大数据-Elasticsearch 专栏收录该内容
555 篇文章 544 订阅 ¥79.90 ¥99.00
订阅专栏

文章目录


在这里插入图片描述

1.概述

转载：［10］elasticsearch源码深入分析——线程池的封装

2.线程池在何时初始化

当Node完成了PluginsService的构造后，紧接会通过getExecutorBuilders方法取得线程池的Executor构造器列表，代码如下：

List<ExecutorBuilder<?>> executorBuilders = pluginsService.getExecutorBuilders(settings)

此时PluginsService对象中已经有了需要加载的所有plugin了，包含modules路径和plugins路径中的所有组件，这里统称为plugin。如下图所示总共是包含了13个已加载的Plugin，分别是modules路径中的默认必须加载的12个和Plugins路径中的自定义安装的1个（ICU分词器）。如下图所示
在这里插入图片描述

内存中的plugin对象

3.构建线程池框架

3.1 初始化ExecutorBuilder集合

Node实例化过程中，通过代码：

List<ExecutorBuilder<?>> executorBuilders = 
pluginsService.getExecutorBuilders(settings);

查找到自定义的线程池Executor构建器。再获得自定义线程池构建器集合后，开始构建线程池（ThreadPool）。

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

3.1.1 构造函数

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

        final Map<String, ExecutorBuilder> builders = new HashMap<>();
        // 获得处理器CPU的数量，
        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, 200));
        builders.put(Names.GET, new FixedExecutorBuilder(settings, Names.GET, allocatedProcessors, 1000));
        builders.put(Names.ANALYZE, new FixedExecutorBuilder(settings, Names.ANALYZE, 1, 16));
        builders.put(Names.SEARCH, new AutoQueueAdjustingExecutorBuilder(settings,
                        Names.SEARCH, searchThreadPoolSize(allocatedProcessors), 1000, 1000, 1000, 2000));
        builders.put(Names.SEARCH_THROTTLED, new AutoQueueAdjustingExecutorBuilder(settings,
            Names.SEARCH_THROTTLED, 1, 100, 100, 100, 200));
        builders.put(Names.MANAGEMENT, new ScalingExecutorBuilder(Names.MANAGEMENT, 1, 5, TimeValue.timeValueMinutes(5)));
        // no queue as this means clients will need to handle rejections on listener queue even if the operation succeeded
        // the assumption here is that the listeners should be very lightweight on the listeners side
        builders.put(Names.LISTENER, new FixedExecutorBuilder(settings, Names.LISTENER, halfProcMaxAt10, -1, true));
        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));
        builders.put(Names.FETCH_SHARD_STORE,
                new ScalingExecutorBuilder(Names.FETCH_SHARD_STORE, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5)));

        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()) {
            logger.info("分配线程池每种类型的情况：name:{}  value:{}",entry.getKey(),entry.getValue().getRegisteredSettings());

            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);

        logger.info("初始化Scheduler.initScheduler");
        this.scheduler = Scheduler.initScheduler(settings);
        TimeValue estimatedTimeInterval = ESTIMATED_TIME_INTERVAL_SETTING.get(settings);

        logger.info("创建CachedTimeThread 并且设置成 daemon");
        this.cachedTimeThread = new CachedTimeThread(EsExecutors.threadName(settings, "[timer]"), estimatedTimeInterval.millis());
        this.cachedTimeThread.start();
    }

首先通过代码获得处理器CPU的数量，

Runtime.getRuntime().availableProcessors()

当然这个值是可以被Setting中设置的变量processors来覆盖的。这个变量在代码中被标记为availableProcessors。然后创建变量

  1. halfProcMaxAt5，这个变量的意思是availableProcessors的一半，但最大不超过5。
  2. halfProcMaxAt10，这个变量的意思是availableProcessors的一半，但最大不超过10。

这两个变量在后面创建各种线程池构造器中反复用到。

在确定了可使用的处理器数量后，就能确定线程池的最小值（genericThreadPoolMax），ElasticSearch中是确定为：可用CPU处理器数量的4倍，且固定范围为最小128，最大为512。

由此可见如果用一般服务器的话，线程池上限最终会被确定为128，可以说还是比较高的设定了。

接下来开始构造执行不同操作时线程池Executor，ElasticSearch中把各个操作的Executor构造为Map，Map<String, ExecutorBuilder>，下面是各个Executor对象的解释：

3.1.1.1 普通操作的Executor

普通操作的Executor：构建一个可伸缩的Executor构建器，value为ScalingExecutorBuilder对象。接收参数和对应操作如下：

builders.put(Names.GENERIC, new ScalingExecutorBuilder(Names.GENERIC, 4, genericThreadPoolMax, TimeValue.timeValueSeconds(30)));

public ScalingExecutorBuilder(final String name, final int core, final int max, final TimeValue keepAlive, final String prefix) {
    super(name);
    this.coreSetting =
        Setting.intSetting(settingsKey(prefix, "core"), core, Setting.Property.NodeScope);
    this.maxSetting = Setting.intSetting(settingsKey(prefix, "max"), max, Setting.Property.NodeScope);
    this.keepAliveSetting =
        Setting.timeSetting(settingsKey(prefix, "keep_alive"), keepAlive, Setting.Property.NodeScope);
}
  1. name：线程池执行者的名称，也就是generic。
  2. core：线程池中线程的最小值，固定为4。将thread_pool.generic.core的设为这个值。
  3. max：线程池中线程的最大值，对应上面提到的genericThreadPoolMax，在本机跑的结果是128
  4. keepAlive：超过4个线程后，线程保持活跃的时间。这个值固定为30秒。这个参数被设定为变量thread_pool.generic.keep_alive
3.1.1.2 索引操作的Executor

索引操作的Executor：构建一个固定的Executor构建器。key为index，value为FixedExecutorBuilder对象，接收参数和对应操作如下：

public FixedExecutorBuilder(
        final Settings settings,
        final String name,
        final int size,
        final int queueSize,
        final String prefix,
        final boolean deprecated
    ) {
        super(name);
        final String sizeKey = settingsKey(prefix, "size");
        final Setting.Property[] properties;
        if (deprecated) {
            properties = new Setting.Property[]{Setting.Property.NodeScope, Setting.Property.Deprecated};
        } else {
            properties = new Setting.Property[]{Setting.Property.NodeScope};
        }
        this.sizeSetting =
            new Setting<>(
                sizeKey,
                s -> Integer.toString(size),
                s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
                properties);
        final String queueSizeKey = settingsKey(prefix, "queue_size");
        this.queueSizeSetting = Setting.intSetting(queueSizeKey, queueSize, properties);
    }
  1. settings：Node的配置settings。设定配置变量 thread_pool.index.size的值为该参数中cpu的数量
  2. name：线程池执行者的名称，也就是idnex。
  3. size：线程的固定大小，和参数name一起构造配置变量thread_pool.index.size的值为size的值，本机跑的结果是4。
  4. queueSize：阻塞队列的大小，构造配置变量thread_pool.index.queue_size的值为200，注意这个值固定为200。
3.1.1.3 批处理操作的Executor (无)

批处理操作的Executor：构建一个固定的Executor构建器。key为bulk，value为FixedExecutorBuilder对象，接收参数和对应操作如下：

  1. settings：Node的配置settings。设定配置变量thread_pool.bulk.size的值为该参数中cpu的数量
  2. name：线程池执行者的名称，也就是bulk。
  3. size：线程的固定大小，和参数name一起构造配置变量thread_pool.bulk.size的值为size的值，本机跑的结果是4。
  4. queueSize：阻塞队列的大小，构造配置变量thread_pool.bulk.queue_size的值为200，注意这个值固定为200。
3.1.1.4 get操作的Executor

get操作的Executor：构建一个固定的Executor构建器。key为get，value为FixedExecutorBuilder对象，接收参数和对应操作如下：

public FixedExecutorBuilder(
        final Settings settings,
        final String name,
        final int size,
        final int queueSize,
        final String prefix,
        final boolean deprecated
    ) {
        super(name);
        final String sizeKey = settingsKey(prefix, "size");
        final Setting.Property[] properties;
        if (deprecated) {
            properties = new Setting.Property[]{Setting.Property.NodeScope, Setting.Property.Deprecated};
        } else {
            properties = new Setting.Property[]{Setting.Property.NodeScope};
        }
        this.sizeSetting =
            new Setting<>(
                sizeKey,
                s -> Integer.toString(size),
                s -> Setting.parseInt(s, 1, applyHardSizeLimit(settings, name), sizeKey),
                properties);
        final String queueSizeKey = settingsKey(prefix, "queue_size");
        this.queueSizeSetting = Setting.intSetting(queueSizeKey, queueSize, properties);
    }
  1. settings：Node的配置settings。设定配置变量thread_pool.get.size的值为该参数中cpu的数量
  2. name：线程池执行者的名称，也就是get。
  3. size：线程的固定大小，和参数name一起构造配置变量thread_pool.get.size的值为size的值，本机跑的结果是4。
  4. queueSize：阻塞队列的大小，构造配置变量thread_pool.get.queue_size的值为1000，注意这个值固定为1000。
3.1.1.5 查询操作的Executor

查询操作的Executor：构建一个根据利特尔法则自动扩展长度的Executor构建器，这个构建器的逻辑与其他构建器不同，也显得比较复杂，也说明了对于查询操作，ElasticSearch做了特殊的优化。key为search，value为AutoQueueAdjustingExecutorBuilder对象，接收参数和对应操作如下：

 builders.put(Names.SEARCH, new AutoQueueAdjustingExecutorBuilder(settings,
                        Names.SEARCH, searchThreadPoolSize(allocatedProcessors), 1000, 1000, 1000, 2000));
  1. settings：Node的配置settings。设定配置变量thread_pool.search.size的值为该参数中cpu的数量
  2. name：线程池执行者的名称，也就是search。
  3. size：线程的固定大小，和参数name一起构造配置变量thread_pool.search.size的值为size的值，本机跑的结果是7。
  4. initialQueueSize:初始化队列的大小，固定设置为1000，造配置变量thread_pool.search.queue_size的值为200
  5. minQueueSize：队列的最小长度，固定设置为1000设定配置变量thread_pool.search.min_queue_size的值为1000
  6. maxQueueSize：队列的最大长度，固定设置为1000，设定配置变量thread_pool.search.max_queue_size的值为1000
  7. frameSize：队列的步进长度，固定设置为2000，构造配置变量thread_pool.search.auto_queue_frame_size的值为200，注意这个值固定为200。
  8. thread_pool.search.target_response_time针对search操作的相应被设置为1S，
3.1.1.6 管理操作的Executor

管理操作的Executor：构建一个可伸缩的Executor构建器。key为management，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.MANAGEMENT, new ScalingExecutorBuilder(Names.MANAGEMENT, 1, 5, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.management.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是management，
size：线程的固定大小，和参数name一起构造配置变量thread_pool.management.size的值为size的值，本机跑的结果是1。
queueSize：阻塞队列的大小，构造配置变量thread_pool.management.queue_size的值为200，注意这个值固定为200。
keepAlive：超过1个线程后，线程保持活跃的时间。这个值固定为5分钟。这个参数被设定为变量thread_pool.management.keep_alive。
3.1.1.7 监听操作的Executor

监听操作的Executor：构建一个固定的Executor构建器。key为listener，value为FixedExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.LISTENER, new FixedExecutorBuilder(settings, Names.LISTENER, halfProcMaxAt10, -1, true));


settings：Node的配置settings。设定配置变量thread_pool.listener.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是listener，
size：线程的固定大小，上文提到的halfProcMaxAt10，和参数name一起构造配置变量thread_pool.listener.size的值为size的值，本机跑的结果是2。
queueSize：阻塞队列的大小，构造配置变量thread_pool.listener.queue_size的值为-1，意思就没有阻塞队列。
3.1.1.8 flush操作的Executor

flush操作的Executor：构建一个可伸缩的Executor构建器。key为flush，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.FLUSH, new ScalingExecutorBuilder(Names.FLUSH, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.flush.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是flush，
size：线程的固定大小，上文提到的halfProcMaxAt5，和参数name一起构造配置变量thread_pool.flush.size的值为size的值，本机跑的结果是4。
keepAlive：超过1个线程后，线程保持活跃的时间。这个值固定为5分钟。这个参数被设定为变量thread_pool.management.keep_alive。
3.1.1.9 refresh操作的Executor

refresh操作的Executor：构建一个可伸缩的Executor构建器。key为refresh，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.REFRESH, new ScalingExecutorBuilder(Names.REFRESH, 1, halfProcMaxAt10, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.refresh.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是refresh，
size：线程的固定大小，上文提到的halfProcMaxAt10，和参数name一起构造配置变量thread_pool.refresh.size的值为size的值，本机跑的结果是4。
keepAlive：超过1个线程后，线程保持活跃的时间。这个值固定为5分钟。这个参数被设定为变量thread_pool.management.keep_alive。
3.1.1.10 warmer操作的Executor

warmer操作的Executor：构建一个可伸缩的Executor构建器。key为warmer，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.WARMER, new ScalingExecutorBuilder(Names.WARMER, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.warmer.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是warmer，
size：线程的固定大小，上文提到的halfProcMaxAt5，和参数name一起构造配置变量thread_pool.warmer.size的值为size的值，本机跑的结果是4。
keepAlive：超过1个线程后，线程保持活跃的时间。这个值固定为5分钟。这个参数被设定为变量thread_pool.management.keep_alive。
3.1.1.11 snapshot操作的Executor

snapshot操作的Executor：构建一个可伸缩的Executor构建器。key为snapshot，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.SNAPSHOT, new ScalingExecutorBuilder(Names.SNAPSHOT, 1, halfProcMaxAt5, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.snapshot.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是snapshot，
size：线程的固定大小，上文提到的halfProcMaxAt5，和参数name一起构造配置变量thread_pool.snapshot.size的值为size的值，本机跑的结果是4。
keepAlive：超过1个线程后，线程保持活跃的时间。这个值固定为5分钟。这个参数被设定为变量thread_pool.management.keep_alive。
3.1.1.12 碎片处理操作的Executor

碎片处理操作的Executor：构建一个可伸缩的Executor构建器。key为fetch_shard_started，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

 builders.put(Names.FETCH_SHARD_STARTED,
                new ScalingExecutorBuilder(Names.FETCH_SHARD_STARTED, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5)));
        

settings：Node的配置settings。设定配置变量thread_pool.fetch_shard_started.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是fetch_shard_started，
size：线程的固定大小，和参数name一起构造配置变量thread_pool.fetch_shard_started.size的值为size的值，本机跑的结果是4。
queueSize：阻塞队列的大小，构造配置变量thread_pool.fetch_shard_started.queue_size的值为200，注意这个值固定为200。
3.1.1.13 强制merge操作的Executor

强制merge操作的Executor：构建一个可伸缩的Executor构建器。key为force_merge，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

        builders.put(Names.FORCE_MERGE, new FixedExecutorBuilder(settings, Names.FORCE_MERGE, 1, -1));


settings：Node的配置settings。设定配置变量thread_pool.force_merge.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是force_merge，
size：线程的固定大小，和参数name一起构造配置变量thread_pool.force_merge.size的值为size的值，本机跑的结果是4。
queueSize：阻塞队列的大小，构造配置变量thread_pool.force_merge.queue_size的值为200，注意这个值固定为200。
3.1.1.14 获取碎片操作的Executor

获取碎片操作的Executor：构建一个可伸缩的Executor构建器。key为fetch_shard_store，value为ScalingExecutorBuilder对象，接收参数和对应操作如下：

builders.put(Names.FETCH_SHARD_STORE,
                new ScalingExecutorBuilder(Names.FETCH_SHARD_STORE, 1, 2 * allocatedProcessors, TimeValue.timeValueMinutes(5)));


settings：Node的配置settings。设定配置变量thread_pool.fetch_shard_store.size的值为该参数中cpu的数量
name：线程池执行者的名称，也就是fetch_shard_store，
size：线程的固定大小，和参数name一起构造配置变量thread_pool.fetch_shard_store.size的值为size的值，本机跑的结果是4。
queueSize：阻塞队列的大小，构造配置变量thread_pool.fetch_shard_store.queue_size的值为200，注意这个值固定为200。

至此就完成了org.elasticsearch.threadpool.ThreadPool对象的创建。

3.2 ThreadPool对象的作用

得到ThreadPool的对象后，通过线程池进行了NodeClient的构建。

client = new NodeClient(settings, threadPool);

和ResourceWatcherService对象的构建，

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

后面还有很多的组件都用到了线程池，比如：

IngestService
ClusterInfoService
MonitorService
ActionModule
IndicesService
NetworkModule
TransportService
DiscoveryModule
NodeService

可以看出都是ElasticSearch的核心组件，这些组件的功能和原理，我都会在以后的文章中讲解，而像ElasticSearch这种存储搜索系统来说IO操作肯定非常频繁，而线程池是专门致力于解决系统的IO问题，它在这些服务组件中的作用也显得愈发重要。

4.利特尔法则

查询操作中提到的利特尔法则是一种描述稳定系统中，三个变量之间关系的法则。
在这里插入图片描述

其中L表示平均请求数量，λ表示请求的频率，W表示响应请求的平均时间。举例来说，如果每秒请求数为10次，每个请求处理时间为1秒，那么在任何时刻都有10个请求正在被处理。回到我们的话题，就是需要使用10个线程来进行处理。如果单个请求的处理时间翻倍，那么处理的线程数也要翻倍，变成20个。

理解了处理时间对于请求处理效率的影响之后，我们会发现，通常理论上限可能不是线程池大小的最佳值。线程池上限还需要参考任务处理时间。

假设JVM可以并行处理1000个任务，如果每个请求处理时间不超过30秒，那么在最坏情况下，每秒最多只能处理33.3个请求。然而，如果每个请求只需要500毫秒，那么应用程序每秒可以处理2000个请求。

M.扩展

Elasticsearch 线程池和队列问题

九师兄
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
订阅专栏
java线程池封装
05-24
java线程池封装，可自定义线程优先级，使用方便。。。
ElasticSearch--线程池(ThreadPool)--使用/设置
IT利刃出鞘的博客
09-14 3886
​ 本文介绍ElasticSearch的线程池的配置。 ES每个node都有多个线程池来管理内存占用，线程池都有一个queue来缓存需要处理的request而不是直接丢弃。 ES的线程池有点儿类似于Java中的线程池。...
深入Elasticsearch：线程池的原理与应用
码到三十五
02-07 953
在Elasticsearch中，线程池是用于管理线程资源和控制并发度的关键组件。它通过将不同类型的操作映射到不同的线程池中，实现了资源的隔离和优化。Elasticsearch的线程池设计考虑了不同类型的操作对CPU、IO和内存等资源的需求，以及操作的优先级和并发度。Elasticsearch的线程池设计是其高性能和可扩展性的基石之一。通过合理地配置和优化线程池，可以确保Elasticsearch在各种工作负载下都能提供稳定、高效的搜索和分析服务。
线程池工具类封装（高级版）
qq_42889280的博客
04-06 6430
原文地址：https://blog.xaoxu.cn/archives/thread-pool-tool-package 为什么需要一个线程池工具类？ 整个项目，用到线程执行任务的地方很多，不可能哪里用到就在那里直接 new 一个线程执行，这样资源得不到重复利用，一旦线程过多就会导致内存不足。 线程池的好处是什么？ 使用线程池执行线程任务，当一个线程执行完成一个任务之后，线程资源回到线程池，资源得到重复利用。 线程池为什么使用自定义方式？ 因为 java 自带线程池都会有可能造成内存不足的问题。自定义线程池
线程池的封装和使用
Bu_siliang的博客
04-09 933
开发中你是否在用线程的时候一味的在new，这是很明显的弊端使用，项目中会有太多的地方需要线程，当你new了无数个线程时： 1.每次new Thread新建对象性能差 线程缺乏统一管理，可能无限制新建线程，相互之间竞争，即可能占用过多的系统资源导致死机（OOM） 3.缺乏更多功能，比如定时执行，定期执行，线程中断 二：## 线程池 ThreadPoolExecutor 在 Java中 线程池的顶级...
Elasticsearch常用配置及性能参数
大JAVA解决方案
06-19 1933
Elasticsearch常用配置及性能参数 cluster.name: estest 集群名称 node.name: “testanya” 节点名称 node.master: false 是否主节点 node.data: true 是否存储数据 index.store.type: niofs 读写文件方式 index.cache.field.type: soft 缓存类型 bootstrap.mlockall: true 禁用swap gateway.type: local 本地存储...
elasticsearch 5.x 系列之二 线程池的设置
weixin_30613727的博客
07-24 219
1，概述 每个Elasticsearch节点内部都维护着多个线程池，如index、search、get、bulk等，用户可以修改线程池的类型和大小，以及其他的比如reflesh, flush,warmer 等， 我们一般需要关注的只是： index,search，get,bulk 就ok了，其他的可以用到的时候再具体进行查看。 2，查看线程组的状态 curl -XGET http://master...
基于.netcore搜索封装ElasticSearch.zip
06-09
。netcore内的es搜索封装
基于SpringBoot的Elasticsearch客户端调用封装工具设计源码
最新发布
03-29
EsClientRHL是一个可基于springboot的elasticsearch客户端调用封装工具，通过elasticsearch官网推荐的RestHighLevelClient实现，内置了es索引结构工具、es索引数据增删改工具、es查询工具、es数据分析工具或者es。...
ElasticSearch连接池全套封装
12-28
ElasticSearch连接池全套封装
基于elasticsearch的CRUD简单封装java版
06-23
简化elasticsearch API的使用方式 使用示例 ApplicationContext context = new AnnotationConfigApplicationContext(TestConfiguration.class); ESBasicService service = context.getBean(ESBasicService.class);...
es docker 部署 elasticsearch.yml
03-19
docker run --name elasticsearch7.16.3 -p 127.0.0.1:9200:9200 -p 127.0.0.1:9300:9300 -e "discovery.type=single-node" -v /Users/xingyue/Home/xingyue/学习/工程化/es/elasticsearch.yml:/usr/share/elastic...
《Elasticsearch 源码解析与优化实战》第16章：ThreadPool模块分析
chbxw
09-30 1329
文章目录一、简介二、线程池类型2.1、fixed2.2、scaling2.3、direct2.4、fixed_auto_queue_size三、处理器设置四、查看线程池4.1、cat thread pool4.2、nodes info4.3、nodes stats4.4、nodes hot threads4.5、Java 的线程池结构五、ES的线程池实现5.1、ThreadPool 类结构与初始化5.2、fixed类型线程池构建过程5.3、scaling类型线程池构建过程5.4、direct类型线程池构建过
es7.3的性能参数调优
woturanshihuaidexiao的博客
12-09 2589
1、es集群的索引分片设计不合理，导致分片数很多，监控压力也增大，严重影响到了es集群的稳定性。只能临时关闭监控索引，或者调整监控频率 1）关闭监控 PUT /_cluster/settings?pretty { "persistent": { "xpack.monitoring.collection.enabled": false } } 2）监控频率调整 动态参数 调整es的监控频率 PUT /_cluster/settings { "persistent" : { "xpack.monitor
（十一）elasticsearch集群及读写调优
weixin_43930865的博客
03-31 979
elasticsearch调优 1：系统调优 1：内存调优 ES 安装后默认设置的堆内存是 1GB。如果内存相对很大，如 64G 及以上，那么我建议 ES 内存可以设置为 31G-32G（es分配总内存不超过总内存的一半）。如果内存很大可以通过多实例模式提高利用率，比如我们256G通常会部署3个实例 设置 ES 集群内存的时候，还有一点就是确保堆内存最小值（Xms）与最大值（Xmx）的大小是相同的，防止程序在运行时改变堆内存大小，这是一个很耗系统资源的过程。 还有一点就是避免swap交换内存，可以在配置文件
07.es_thread_pool使用
寒夜
10-26 4395
文章目录1. 线程池的类型1. fixed2. fixed_auto_queue_size3. scaling 类型线程池2.相对重要的线程池1. generic线程池2. search线程池3. search_throttled线程池4. get线程池5. analyze线程池6. write线程池7. snapshot线程池8. warmer线程池9. refresh线程池10. listener线程池3. 修改某个线程池的设置4. Processors setting 在es这种的每个node都会有多
ES线程池设置
大叶子不小的博客
08-31 1724
每个节点都会创建一系列的线程池来执行任务，许多线程池都有与其相关任务队列，用来允许挂起请求，而不是丢弃它。下面列出目前ES版本中的线程池。generic：用于通用的操作(例如，节点发现)，线程池类型为 scaling。index：用于index/delete操作，线程池类型为fixed，大小为处理器的数量，队列大小为200，允许设置的最大线程数为1+处理器数量。search：用于count/search/suggest操作。
es7.3生产环境问题排查解决
woturanshihuaidexiao的博客
03-13 1665
1、 es集群打开分片数不足 （1）错误描述： Validation Failed: 1: this action would add [5] total shards, but this cluster currently has [998]/[1000] maximum shards open; （2）解决方法：通过API设置集群分片数量，永久设置 PUT /_cluster/settin...
Elasticsearch 线程池配置
05-13
Elasticsearch 是一个分布式搜索引擎，它有多个线程池用于处理不同的任务。可以通过配置线程池来优化 Elasticsearch 的性能。 以下是 Elasticsearch 中常用的线程池及其默认配置： 1. 线程池类型：Index 线程池 默认线程数：CPU 核心数 * 2 作用：处理索引请求 2. 线程池类型：Search 线程池 默认线程数：CPU 核心数 * 2 作用：处理搜索请求 3. 线程池类型：Bulk 线程池 默认线程数：CPU 核心数 * 2 作用：处理批量请求 4. 线程池类型：Get 线程池 默认线程数：CPU 核心数 * 2 作用：处理 GET 请求 5. 线程池类型：Snapshot 线程池 默认线程数：CPU 核心数 * 1 作用：处理快照备份请求 可以通过 Elasticsearch 的配置文件 elasticsearch.yml 来调整线程池的大小。下面是一个示例： ``` thread_pool: index: size: 20 search: size: 30 bulk: size: 10 get: size: 5 snapshot: size: 2 ``` 在上面的示例中，我们将 Index 线程池的大小设置为 20，Search 线程池的大小设置为 30，Bulk 线程池的大小设置为 10，Get 线程池的大小设置为 5，Snapshot 线程池的大小设置为 2。 需要注意的是，线程池的大小应该根据服务器的 CPU 核心数来调整，以充分利用服务器资源。同时，线程池大小也应该根据 Elasticsearch 的使用情况来调整，以避免出现资源浪费或性能瓶颈等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值