Multiple commands can be sent in a batch using RBatch object in a single network call. Command batches allows to reduce the overall execution time of a group of commands. In Redis or Valkey this approach called Pipelining. Follow options could be supplied during object creation:

  1. BatchOptions options = BatchOptions.defaults()
  2. // Sets execution mode
  3. //
  4. // ExecutionMode.REDIS_READ_ATOMIC - Store batched invocations in Redis and execute them atomically as a single command
  5. //
  6. // ExecutionMode.REDIS_WRITE_ATOMIC - Store batched invocations in Redis and execute them atomically as a single command
  7. //
  8. // ExecutionMode.IN_MEMORY - Store batched invocations in memory on Redisson side and execute them on Redis. Default mode
  9. //
  10. // ExecutionMode.IN_MEMORY_ATOMIC - Store batched invocations on Redisson side and executes them atomically on Redis or Valkey as a single command
  11. .executionMode(ExecutionMode.IN_MEMORY)
  13. // Inform Redis or Valkey not to send reply back to client. This allows to save network traffic for commands with batch with big
  14. .skipResult()
  16. // Synchronize write operations execution across defined amount of Redis or Valkey slave nodes
  17. //
  18. // sync with 2 slaves with 1 second for timeout
  19. .syncSlaves(2, 1, TimeUnit.SECONDS)
  21. // Response timeout
  22. .responseTimeout(2, TimeUnit.SECONDS)
  24. // Retry interval for each attempt to send Redis or Valkey commands batch
  25. .retryInterval(2, TimeUnit.SECONDS);
  27. // Attempts amount to re-send Redis or Valkey commands batch if it wasn't sent due to network delays or other issues
  28. .retryAttempts(4);

Result Batch object contains follow data:

  1. // list of result objects per command in batch
  2. List<?> responses = res.getResponses();
  3. // amount of successfully synchronized slaves during batch execution
  4. int slaves = res.getSyncedSlaves();

Code example for Sync / Async mode:

  1. RBatch batch = redisson.createBatch(BatchOptions.defaults());
  2. batch.getMap("test1").fastPutAsync("1", "2");
  3. batch.getMap("test2").fastPutAsync("2", "3");
  4. batch.getMap("test3").putAsync("2", "5");
  5. RFuture<Long> future = batch.getAtomicLong("counter").incrementAndGetAsync();
  6. batch.getAtomicLong("counter").incrementAndGetAsync();
  8. // result could be acquired through RFuture object returned by batched method
  9. // or 
  10. // through result list by corresponding index
  11. future.whenComplete((res, exception) -> {
  12.     // ...
  13. });
  15. BatchResult res = batch.execute();
  16. // or
  17. Future<BatchResult> resFuture = batch.executeAsync();
  19. List<?> list = res.getResponses();
  20. Long result = list.get(4);

Code example of Reactive interface usage:

  1. RBatchReactive batch = redisson.createBatch(BatchOptions.defaults());
  2. batch.getMap("test1").fastPut("1", "2");
  3. batch.getMap("test2").fastPut("2", "3");
  4. batch.getMap("test3").put("2", "5");
  5. Mono<Long> commandMono = batch.getAtomicLongAsync("counter").incrementAndGet();
  6. batch.getAtomicLongAsync("counter").incrementAndGet();
  8. // result could be acquired through Reactive object returned by batched method
  9. // or 
  10. // through result list by corresponding index
  11. commandMono.doOnNext(res -> {
  12.    // ...
  13. }).subscribe();
  15. Mono<BatchResult> resMono = batch.execute();
  16. resMono.doOnNext(res -> {
  17.    List<?> list = res.getResponses();
  18.    Long result = list.get(4);
  20.    // ...
  21. }).subscribe();

Code example of RxJava3 interface usage:

  1. RBatchRx batch = redisson.createBatch(BatchOptions.defaults());
  2. batch.getMap("test1").fastPut("1", "2");
  3. batch.getMap("test2").fastPut("2", "3");
  4. batch.getMap("test3").put("2", "5");
  5. Single<Long> commandSingle = batch.getAtomicLongAsync("counter").incrementAndGet();
  6. batch.getAtomicLongAsync("counter").incrementAndGet();
  8. // result could be acquired through RxJava3 object returned by batched method
  9. // or 
  10. // through result list by corresponding index
  11. commandSingle.doOnSuccess(res -> {
  12.    // ...
  13. }).subscribe();
  15. Mono<BatchResult> resSingle = batch.execute();
  16. resSingle.doOnSuccess(res -> {
  17.    List<?> list = res.getResponses();
  18.    Long result = list.get(4);
  20.    // ...
  21. }).subscribe();

In cluster environment batch executed in map\reduce way. It aggregates commands for each node and sends them simultaneously, then result got from each node added to common result list.