redis_queued_locks 1.19.0 → 1.20.0

data/lib/redis_queued_locks/acquirer/acquire_lock/yield_expire.rb

@@ -19,7 +19,9 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
   # @param logger [::Logger,#debug] Logger object.
   # @param lock_key [String] Obtained lock key that should be expired.
   # @param lock_readers_key [String] Registry of read lock holders.
-  # @param read_lock_key [String] Read lock data of the current acquirer.
+  # @param read_lock_key [String,NilClass]
+  #   Read lock data of the current acquirer (`nil` for write lock requests: they never obtain
+  #   read locks).
   # @param rw_mode [Symbol]
   #   - The mode of the obtained lock (`:read` or `:write`);
   #   - `:read` => only the read lock of the current acquirer is released/decreased;

data/lib/redis_queued_locks/acquirer/acquire_lock.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.18.0
+# @version 1.20.0
 # rubocop:disable Metrics/ModuleLength
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
@@ -46,6 +46,16 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #   Lock's time to live (in milliseconds). Nil means "without timeout".
     # @option queue_ttl [Integer]
     #   Lifetime of the acuier's lock request. In seconds.
+    # @option lock_index_enabled [Boolean]
+    #   - Maintain the lock index (`rql:index:locks`): the lock request and the obtained lock are
+    #     indexed, the lock request queue gets TTL, expired lock names are dropped from the index;
+    #   - `config['lock_index_enabled']` (the client-wide mode, not a per-call option);
+    # @option lock_index_grace_period [Integer]
+    #   - The lock index score margin over the lock key lifetime (in milliseconds): the lock name
+    #     stays in the lock index for this period after the expiration of the lock keys;
+    #   - tolerance of the client clock skew (between hosts) and of the network latency;
+    #   - pre-configured in `config['lock_index_grace_period']`;
+    #   - used only with the enabled lock index (`lock_index_enabled`);
     # @option timeout [Integer,NilClass]
     #   Time period whe should try to acquire the lock (in seconds).
     # @option timed [Boolean]
@@ -166,7 +176,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.20.0
     def acquire_lock(
       redis,
       lock_name,
@@ -176,6 +186,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
       ractor_id:,
       ttl:,
       queue_ttl:,
+      lock_index_enabled:,
+      lock_index_grace_period:,
       timeout:,
       timed:,
       retry_count:,
@@ -276,7 +288,12 @@ module RedisQueuedLocks::Acquirer::AcquireLock
       # NOTE: (RW) write lock requests use the classic lock queue (lock_key_queue)
       read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
       lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
-      read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+      # NOTE: (RW) read lock data key is required by read lock requests only (write lock requests
+      #   never obtain read locks: read-to-write lock upgrade is not supported);
+      read_lock_key =
+        if read_write_mode == :read
+          RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+        end
 
       acquirer_position = RedisQueuedLocks::Resource.calc_initial_acquirer_position
 
@@ -371,15 +388,19 @@ module RedisQueuedLocks::Acquirer::AcquireLock
             read_lock_key_queue,
             lock_readers_key,
             read_lock_key,
+            lock_name,
             acquirer_id,
             host_id,
             acquirer_position,
             lock_ttl,
             queue_ttl,
+            lock_index_enabled,
+            lock_index_grace_period,
             fail_fast,
             conflict_strategy,
             access_strategy,
             meta,
+            acq_process[:tries] > 0, # NOTE: retry attempt (see "pre-check" in `try_to_lock`)
             log_sampled,
             instr_sampled
           ) => { ok:, result: }

data/lib/redis_queued_locks/acquirer/clear_dead_requests.rb

@@ -2,11 +2,25 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.20.0
 module RedisQueuedLocks::Acquirer::ClearDeadRequests
   class << self
+    # Drops dead lock requests (requests older than `dead_ttl`) from the lock queues (write and
+    # read):
+    #   - the disabled lock index: the lock queues found in one SCAN pass, one round trip per batch
+    #     of `scan_size` lock queues (batches are collected across SCAN pages);
+    #   - the enabled lock index: the lock queues of the locks of the lock index: one ZSCAN pass
+    #     over the lock names (the keyspace is never scanned), one round trip per batch of
+    #     `scan_size` lock names (both lock queues of each lock name); expired lock names are
+    #     dropped from the lock index first;
+    #
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
+    #   SCAN count and the number of lock queues in one batch (the disabled lock index) or ZSCAN
+    #   count and the number of lock names in one batch (the enabled lock index).
     # @param dead_ttl [Integer] In milliseconds
+    # @param lock_index_enabled [Boolean]
+    #   Find lock queues via the lock index instead of the keyspace SCAN.
     # @param logger [::Logger,#debug]
     # @param instrumenter [#notify]
     # @param instrument [NilClass,Any]
@@ -22,11 +36,12 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.20.0
     def clear_dead_requests(
       redis_client,
       scan_size,
       dead_ttl,
+      lock_index_enabled,
       logger,
       instrumenter,
       instrument,
@@ -45,9 +60,35 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
       result = Set.new.tap do |processed_queues|
         # @type var processed_queues: Set[String]
         redis_client.with do |rconn|
-          each_lock_queue(rconn, scan_size) do |lock_queue|
-            rconn.call('ZREMRANGEBYSCORE', lock_queue, '-inf', dead_score)
-            processed_queues << lock_queue
+          if lock_index_enabled
+            # Step 1 (lock index): drop the expired lock names from the lock index
+            #   (all their keys are expired);
+            rconn.call(
+              'ZREMRANGEBYSCORE', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+              '-inf', RedisQueuedLocks::Resource.lock_index_time - 1
+            )
+
+            # Step 2 (lock index): drop dead requests from the lock queues of the lock index
+            each_lock_name_batch(rconn, scan_size) do |lock_names|
+              drop_dead_requests_of_locks(rconn, lock_names, dead_score, processed_queues)
+            end
+          else
+            # Step 1 (keyspace): drop dead requests from the lock queues found in one SCAN pass
+            # NOTE: dead requests are dropped with one pipeline per batch of `scan_size` queues
+            #   (batches are collected across SCAN pages: lock queues can be rare among other keys);
+            # @type var lock_queues: Array[String]
+            lock_queues = []
+
+            each_lock_queue(rconn, scan_size) do |lock_queue|
+              processed_queues << lock_queue
+              lock_queues << lock_queue
+              next if lock_queues.size < scan_size
+
+              drop_dead_requests(rconn, lock_queues, dead_score)
+              lock_queues.clear
+            end
+
+            drop_dead_requests(rconn, lock_queues, dead_score) unless lock_queues.empty?
           end
         end
       end
@@ -57,30 +98,116 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
 
     private
 
+    # Write and read lock queues in one SCAN pass (the disabled lock index).
+    #
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
     # @yield [lock_queue]
     # @yieldparam lock_queue [String]
     # @yieldreturn [void]
-    # @return [Enumerator]
+    # @return [void]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
-    def each_lock_queue(redis_client, scan_size, &block)
+    # @version 1.20.0
+    def each_lock_queue(redis_client, scan_size)
       redis_client.scan(
         'MATCH',
-        RedisQueuedLocks::Resource::LOCK_QUEUE_PATTERN,
-        count: scan_size,
-        &block
-      )
-      # NOTE: (RW) read lock queues
-      redis_client.scan(
-        'MATCH',
-        RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
-        count: scan_size,
-        &block
-      )
+        RedisQueuedLocks::Resource::ALL_LOCK_QUEUES_PATTERN,
+        count: scan_size
+      ) do |key|
+        # NOTE: the pattern matches other keys too (lock names with `queue:`): lock queues only
+        family = RedisQueuedLocks::Resource.lock_key_family(key)
+        yield(key) if family == :lock_queue || family == :read_lock_queue
+      end
+    end
+
+    # Drops dead requests of the given lock queues in one round trip (the disabled lock index).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_queues [Array<String>]
+    # @param dead_score [Float]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def drop_dead_requests(redis_client, lock_queues, dead_score)
+      redis_client.pipelined do |pipeline|
+        lock_queues.each do |lock_queue|
+          pipeline.call('ZREMRANGEBYSCORE', lock_queue, '-inf', dead_score)
+        end
+      end
+    end
+
+    # Drops dead requests of both lock queues of the given lock names in one round trip
+    # (the enabled lock index).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_names [Array<String>]
+    # @param dead_score [Float]
+    # @param processed_queues [Set<String>] Collects the existing (processed) lock queues.
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def drop_dead_requests_of_locks(redis_client, lock_names, dead_score, processed_queues)
+      # NOTE: (pipeline layout) two replies per lock queue (two lock queues per lock name) in
+      #   the batch order: EXISTS (the queue is processed when it exists), ZREMRANGEBYSCORE;
+      # @type var replies: Array[Integer]
+      replies = redis_client.pipelined do |pipeline|
+        lock_names.each do |lock_name|
+          lock_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+          read_lock_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+          pipeline.call('EXISTS', lock_queue)
+          pipeline.call('ZREMRANGEBYSCORE', lock_queue, '-inf', dead_score)
+          pipeline.call('EXISTS', read_lock_queue)
+          pipeline.call('ZREMRANGEBYSCORE', read_lock_queue, '-inf', dead_score)
+        end
+      end
+
+      lock_names.each_with_index do |lock_name, index|
+        if replies[index * 4] == 1
+          processed_queues << RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+        end
+        if replies[(index * 4) + 2] == 1
+          processed_queues << RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+        end
+      end
+    end
+
+    # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
+    # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
+    # the index yet) are skipped: all their keys are expired.
+    #
+    # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
+    #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
+    #
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer] ZSCAN count and the number of lock names in one batch.
+    # @yield [lock_names]
+    # @yieldparam lock_names [Array<String>] The batch of lock names (reused between batches).
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_lock_name_batch(redis_client, scan_size)
+      lock_index_time = RedisQueuedLocks::Resource.lock_index_time
+      # @type var lock_names: Array[String]
+      lock_names = []
+
+      redis_client.zscan(
+        RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
+      ) do |lock_name, lock_index_score|
+        next if lock_index_score.to_f < lock_index_time
+
+        lock_names << lock_name
+        next if lock_names.size < scan_size
+
+        yield(lock_names)
+        lock_names.clear
+      end
+
+      yield(lock_names) unless lock_names.empty?
     end
   end
 end

data/lib/redis_queued_locks/acquirer/extend_lock_ttl.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.18.0
+# @version 1.20.0
 # rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ExtendLockTTL
   # @return [String]
@@ -28,6 +28,8 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #   (used for `:read` mode only, ignored for `:write` mode).
     # @param acquirer_id [String]
     #   The read lock acquirer (used for `:read` mode without `all_read_locks` only).
+    # @param lock_index_enabled [Boolean]
+    #   Increase the lock index score of the lock name by the extension (the enabled lock index).
     # @param logger [::Logger,#debug]
     # @param instrumenter [#notify]
     # @param instrument [NilClass,Any]
@@ -43,7 +45,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     #
     # @api private
     # @since 1.0.0
-    # @version 1.18.0
+    # @version 1.20.0
     # rubocop:disable Metrics/MethodLength
     def extend_lock_ttl(
       redis_client,
@@ -52,6 +54,7 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
       read_write_mode,
       all_read_locks,
       acquirer_id,
+      lock_index_enabled,
       logger,
       instrumenter,
       instrument,
@@ -84,19 +87,43 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
 
         # NOTE: (RW) all live read locks of the lock
         if all_read_locks
-          return extend_all_read_locks_ttl(redis_client, lock_name, lock_key, milliseconds)
+          return extend_all_read_locks_ttl(
+            redis_client, lock_name, lock_key, milliseconds, lock_index_enabled
+          )
         end
 
         # NOTE: (RW) read lock of the concrete acquirer
-        return extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+        return extend_read_lock_ttl(
+          redis_client, lock_name, lock_key, acquirer_id, milliseconds, lock_index_enabled
+        )
       end
 
-      # NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
-      result = redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+      # NOTE:
+      #   - EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments);
+      #   - (lock index) the enabled lock index: the lock index score is increased by the extension
+      #     in the same transaction (`ZADD XX INCR`: the upper bound of the lock lifetime stays
+      #     the upper bound, locks without the index entry (of older RQL versions) are not indexed
+      #     with a wrong score); a failed extension (no lock) increases the score of the lock name
+      #     too: the name just stays in the index a bit longer;
+      #   - the disabled lock index: one EVAL command (no transaction);
+      # @type var extended: Integer
+      extended =
+        if lock_index_enabled
+          # @type var result: [Integer, Float?]
+          result = redis_client.multi do |transact|
+            transact.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+            transact.call(
+              'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+              'XX', 'INCR', milliseconds, lock_name
+            )
+          end
+          result[0]
+        else
+          redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
+        end
       # TODO: upload scripts to the redis
 
-      # @type var result: Integer
-      if result == 1
+      if extended == 1
         { ok: true, result: { extended_locks_count: 1 } }
       else
         { ok: false, result: :async_expire_or_no_lock }
@@ -117,12 +144,21 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param lock_key [String]
     # @param acquirer_id [String]
     # @param milliseconds [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.18.0
+    # @version 1.20.0
     # rubocop:disable Metrics/MethodLength
-    def extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+    def extend_read_lock_ttl(
+      redis_client,
+      lock_name,
+      lock_key,
+      acquirer_id,
+      milliseconds,
+      lock_index_enabled
+    )
       lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
       read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
 
@@ -145,6 +181,14 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             transact.call('PEXPIRE', lock_readers_key, extended_ttl, 'GT')
             transact.call('PEXPIRE', read_lock_key, extended_ttl, 'NX')
             transact.call('PEXPIRE', read_lock_key, extended_ttl, 'GT')
+            # NOTE: (lock index) the lock index score is increased by the extension
+            #   (the enabled lock index only; the last command: its reply is not read);
+            if lock_index_enabled
+              transact.call(
+                'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+                'XX', 'INCR', milliseconds, lock_name
+              )
+            end
           end
         end
       end
@@ -174,12 +218,20 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param lock_name [String]
     # @param lock_key [String]
     # @param milliseconds [Integer]
+    # @param lock_index_enabled [Boolean]
     # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.18.0
+    # @version 1.20.0
     # rubocop:disable Metrics/MethodLength
-    def extend_all_read_locks_ttl(redis_client, lock_name, lock_key, milliseconds)
+    def extend_all_read_locks_ttl(
+      redis_client,
+      lock_name,
+      lock_key,
+      milliseconds,
+      lock_index_enabled
+    )
       lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
       extended_read_locks_count = 0
 
@@ -214,6 +266,15 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
             if extended_read_locks_count > 0
               transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'NX')
               transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'GT')
+              # NOTE: (lock index) the lock index score is increased by the extension
+              #   (each read lock is extended by the same milliseconds; the enabled lock index
+              #   only; the last command: its reply is not read);
+              if lock_index_enabled
+                transact.call(
+                  'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY,
+                  'XX', 'INCR', milliseconds, lock_name
+                )
+              end
             end
           end
         end

data/lib/redis_queued_locks/acquirer/keys.rb

@@ -2,25 +2,160 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.20.0
 module RedisQueuedLocks::Acquirer::Keys
+  # The number of replies of one lock name in the key state pipeline of a batch of lock names
+  # (`collect_lock_keys`): EXISTS (write lock), EXISTS (write lock queue), EXISTS (read lock
+  # queue), ZRANGE (readers registry).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.20.0
+  KEY_STATE_REPLIES = 4
+
   class << self
+    # RQL keys of the locks:
+    #   - the disabled lock index: all the RQL keys (`RedisQueuedLocks::Resource::KEY_PATTERN`,
+    #     `rql:lock*`) found in one SCAN pass over the keyspace;
+    #   - the enabled lock index: all the existing keys of the locks of the lock index (write locks,
+    #     lock queues, readers registries, read lock queues, read lock data): one ZSCAN pass over
+    #     the lock names (`RedisQueuedLocks::Resource::LOCK_INDEX_KEY`, the keyspace is never
+    #     scanned), lock keys are derived from the lock names;
+    #
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
+    #   SCAN count (the disabled lock index) or ZSCAN count and the number of lock names in one
+    #   batch (the enabled lock index).
+    # @option lock_index_enabled [Boolean]
     # @return [Set<String>]
     #
     # @api private
     # @since 1.0.0
-    def keys(redis_client, scan_size:)
+    # @version 1.20.0
+    def keys(redis_client, scan_size:, lock_index_enabled:)
       Set.new.tap do |keyset|
         # @type var keyset: Set[String]
-        redis_client.scan(
-          'MATCH',
-          RedisQueuedLocks::Resource::KEY_PATTERN,
-          count: scan_size
-        ) do |key|
-          keyset.add(key)
+        if lock_index_enabled
+          redis_client.with do |rconn|
+            each_lock_name_batch(rconn, scan_size) do |lock_names|
+              collect_lock_keys(rconn, lock_names, keyset)
+            end
+          end
+        else
+          redis_client.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::KEY_PATTERN,
+            count: scan_size
+          ) do |key|
+            keyset.add(key)
+          end
         end
       end
     end
+
+    private
+
+    # (lock index) Adds the existing keys of the given batch of lock names to the key set
+    # (one round trip for the lock keys, one more for the read lock data when read locks exist).
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_names [Array<String>]
+    # @param keyset [Set<String>]
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    # rubocop:disable Metrics/MethodLength
+    def collect_lock_keys(redis_client, lock_names, keyset)
+      # Step 1: the state of the lock keys of the batch
+      # NOTE: (pipeline layout) `KEY_STATE_REPLIES` replies per lock name in the batch order
+      #   (the replies of the lock name with the index N start at `N * KEY_STATE_REPLIES`):
+      #   EXISTS (write lock), EXISTS (write lock queue), EXISTS (read lock queue),
+      #   ZRANGE (readers registry: redis deletes empty sorted sets, so an empty result means
+      #   the registry does not exist);
+      # @type var key_state: Array[untyped]
+      key_state = redis_client.pipelined do |pipeline|
+        lock_names.each do |lock_name|
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_lock_key(lock_name))
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_lock_queue(lock_name))
+          pipeline.call('EXISTS', RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name))
+          pipeline.call(
+            'ZRANGE', RedisQueuedLocks::Resource.prepare_lock_readers(lock_name), '0', '-1'
+          )
+        end
+      end
+
+      # @type var read_lock_keys: Array[String]
+      read_lock_keys = []
+      lock_names.each_with_index do |lock_name, index|
+        replies_at = index * KEY_STATE_REPLIES
+        if key_state[replies_at] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_lock_key(lock_name))
+        end
+        if key_state[replies_at + 1] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_lock_queue(lock_name))
+        end
+        if key_state[replies_at + 2] == 1
+          keyset.add(RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name))
+        end
+        # @type var read_lock_acquirers: Array[String]
+        read_lock_acquirers = key_state[replies_at + 3]
+        next if read_lock_acquirers.empty?
+
+        keyset.add(RedisQueuedLocks::Resource.prepare_lock_readers(lock_name))
+        read_lock_acquirers.each do |acquirer_id|
+          read_lock_keys << RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+        end
+      end
+      return if read_lock_keys.empty?
+
+      # Step 2: (RW) read lock data of the readers registries (it can be absent: the data of an
+      #   expired read lock is expired before the registry cleanup)
+      # NOTE: (pipeline layout) one EXISTS reply per read lock data key
+      # @type var read_lock_keys_existence: Array[Integer]
+      read_lock_keys_existence = redis_client.pipelined do |pipeline|
+        read_lock_keys.each { |read_lock_key| pipeline.call('EXISTS', read_lock_key) }
+      end
+      read_lock_keys.each_with_index do |read_lock_key, index|
+        keyset.add(read_lock_key) if read_lock_keys_existence[index] == 1
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Iterates over the lock names of the lock index (one ZSCAN pass) in batches of `scan_size`
+    # lock names (batches are collected across ZSCAN pages). Expired lock names (not dropped from
+    # the index yet) are skipped: all their keys are expired.
+    #
+    # NOTE: each operation module iterates over the lock index by itself (duplicated on purpose:
+    #   operation modules are independent of each other, see `Locks.each_lock_name_batch`);
+    #
+    # @param redis_client [RedisClient]
+    # @param scan_size [Integer] ZSCAN count and the number of lock names in one batch.
+    # @yield [lock_names]
+    # @yieldparam lock_names [Array<String>] The batch of lock names (reused between batches).
+    # @return [void]
+    #
+    # @api private
+    # @since 1.20.0
+    def each_lock_name_batch(redis_client, scan_size)
+      lock_index_time = RedisQueuedLocks::Resource.lock_index_time
+      # @type var lock_names: Array[String]
+      lock_names = []
+
+      redis_client.zscan(
+        RedisQueuedLocks::Resource::LOCK_INDEX_KEY, count: scan_size
+      ) do |lock_name, lock_index_score|
+        next if lock_index_score.to_f < lock_index_time
+
+        lock_names << lock_name
+        next if lock_names.size < scan_size
+
+        yield(lock_names)
+        lock_names.clear
+      end
+
+      yield(lock_names) unless lock_names.empty?
+    end
   end
 end

data/lib/redis_queued_locks/acquirer/lock_info.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.18.0
+# @version 1.20.0
 module RedisQueuedLocks::Acquirer::LockInfo
   class << self
     # @param redis_client [RedisClient]
@@ -117,6 +117,7 @@ module RedisQueuedLocks::Acquirer::LockInfo
     #
     # @api private
     # @since 1.18.0
+    # @version 1.20.0
     # rubocop:disable Metrics/MethodLength
     def read_lock_info(redis_client, lock_name, lock_key, redis_time, read_locks)
       now = RedisQueuedLocks::Resource.redis_time_ms(redis_time)
@@ -139,10 +140,15 @@ module RedisQueuedLocks::Acquirer::LockInfo
         rem_ttl = (expiration - now).ceil
         longest_rem_ttl = rem_ttl if rem_ttl > longest_rem_ttl
 
+        # NOTE: acquirer and host ids are not stored in the read lock data (both are derived from
+        #   the acquirer id): they are the first fields like in the write lock info (read lock data
+        #   of older versions contains them with the same values);
         # @type var reader: Hash[String,String|Float|Integer|nil]
-        reader = read_locks_data[index] || {}
-        reader['acq_id'] = acquirer_id
-        reader['hst_id'] ||= RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
+        reader = {
+          'acq_id' => acquirer_id,
+          'hst_id' => RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id)
+        }
+        read_locks_data[index]&.each { |field, value| reader[field] = value }
         reader['ts'] = Float(reader['ts']) if reader['ts']
         reader['ini_ttl'] = Integer(reader['ini_ttl']) if reader['ini_ttl']
         reader['rem_ttl'] = rem_ttl