Elasticsearch-BulkProcessor浅析

批量插入千万数据到Elasticsearch之bulkProcessor 2.遇到的问题连接超时和io问题,这是因为发起的线程太多了上面我设置了10个线程,一个线程5000的数据,.setBulkActions(5000) .setConcurrentRequests(10) 因为线程太多导致有一个线程不成功的话就会导致缺少数据,后面解决把.setBulkActions(2000) .setConcurrentRequests(1)就成功导入1000万数据成功了。关闭,加在flush的后面一行。 阅读详情

Elasticsearch-BulkProcessor浅析

1 概述

可参考Elasticsearch Bulk Processor

BulkProcessor提供了一个简单的接口来实现批量提交请求(多种请求,如IndexRequest,DeleteRequest),且可根据请求数量、大小或固定频率进行flush提交。flush方式可选同步或异步。以下是一个官方例子

import org.elasticsearch.action.bulk.BackoffPolicy;
import org.elasticsearch.action.bulk.BulkProcessor;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.common.unit.TimeValue;

// create a bulkProcessor
BulkProcessor bulkProcessor = BulkProcessor.builder(
        client,  
        new BulkProcessor.Listener() {
            @Override
            public void beforeBulk(long executionId,
                                   BulkRequest request) { 	
                                   request.numberOfActions() } 

            @Override
            public void afterBulk(long executionId,
                                  BulkRequest request,
                                  BulkResponse response) {
                                  response.hasFailures() } 

            @Override
            public void afterBulk(long executionId,
                                  BulkRequest request,
                                  Throwable failure) { 
                                  failure.getMessage() } 
        })
        // 每10000个request flush一次
        .setBulkActions(10000) 
        // bulk数据每达到5MB flush一次
        .setBulkSize(new ByteSizeValue(5, ByteSizeUnit.MB)) 
        // 每5秒flush一次
        .setFlushInterval(TimeValue.timeValueSeconds(5)) 
        // 0代表同步提交即只能提交一个request;
        // 1代表当有一个新的bulk正在累积时,1个并发请求可被允许执行
        .setConcurrentRequests(1) 
        // 设置当出现代表ES集群拥有很少的可用资源来处理request时抛出
        // EsRejectedExecutionException造成N个bulk内request失败时
        // 进行重试的策略,初始等待100ms,后面指数级增加,总共重试3次.
        // 不重试设为BackoffPolicy.noBackoff()
        .setBackoffPolicy(
            BackoffPolicy.exponentialBackoff(TimeValue.timeValueMillis(100), 3)) 
        .build();

// add a IndexRequest to bulkprocessor
bulkProcessor.add(new IndexRequest("twitter", "_doc", "1").source(/* your doc here */));
// add a DeleteRequest to bulkprocessor
bulkProcessor.add(new DeleteRequest("twitter", "_doc", "2"));

// await close the bulkprocessor
bulkProcessor.awaitClose(10, TimeUnit.MINUTES);

2 源码

2.1 创建BulkProcessor

就是上述例子中的build()方法,创建时用了builder模式。

BulkProcessor.builder(client,listener)

其中client为TransportClient实例,listener bulk各事件监听器。

使用各种.setxxx方法设置属性,最后使用.build()方法创建一个BulkProcessor实例:

BulkProcessor(Client client, BackoffPolicy backoffPolicy, Listener listener, @Nullable String name, int concurrentRequests, int bulkActions, ByteSizeValue bulkSize, @Nullable TimeValue flushInterval) {
        this.bulkActions = bulkActions;
        this.bulkSize = bulkSize.bytes();

        this.bulkRequest = new BulkRequest();
        // 根据concurrentRequests值不同设置同步或异步Handler
        this.bulkRequestHandler = (concurrentRequests == 0) ? BulkRequestHandler.syncHandler(client, backoffPolicy, listener) : BulkRequestHandler.asyncHandler(client, backoffPolicy, listener, concurrentRequests);
		
        if (flushInterval != null) {
        // 设置了flushInterval,就会开启一个定时执行的线程池
            this.scheduler = (ScheduledThreadPoolExecutor) Executors.newScheduledThreadPool(1, EsExecutors.daemonThreadFactory(client.settings(), (name != null ? "[" + name + "]" : "") + "bulk_processor"));
            this.scheduler.setExecuteExistingDelayedTasksAfterShutdownPolicy(false);
            this.scheduler.setContinueExistingPeriodicTasksAfterShutdownPolicy(false);
            // 按配置的flush定时提交bulk
            this.scheduledFuture = this.scheduler.scheduleWithFixedDelay(new Flush(), flushInterval.millis(), flushInterval.millis(), TimeUnit.MILLISECONDS);
        } else {
            this.scheduler = null;
            this.scheduledFuture = null;
        }
    }

2.2 Flush

在上述BulkProcessor的最后就启动了Flush定时任务,下面看看Flush任务具体是做什么:

class Flush implements Runnable {
        @Override
        public void run() {
            synchronized (BulkProcessor.this) {
                if (closed) {
                // 如果已经close,什么都不做
                    return;
                }
                if (bulkRequest.numberOfActions() == 0) {
                // 无数据,什么都不做
                    return;
                }
                //否则执行bulk提交
                execute();
            }
        }
    }

2.3 execute

Flush定时任务会调用execute方法提交bulk。

2.3.1 SyncBulkRequestHandler

同步的SyncBulkRequestHandler的execute方法如下:

public void execute(BulkRequest bulkRequest, long executionId) {
    boolean afterCalled = false;
    try {
        // 调用注册的listener的beforeBulk方法
        listener.beforeBulk(executionId, bulkRequest);
        // 根据重试策略同步的写入数据到ES
        BulkResponse bulkResponse = Retry
                .on(EsRejectedExecutionException.class)
                .policy(backoffPolicy)
                .withSyncBackoff(client, bulkRequest);
        afterCalled = true;
        // 调用注册的listener的afterBulk方法
        listener.afterBulk(executionId, bulkRequest, bulkResponse);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        if (!afterCalled) {
            //出错时调用afterBulk
            listener.afterBulk(executionId, bulkRequest, e);
        }
    } catch (Throwable t) {
        logger.warn("Failed to execute bulk request {}.", t, executionId);
        if (!afterCalled) {
            listener.afterBulk(executionId, bulkRequest, t);
        }
    }
}
2.3.2 AsyncBulkRequestHandler

该类的bulk提交是异步的。

  • 构造方法
    private AsyncBulkRequestHandler(Client client, BackoffPolicy backoffPolicy, BulkProcessor.Listener listener, int concurrentRequests) {
        super(client);
        this.backoffPolicy = backoffPolicy;
        assert concurrentRequests > 0;
        this.listener = listener;
        // 这里就是setConcurrentRequests的值
        this.concurrentRequests = concurrentRequests;
        // 这里创建了concurrentRequests个Semaphore许可
        this.semaphore = new Semaphore(concurrentRequests);
    }
    
  • execute方法如下:
    public void execute(final BulkRequest bulkRequest, final long executionId) {
        boolean bulkRequestSetupSuccessful = false;
        boolean acquired = false;
        try {
            listener.beforeBulk(executionId, bulkRequest);
            //申请许可,无许可时阻塞
            semaphore.acquire();
            acquired = true;
            Retry.on(EsRejectedExecutionException.class)
                    .policy(backoffPolicy)
                    // 异步方式提交bulk
                    .withAsyncBackoff(client, bulkRequest, new ActionListener<BulkResponse>() {
                        @Override
                        // es响应后调用此方法
                        public void onResponse(BulkResponse response) {
                            try {
                                listener.afterBulk(executionId, bulkRequest, response);
                            } finally {
                            	// 该bulk提交完了,才会释放许可
                                semaphore.release();
                            }
                        }
    
                        @Override
                        public void onFailure(Throwable e) {
                            try {
                                listener.afterBulk(executionId, bulkRequest, e);
                            } finally {
                            	// 该bulk提交完失败了,也会释放许可
                                semaphore.release();
                            }
                        }
                    });
            // 异步提交成功        
            bulkRequestSetupSuccessful = true;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            logger.info("Bulk request {} has been cancelled.", e, executionId);
            listener.afterBulk(executionId, bulkRequest, e);
        } catch (Throwable t) {
            logger.warn("Failed to execute bulk request {}.", t, executionId);
            listener.afterBulk(executionId, bulkRequest, t);
        } finally {
            if (!bulkRequestSetupSuccessful && acquired) {  
            // if we fail on client.bulk() release the semaphore
            // 即异步提交过程就失败了,也会释放许可
                semaphore.release();
            }
        }
    }
    

2.4 add

下面看看bulkProcessor.add(IndexRequest)方法,实际执行的是以下方法

// 注意该方法拥有全局对象锁
private synchronized void internalAdd(ActionRequest request, @Nullable Object payload) {
	// 确保没有close
    ensureOpen();
    // bulkRequest内部有一个ActionRequestList,会将request放入
    // 然后增加累积的size(每个request的source及50字节的head)
    bulkRequest.add(request, payload);
    // 该方法会判断当前request条数或字节数超过阈值则会执行execute方法
    // 需要注意的是这个execute方法还是需要申请许可,跟flush那个execute是同一个
    // 否则什么都不做
    executeIfNeeded();
}

3 补充 ES6改动

3.1 概述

ES6对BulkProcessor做了改动,这里主要分析下execute方法。

3.2 BulkProcessor.execute

// 当前需要在获取锁的情况下才能执行
private void execute() {
	// 获取当前的BulkRequest
    final BulkRequest bulkRequest = this.bulkRequest;
    final long executionId = executionIdGen.incrementAndGet();

	// 创建一个新的BulkRequest
    this.bulkRequest = new BulkRequest();
    // 用老的BulkRequest去执行
    this.bulkRequestHandler.execute(bulkRequest, executionId);
}

注意,该execute的几个调用位置都是使用BulkProcessor实例的对象级别synchronized锁定来保证线程安全的。

3.3 BulkRequestHandler构造方法

ES6中不再分同步异步的BulkRequestHandler,而是仅有一个:

public final class BulkRequestHandler {
    private final Logger logger;
    private final BiConsumer<BulkRequest, ActionListener<BulkResponse>> consumer;
    private final BulkProcessor.Listener listener;
    private final Semaphore semaphore;
    private final Retry retry;
    private final int concurrentRequests;

    BulkRequestHandler(BiConsumer<BulkRequest, ActionListener<BulkResponse>> consumer, BackoffPolicy backoffPolicy,
                       BulkProcessor.Listener listener, Scheduler scheduler, int concurrentRequests) {
        assert concurrentRequests >= 0;
        this.logger = Loggers.getLogger(getClass());
        // (bulkRequest, bulkListener) -> client.bulkAsync(bulkRequest, RequestOptions.DEFAULT, bulkListener)
        // 即带listener异步方式执行bulkRequest
        this.consumer = consumer;
        // 这就是我们设置的bulkProcessorListener
        this.listener = listener;
        // 这里就是setConcurrentRequests的值
        this.concurrentRequests = concurrentRequests;
        // 重试策略
        // es6中,默认为初始等待时间为50 ms,重试8次,总共耗时约5.1秒的策略。
        this.retry = new Retry(backoffPolicy, scheduler);
        // 创建concurrentRequests个Semaphore许可,默认为1个
        this.semaphore = new Semaphore(concurrentRequests > 0 ? concurrentRequests : 1);
    }
}

3.4 BulkRequestHandler.execute

public void execute(BulkRequest bulkRequest, long executionId) {
    Runnable toRelease = () -> {};
    boolean bulkRequestSetupSuccessful = false;
    try {
    	// 调用注册的listener的beforeBulk方法
        listener.beforeBulk(executionId, bulkRequest);
        //申请许可,无许可时阻塞
        semaphore.acquire();
        // toRelease的run方法执行这个许可的release操作
        toRelease = semaphore::release;
        // 初始化一个latch
        CountDownLatch latch = new CountDownLatch(1);
        retry.withBackoff(consumer, bulkRequest, new ActionListener<BulkResponse>() {
            @Override
            public void onResponse(BulkResponse response) {
                try {
                    listener.afterBulk(executionId, bulkRequest, response);
                } finally {
                    // 该bulk提交,获得成功响应,才会释放许可和latch
                    semaphore.release();
                    latch.countDown();
                }
            }

            @Override
            public void onFailure(Exception e) {
                try {
                    listener.afterBulk(executionId, bulkRequest, e);
                } finally {
                    // 该bulk提交失败,也会释放许可和latch
                    semaphore.release();
                    latch.countDown();
                }
            }
        }, Settings.EMPTY);
        // 异步提交成功
        bulkRequestSetupSuccessful = true;
        if (concurrentRequests == 0) {
        	// 并发设为0时,必须等待该次提交bulk结果,无论结果成功与否
            latch.await();
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        logger.info(() -> new ParameterizedMessage("Bulk request {} has been cancelled.", executionId), e);
        listener.afterBulk(executionId, bulkRequest, e);
    } catch (Exception e) {
        logger.warn(() -> new ParameterizedMessage("Failed to execute bulk request {}.", executionId), e);
        listener.afterBulk(executionId, bulkRequest, e);
    } finally {
        if (bulkRequestSetupSuccessful == false) {  // if we fail on client.bulk() release the semaphore
            // 即异步提交过程就失败了,也会释放许可
            toRelease.run();
        }
    }
}

也就是说,每次execute时,是异步的,正常情况下(直接抛错时会释放许可)方法返回时是不会释放许可的,这就控制了并发数。只有当异步请求返回调用了ActionListener时才会释放许可。

这里说execute必须在有锁条件下调用,是因为该方法内用到的一些对象并非线程安全。这里应该也是未来一个优化点。

3.5 retry.withBackoff

这个方法实际是调用我们之前定义的

BiConsumer<BulkRequest, ActionListener<BulkResponse>> bulkConsumer =
                (bulkRequest, bulkListener) -> client.bulkAsync(bulkRequest, RequestOptions.DEFAULT, bulkListener)

即:

//这里的this指 RetryHandler implements ActionListener<BulkResponse>
consumer.accept(bulkRequest, this)

接下去就会使用底层的CloseableHttpAsyncClient执行了,可立即返回,不再继续分析。

4 总结

4.1 关于并发控制

从以上代码可以看到,setConcurrentRequests这个值在异步bulk场景中是很关键的。

  • 比如setConcurrentRequests=2,且在某个较大bulk请求提交后,真实响应未在flush时间内返回,那么当flush间隔到了后第二个bulk请求也能申请到许可并提交bulk。

    或在数据量很大,很快达到action/size阈值触发提交时,也需要高并行度来提高效率。

  • 如果设置setConcurrentRequests=0,则是完全同步的bulk提交,每次提交需要等待上一次bulk提交任务完成后再等待flush时间才能继续下一次bulk提交。虽然此时semaphore许可数为1,但是需要做latch.await(),而latch.countDown()必须在异步请求回调listener后才会触发。

4.2 性能

4.2.1 BulkProcessor.add

当我们将各种request放入BulkProcessor时,始终会调用如下方法:

private synchronized void internalAdd(DocWriteRequest request, @Nullable Object payload) {
    ensureOpen();
    bulkRequest.add(request, payload);
    executeIfNeeded();
}

这里有一个BulkProcessor实例的对象级别同步锁。也就是说,当我们在高并发场景,所有请求要放入Bulk都会去竞争等待对象锁。

4.2.2 BulkRequestHandler.execute

该方法必须在拥有BulkRequestHandler实例的对象级别同步锁的情况下调用,跟上述一样,高并发场景下会竞争激烈。虽然名义上使用semaphore发放多个许可,但前提是后一个调用必须等待前一个调用走完全部execute异步方法流程。

4.2.3 小结

这些点都要引起注意,在实际使用场景中需要集合实际情况来决定如何使用BulkProcessor。

我们现在是每个index写入就共用一个RestHighLevelClient,以及一个BulkProcessor实例。在调优时就发现,机器负载都还没打满,但性能就一直上不去了。据我分析应该有上述两点同步锁竞争原因。我会尝试将BulkProcessor改为该index的每个写入线程创建一个,并且统一加大并发进行调试。待有结果后上来补充。

批处理 :从ElasticSearch看批处理的性能优势 主要是借着 ES 的优化好好思考了一下批处理带来的好处。IO 和 网络消耗CPU 损耗及上下文切换磁盘损耗和顺序IO原子处理及内存复用,共享了内存,减少了重复操作例如一次事务和多次事务带来的性能差距,对资源的锁定范围等额外的并发消耗,这涉及到多线程情况下的切换,也属于上下文切换,但是和CPU的那个维度不同重复的刷新操作,这种就是代码维度的节省了这一篇主要的目的是说清楚批处理的好处 ,然后在高性能的系统中,要养成批处理的思维。 阅读详情

相关推荐

操作es_ES 操作之批量写-BulkProcessor 原理浅析

BulkProcessor创建流程内部逻辑实现最近对线上业务进行重构,涉及到ES同步这一块,在重构过程中,为了ES 写入 性能考虑,大量的采取了 bulk的方式,来保证整体的一个同步速率,针对BulkProcessor 来深入一下,了解下 是如何实现,基于请求数,请求数据量大小 和 固定时间,刷新写入ES 的原理 针对ES 批量写入, 提供了3种方式,在 high-rest-client 中 分...

weixin_35353285的博客 2267

ElasticSearch 7.x 版本使用 BulkProcessor 实现批量添加数据

BulkProcessor是 ElasticSearch 客户端中的一个功能,用于批量执行索引、更新或删除操作,BulkProcessor 运行将多个操作打包成一个请求进行发送,以提高效率和性能。 性能优势:将多个操作打包成一个请求,这样可以减少网络开销,提高数据传输效率,从而可以加快数据写入索引速度。 减少开销:较少的网络开销和较少的服务器的交互,减少服务器开销,尤其是大规模写入数据时。 原子性:批量操作可以保证一组操作要么全部成功,要么全部失败,报错数据的一致性。

qq_19283249的博客 4140

Java使用BulkProcessor批量写elasticsearch

pre 业务需求,探索的时候踩了坑,记录下来以备查阅,工作之余时间不多,简单记录问题和解决方案,后续有精力再补全 background bulk是es的批量写的命令,bulkprocessor是官方对于bulk操作的进一步封装,可以控制单次批处理的数据量,以防单次数据量过多引起的连接错误 踩过的坑 找不到bulkprocessor 在网上找不到类所在的jar包,后续确认通过maven管理依赖,添...

月光轩辕的专栏 3435

ES 客户端BulkProcessor代码解析-代码设计是什么?

优秀的代码设计是的产品高效、健壮和强扩展性。核心和变动点分开简洁而不简单的使用方式, 大家可以思考一下设计流行的做减法代表着什么?深入灵活的结构抽象。

dreamsofa的专栏 660

ES的BulkProcessor实现批量写入

这是读取的文件 0,联想(Lenovo)拯救者Y7000P英特尔酷睿i7 15.6英寸游戏笔记本电脑(8核i7-10875H 16G 512G RTX2060 144Hz)灰,https://item.jd.com/100013950500.html,7299.0,联想京东自营旗舰店,200000,电脑,1000 0,联想ThinkPad E15 2021款 酷睿版 英特尔酷睿i5/i7 轻薄笔记本电脑 人脸识别 i5-1135G7 16G 512G 1SCD,https://item.jd.com/100

qq_43662627的博客 1626

批量插入千万数据到Elasticsearch之bulkProcessor_bulkprocessor使用

System.out.println(“操作” + request.numberOfActions() + “条数据”);

2401_84615813的博客 800

Elasticsearch-BulkRequest和BulkProcessor简述

BulkRequest和BulkProcessor都可以用来批量处理请求,但二者的使用流程和设计理念有所不同 BulkRequest 主要使用流程 RestHighLevelClient restHighLevelClient = new RestHighLevelClient();//创建一个es客户端,用于执行请求 BulkRequest bulkRequest = new BulkRequest(); //创建一个批量请求 IndexRequest indexRequest1 = new Inde

qq_17690301的博客 9626

批量插入千万数据到Elasticsearch之bulkProcessor_bulkprocessor使用(1)

System.out.println(“操作” + request.numberOfActions() + “条数据”);

2401_84615650的博客 528

es异步写入java_ES 操作之批量写-BulkProcessor 原理浅析

最近对线上业务进行重构,涉及到ES同步这一块,在重构过程中,为了ES 写入 性能考虑,大量的采取了 bulk的方式,来保证整体的一个同步速率,针对BulkProcessor 来深入一下,了解下 是如何实现,基于请求数,请求数据量大小 和 固定时间,刷新写入ES 的原理针对ES 批量写入, 提供了3种方式,在 high-rest-client 中分别是 bulk bulkAsync bulkPro...

weixin_33556941的博客 4966

Docker Desktop 在 Windows 上的安装和使用

WSL 指 “”,这是一个在 Windows 10\11 上能够运行原生 Linux 二进制可执行文件(ELF格式)的兼容层。它是由微软与Canonical公司合作开发的,旨在使纯正的Ubuntu、Debian等映像能下载和解压到用户的本地计算机,并且映像内的工具和实用工具能在此子系统上原生运行。这极大地拓展了Windows系统的功能,使用户能够在Windows环境中享受到Linux的强大功能。//Linux容器。

swadian2008的博客 6万+

Rockchip平台Android相机HAL3开发实战:从配置到调试全流程解析

本文深入解析了Rockchip平台Android相机HAL3的开发全流程。从理解AAL与PSL核心架构、解析关键配置文件(如camera3_profiles.xml和Tuning文件),到搭建编译环境、进行增量部署,并提供了系统日志分析、V4L2调试等高级问题排查技巧,为开发者提供了一套从配置到调试的实战指南。

docker7nomad的博客 847

es bulk java_ES 操作之批量写-BulkProcessor 原理浅析

最近对线上业务进行重构,涉及到ES同步这一块,在重构过程中,为了ES 写入 性能考虑,大量的采取了 bulk的方式,来保证整体的一个同步速率,针对BulkProcessor 来深入一下,了解下 是如何实现,基于请求数,请求数据量大小 和 固定时间,刷新写入ES 的原理针对ES 批量写入, 提供了3种方式,在 high-rest-client 中分别是 bulk bulkAsync bulkPro...

weixin_42299244的博客 2521

WorkBuddy 实战:规则、记忆与 Skill 配置全攻略

AI工作台正成为连接大模型与真实业务的桥梁,其核心价值在于将零散AI能力封装为可复用的工作流。WorkBuddy作为典型智能体入口,通过自定义规则、跨对话记忆与Skill扩展,解决AI“失忆”和“不懂行话”等痛点。从概念到实践,掌握安装避坑、缓存目录调整、知识库挂载等基础操作后,用户可在客服话术生成、文献综述、重复任务自动执行等场景中显著提升效率。本文结合Docker私有化部署与安全审核要点,系统拆解WorkBuddy从入门到进阶的完整路径,帮助团队将AI工具沉淀为可维护的流程资产。

weixin_29053073的博客 455

Elasticsearch-BulkProcessor-死锁分析

Elasticsearch-BulkProcessor-死锁分析 摘要 本文基于ES 6.4.3。主要分析由于在使用BulkProcessor向ES集群提交数据而集群响应异常时,导致的BulkProcessor死锁,而无法继续向BulkProcessor提交新数据,导致整个处理流程卡死的问题。 关于BulkProcessor原理可参考Elasticsearch-BulkProcessor浅析 关于Java线程状态原理可参考Java-多线程-线程状态 1 问题概述 我们程序流程是: 从Kafka消费数据

迷路剑客个人博客 4106

高通平台蓝牙学习-- 基于WCN6750 Bluetooth 5.2的讲解

摘要:蓝牙5.2解决方案WCN6750具备多项先进特性:完全兼容5.2标准及ANT+协议,支持2Mbps高速BLE和长距离传输;采用射频集成方案,与WLAN共享天线并支持5G并发;内置功率放大器,支持Class1/2传输;提供双音频流和Slimbus接口优化。其HCI UART接口支持3.2Mbps速率,通过BlueZ协议栈实现蓝牙5.2功能,包括2Mbps模式和长距离传输,符合核心规范要求。(149字)

专业开发者的博客,一个从事Android WiFi和蓝牙的工程师 3万+

AD9361功能介绍和使用

AD9361使用分数分频锁相环(PLL)来产生发射机和接收机本地振荡器(LO)频率和BB PLL。BB PLL 可用于数据转换、数字滤波器和 |/O 端口。PLL的参考时钟可以由外部振荡器或外部晶体(XO)和数字可编程片内可变电容提供,电容微调产生参考时钟频率,XO和微调电容的组合统称为DCXO。有多个天线输入的分集系统。接收链数据首先经过低噪声放大器(LNA),然后是同相(1)和正交(Q)放大器,混频器和频带整形滤波器,可将接收到的信号下变频为基带以进行数字化。时分双工(TDD)和频分双工(FDD)。。。

wangjie36的博客 1万+

使用BulkProcessor批量插入ES

话不多少,贴上代码 类实现2个接口 implements Flushable, Closeable private BulkProcessor bulkProcessor; /** * 初始化静态配置 */ @PostConstruct public void init() { bulkProcessor = BulkProcessor.builder(client, new BulkProcessor.Listener() {

zhao19191919的博客 4664

如何在 FPGA 中做数学运算

FPGA 非常适合进行数学运算,但是需要一点技巧,所以我们今天就看看如何在 FPGA 中进行简单和复杂的数学运算。介绍由于FPGA可以对算法进行并行化,所以FPGA 非常适合在可编程逻辑中实现数学运算。我们可以在 FPGA 中使用数学来实现信号处理、仪器仪表、图像处理和控制算法等一系列应用。这意味着 FPGA 可用于从自动驾驶汽车图像处理到雷达和飞机飞行控制系统的一系列应用。因为 FPGA 寄存器...

OpenFPGA的博客 2921

Elasticsearch BulkProcessor 的具体实现

每一个成功人士的背后,必定曾经做出过勇敢而又孤独的决定。放弃不难,但坚持很酷~Elasticsearch 使用 BulkProcessor 将 Bulk API 进一步封装,大大简化了对...

CREATE_17的博客 1496

AIGC游戏测试自动化:AI如何提升游戏QA效率

随着游戏产业的蓬勃发展,游戏的复杂度和规模不断增加,传统的游戏测试方式面临着巨大的挑战。本文章的目的在于深入探讨AIGC技术在游戏测试自动化中的应用,分析AI如何提升游戏QA的效率。范围涵盖了从核心概念到实际应用的各个方面,包括算法原理、数学模型、项目实战案例以及未来发展趋势等。本文将按照以下结构进行阐述:首先介绍核心概念与联系,明确AIGC和游戏测试自动化的相关概念和关系;接着讲解核心算法原理和具体操作步骤,通过Python代码进行详细说明;然后介绍数学模型和公式,并举例说明;

AI 原生应用开发的博客 1363

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

【ES】springboot使用bulkProcessor定时用quartz同步mysql数据到es中(基本引用即用)

一、项目中添加一个工具类就可以了 配置类不用改,需要改的地方就是业务需求的地方 每两分钟同步一次,加了个定时任务 自已已应用到测试环境,是能正常运行的 package com.example.gauditdemo.config; import org.apache.http.HttpHost; import org.elasticsearch.client.RestClient; import org.elasticsearch.client.RestHighLevelC.

yuxiangdeming的博客 3581

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Java 中间件:Elasticsearch 批量操作(BulkProcessor 优化性能)

通过本文,我们深入探讨了 Elasticsearch 批量操作的核心工具——(即新版本的 BulkProcessor)。它不仅是性能优化的关键,更是构建健壮数据管道的基石。在数据驱动的时代,高效、可靠地将数据写入 Elasticsearch 是每个 Java 开发者必须掌握的技能。作为官方推荐的批量操作工具,以其简洁的 API 和强大的功能,帮助我们轻松应对海量数据写入挑战。性能优化不是一蹴而就的,而是通过合理设计、持续监控和不断调优实现的。

千淘万漉虽辛苦,吹尽狂沙始到金 2万+

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

Elasticsearch Java API Client BulkProcessor并发控制:BulkIngester与Backpressure

是 Elasticsearch Java API Client 提供的一个重要工具,它允许我们高效地将大量文档批量索引到 Elasticsearch 中。相比于单个文档的索引操作,批量操作能显著减少网络往返次数,从而提高索引速度。负责收集索引请求,并根据配置的策略将它们组合成一个,然后发送到 Elasticsearch 服务器。核心概念:包含了多个索引、更新或删除操作的请求集合。用于处理 BulkRequest 的结果(成功或失败)。定义了多久将累积的文档发送到 Elasticsearch。

weixin_41455464的博客 1083

Elasticsearch BulkProcessor 批量插入、删除的具体实现

参考http://120.203.18.89:6969/93/elasticsearch-bulkprocessor-%e7%9a%84%e5%85%b7%e4%bd%93%e5%ae%9e%e7%8e%b0/ Elasticsearch 使用 BulkProcessor 将 Bulk API 进一步封装,大大简化了对文档的 增加/更新/删除 操作。接下来,我们一起来学习一下 BulkProce...

xcl119xcl的专栏 1254
上一篇: Elasticsearch学习-ClusterState
下一篇: Java-反射
迷路剑客
迷路剑客 优质创作者: 大数据技术领域 优质创作者: 大数据技术领域
博客等级 码龄16年 1万+粉丝 307原创
评论 20
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址