redis_queued_locks 1.17.0 → 1.18.0

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

@@ -11,11 +11,12 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
     # @param acquirer_id [String]
     # @param host_id [String]
     # @param access_strategy [Symbol]
+    # @param rw_mode [Symbol]
     # @return [void]
     #
     # @api private
     # @since 1.7.0
-    # @version 1.9.0
+    # @version 1.18.0
     def expire_lock(
       logger,
       log_sampled,
@@ -23,7 +24,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -33,7 +35,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       end rescue nil
     end
 
@@ -45,11 +48,12 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
     # @param acquirer_id [String]
     # @param host_id [String]
     # @param access_strategy [Symbol]
+    # @param rw_mode [Symbol]
     # @return [void]
     #
     # @api private
     # @since 1.7.0
-    # @version 1.9.0
+    # @version 1.18.0
     def decrease_lock(
       logger,
       log_sampled,
@@ -58,7 +62,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
       queue_ttl,
       acquirer_id,
       host_id,
-      access_strategy
+      access_strategy,
+      rw_mode
     )
       return unless log_sampled
 
@@ -69,7 +74,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire::LogVisitor
         "queue_ttl => #{queue_ttl} " \
         "acq_id => '#{acquirer_id}' " \
         "hst_id => '#{host_id}' " \
-        "acs_strat => '#{access_strategy}'"
+        "acs_strat => '#{access_strategy}' " \
+        "rw_mode => '#{rw_mode}'"
       end rescue nil
     end
   end

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

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.3.0
-# @version 1.7.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
   require_relative 'yield_expire/log_visitor'
 
@@ -18,6 +18,11 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
   # @param redis [RedisClient] Redis connection.
   # @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 rw_mode [Symbol]
+  #   - The mode of the obtained lock (`:read` or `:write`);
+  #   - `:read` => only the read lock of the current acquirer is released/decreased;
   # @param acquirer_id [String] Acquirer identifier.
   # @param host_id [String] Host identifier.
   # @param access_strategy [Symbol] Lock obtaining strategy.
@@ -38,12 +43,15 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
   #
   # @api private
   # @since 1.3.0
-  # @version 1.9.0
+  # @version 1.18.0
   # rubocop:disable Metrics/MethodLength
   def yield_expire(
     redis,
     logger,
     lock_key,
+    lock_readers_key,
+    read_lock_key,
+    rw_mode,
     acquirer_id,
     host_id,
     access_strategy,
@@ -97,9 +105,17 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
     if should_expire # TODO: comment all cases/examples when should_expire is true
       LogVisitor.expire_lock(
         logger, log_sampled, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
       )
-      redis.call('EXPIRE', lock_key, '0')
+      if rw_mode == :read
+        # NOTE: release only the read lock of the current acquirer (other readers keep working)
+        redis.multi do |transact|
+          transact.call('ZREM', lock_readers_key, acquirer_id)
+          transact.call('DEL', read_lock_key)
+        end
+      else
+        redis.call('EXPIRE', lock_key, '0')
+      end
     elsif should_decrease # TODO: comment all cases/examples when should_expire is true
       finish_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
       # @type var initial_time: Integer
@@ -110,11 +126,19 @@ module RedisQueuedLocks::Acquirer::AcquireLock::YieldExpire
       if decreased_ttl > 0
         LogVisitor.decrease_lock(
           logger, log_sampled, lock_key,
-          decreased_ttl, queue_ttl, acquirer_id, host_id, access_strategy
+          decreased_ttl, queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
         )
-        # NOTE:# NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
-        redis.call('EVAL', DECREASE_LOCK_PTTL, 1, lock_key, decreased_ttl)
-        # TODO: upload scripts to the redis
+        if rw_mode == :read
+          # NOTE:
+          #   - decrease the read lock expiration of the current acquirer;
+          #   - XX => do nothing if the read lock is already expired and removed from the registry;
+          #   - the read lock data TTL is not decreased (it is not used without the read lock);
+          redis.call('ZADD', lock_readers_key, 'XX', 'INCR', -decreased_ttl, acquirer_id)
+        else
+          # NOTE:# NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
+          redis.call('EVAL', DECREASE_LOCK_PTTL, 1, lock_key, decreased_ttl)
+          # TODO: upload scripts to the redis
+        end
       end
     end
   end

data/lib/redis_queued_locks/acquirer/acquire_lock.rb

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 1.0.0
-# @version 1.7.0
+# @version 1.18.0
 # rubocop:disable Metrics/ModuleLength
 # rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/ClassLength
@@ -96,7 +96,15 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #     - `:wait_for_lock`;
     #     - `:dead_locking`;
     # @option read_write_mode [Symbol]
-    #   - ?
+    #   - `:write` (default) - exclusive lock: waits for the write lock and for all read locks;
+    #   - `:read` - shared lock: waits for the write lock only (read locks do not block each other);
+    #   - `:queued` access strategy orders read and write requests in FIFO between modes
+    #     (read request waits for earlier write requests, write request waits for earlier
+    #     read requests and for earlier write requests);
+    #   - `:meta` of the read lock is stored in the read lock data of the acquirer;
+    #   - same-process conflicts: read-to-write lock upgrade fails with
+    #     `RedisQueuedLocks::ConflictLockObtainError` for any conflict strategy except
+    #     `:wait_for_lock` (it waits for the read lock expiration);
     # @option access_strategy [Symbol]
     #   - The way in which the lock will be obtained;
     #   - By default it uses `:queued` strategy;
@@ -158,7 +166,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.14.0
+    # @version 1.18.0
     def acquire_lock(
       redis,
       lock_name,
@@ -206,6 +214,24 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         )
       end
 
+      # Step 0.1 (RW): prevent :read_write_mode incompatabilities
+      if read_write_mode != :read && read_write_mode != :write
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:read_write_mode` argument should be `:read` or `:write`, " \
+          "got #{read_write_mode.inspect}."
+        )
+      end
+
+      # Step 0.1 (RW): prevent read lock incompatabilities
+      #   - read lock expiration time is calculated from the lock ttl;
+      if read_write_mode == :read && (!ttl.is_a?(::Integer) || ttl <= 0)
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:ttl` argument should be a positive Integer for read locks, got #{ttl.inspect}."
+        )
+      end
+
       # Step 0.2: prevent :meta incompatabiltiies (structure)
       if meta.is_a?(::Hash) && (meta.any? do |key, _value|
         key == 'acq_id' ||
@@ -218,13 +244,14 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         key == 'spc_cnt' ||
         key == 'l_spc_ext_ini_ttl' ||
         key == 'l_spc_ext_ts' ||
-        key == 'l_spc_ts'
+        key == 'l_spc_ts' ||
+        key == 'rw_mode'
       end)
         raise(
           RedisQueuedLocks::ArgumentError,
           '`:meta` keys can not overlap reserved lock data keys ' \
           '"acq_id", "hst_id", "ts", "ini_ttl", "lock_key", "rem_ttl", "spc_cnt", ' \
-          '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts"'
+          '"spc_ext_ttl", "l_spc_ext_ini_ttl", "l_spc_ext_ts", "l_spc_ts", "rw_mode"'
         )
       end
 
@@ -246,8 +273,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
 
+      # 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)
-      write_lock_key_queue = RedisQueuedLocks::Resource.prepare_write_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)
 
       acquirer_position = RedisQueuedLocks::Resource.calc_initial_acquirer_position
 
@@ -285,7 +314,6 @@ module RedisQueuedLocks::Acquirer::AcquireLock
           read_write_mode,
           lock_key_queue,
           read_lock_key_queue,
-          write_lock_key_queue,
           queue_ttl,
           acquirer_id,
           host_id,
@@ -297,7 +325,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
 
       LogVisitor.start_lock_obtaining(
         logger, log_sampled, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy
+        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
       )
 
       # Step 2: try to lock with timeout
@@ -317,7 +345,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
 
           LogVisitor.start_try_to_lock_cycle(
             logger, log_sampled, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy
+            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
           )
 
           # Step 2.X: check the actual score: is it in queue ttl limit or not?
@@ -327,7 +355,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
 
             LogVisitor.dead_score_reached__reset_acquirer_position(
               logger, log_sampled, lock_key,
-              queue_ttl, acquirer_id, host_id, access_strategy
+              queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
             )
           end
 
@@ -341,7 +369,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
             read_write_mode,
             lock_key_queue,
             read_lock_key_queue,
-            write_lock_key_queue,
+            lock_readers_key,
+            read_lock_key,
             acquirer_id,
             host_id,
             acquirer_position,
@@ -375,10 +404,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               # instrumetnation: (reentrant lock with ttl extension)
               LogVisitor.extendable_reentrant_lock_obtained(
                 logger, log_sampled, result[:lock_key],
-                queue_ttl, acquirer_id, host_id, acq_time, access_strategy
+                queue_ttl, acquirer_id, host_id, acq_time, access_strategy, read_write_mode
               )
               InstrVisitor.extendable_reentrant_lock_obtained(
-                instrumenter, instr_sampled, result[:lock_key],
+                instrumenter, instr_sampled, result[:lock_key], read_write_mode,
                 result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
@@ -386,10 +415,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               # instrumetnation: (reentrant lock without ttl extension)
               LogVisitor.reentrant_lock_obtained(
                 logger, log_sampled, result[:lock_key],
-                queue_ttl, acquirer_id, host_id, acq_time, access_strategy
+                queue_ttl, acquirer_id, host_id, acq_time, access_strategy, read_write_mode
               )
               InstrVisitor.reentrant_lock_obtained(
-                instrumenter, instr_sampled, result[:lock_key],
+                instrumenter, instr_sampled, result[:lock_key], read_write_mode,
                 result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
@@ -398,10 +427,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               # NOTE: classic is: acq_process[:result][:process] == :lock_obtaining
               LogVisitor.lock_obtained(
                 logger, log_sampled, result[:lock_key],
-                queue_ttl, acquirer_id, host_id, acq_time, access_strategy
+                queue_ttl, acquirer_id, host_id, acq_time, access_strategy, read_write_mode
               )
               InstrVisitor.lock_obtained(
-                instrumenter, instr_sampled, result[:lock_key],
+                instrumenter, instr_sampled, result[:lock_key], read_write_mode,
                 result[:ttl], result[:acq_id], result[:hst_id], result[:ts], acq_time,
                 instrument
               )
@@ -416,6 +445,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               ttl: result[:ttl],
               process: result[:process]
             }
+            # NOTE: (RW) the mode of the really held lock (internal, used for the lock release)
+            acq_process[:held_rw_mode] = result[:rw_mode]
             acq_process[:acquired] = true
             acq_process[:should_try] = false
             acq_process[:acq_time] = acq_time
@@ -424,7 +455,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
             # @type var result: Symbol
 
             # Step 2.2: failed to acquire. anylize each case and act in accordance
-            if acq_process[:result] == :fail_fast_no_try # Step 2.2.a: fail without try
+            case acq_process[:result]
+            when :fail_fast_no_try # Step 2.2.a: fail without try
               acq_process[:should_try] = false
 
               if raise_errors
@@ -433,7 +465,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
                   "Lock \"#{lock_key}\" is already obtained."
                 )
               end
-            elsif acq_process[:result] == :conflict_dead_lock # Step 2.2.b: fail after dead lock
+            when :conflict_dead_lock # Step 2.2.b: fail after dead lock
               acq_process[:tries] += 1
               acq_process[:should_try] = false
               acq_process[:result] = :conflict_dead_lock
@@ -446,6 +478,21 @@ module RedisQueuedLocks::Acquirer::AcquireLock
                   "that is already acquired by the current acquirer (acq_id: \"#{acquirer_id}\")."
                 )
               end
+            when :conflict_lock_upgrade # Step 2.2.c (RW): fail after lock upgrade attempt
+              acq_process[:tries] += 1
+              acq_process[:should_try] = false
+              acq_process[:result] = :conflict_lock_upgrade
+              acq_dequeue.call
+
+              if raise_errors
+                raise(
+                  RedisQueuedLocks::ConflictLockObtainError,
+                  "Lock Conflict: trying to acquire the write lock \"#{lock_key}\" " \
+                  "while the current acquirer holds its read lock (acq_id: \"#{acquirer_id}\"): " \
+                  "read-to-write lock upgrade is not supported " \
+                  "(conflict strategy: :#{conflict_strategy})."
+                )
+              end
             else
               acq_process[:tries] += 1 # Step RETRY: possible retry case
 
@@ -510,6 +557,9 @@ module RedisQueuedLocks::Acquirer::AcquireLock
               redis,
               logger,
               lock_key,
+              lock_readers_key,
+              read_lock_key,
+              acq_process[:held_rw_mode],
               acquirer_id,
               host_id,
               access_strategy,
@@ -537,6 +587,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
                 instrumenter,
                 instr_sampled,
                 acq_process[:lock_info][:lock_key],
+                read_write_mode,
                 acq_process[:lock_info][:ttl],
                 acq_process[:lock_info][:acq_id],
                 acq_process[:lock_info][:hst_id],
@@ -551,6 +602,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock
                 instrumenter,
                 instr_sampled,
                 acq_process[:lock_info][:lock_key],
+                read_write_mode,
                 acq_process[:lock_info][:ttl],
                 acq_process[:lock_info][:acq_id],
                 acq_process[:lock_info][:hst_id],
@@ -568,7 +620,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock
         if acq_process[:result] != :retry_limit_reached &&
            acq_process[:result] != :fail_fast_no_try &&
            acq_process[:result] != :fail_fast_after_try &&
-           acq_process[:result] != :conflict_dead_lock
+           acq_process[:result] != :conflict_dead_lock &&
+           acq_process[:result] != :conflict_lock_upgrade
           # NOTE: we have only two situations if lock is not acquired without explicit failures:
           #   - time limit is reached;
           #   - retry count limit is reached;

data/lib/redis_queued_locks/acquirer/clear_dead_requests.rb

@@ -22,7 +22,7 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.18.0
     def clear_dead_requests(
       redis_client,
       scan_size,
@@ -66,6 +66,7 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def each_lock_queue(redis_client, scan_size, &block)
       redis_client.scan(
         'MATCH',
@@ -73,6 +74,13 @@ module RedisQueuedLocks::Acquirer::ClearDeadRequests
         count: scan_size,
         &block
       )
+      # NOTE: (RW) read lock queues
+      redis_client.scan(
+        'MATCH',
+        RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+        count: scan_size,
+        &block
+      )
     end
   end
 end

data/lib/redis_queued_locks/acquirer/extend_lock_ttl.rb

@@ -2,6 +2,8 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ExtendLockTTL
   # @return [String]
   #
@@ -12,10 +14,20 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     return redis.call("PEXPIRE", KEYS[1], new_lock_pttl);
   LUA_SCRIPT
 
+  # rubocop:disable Metrics/ClassLength
   class << self
     # @param redis_client [RedisClient]
     # @param lock_name [String]
     # @param milliseconds [Integer]
+    # @param read_write_mode [Symbol]
+    #   - `:write` - extends the write lock (of any acquirer);
+    #   - `:read` - extends the read lock of the given acquirer (other read locks are not affected)
+    #     or all live read locks of the lock (see `all_read_locks`);
+    # @param all_read_locks [Boolean]
+    #   Extend all live read locks of the lock instead of the read lock of the given acquirer
+    #   (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 logger [::Logger,#debug]
     # @param instrumenter [#notify]
     # @param instrument [NilClass,Any]
@@ -27,15 +39,19 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
     # @param instr_sampling_percent [Integer]
     # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
     # @param instr_sample_this [Boolean]
-    # @return [Hash<Symbol,Boolean|Symbol>]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.6.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def extend_lock_ttl(
       redis_client,
       lock_name,
       milliseconds,
+      read_write_mode,
+      all_read_locks,
+      acquirer_id,
       logger,
       instrumenter,
       instrument,
@@ -48,18 +64,181 @@ module RedisQueuedLocks::Acquirer::ExtendLockTTL
       instr_sampler,
       instr_sample_this
     )
+      if read_write_mode != :read && read_write_mode != :write
+        raise(
+          RedisQueuedLocks::ArgumentError,
+          "`:read_write_mode` argument should be `:read` or `:write`, " \
+          "got #{read_write_mode.inspect}."
+        )
+      end
+
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
 
+      if read_write_mode == :read
+        if all_read_locks != true && all_read_locks != false
+          raise(
+            RedisQueuedLocks::ArgumentError,
+            "`:all_read_locks` argument should be a boolean, got #{all_read_locks.inspect}."
+          )
+        end
+
+        # 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)
+        end
+
+        # NOTE: (RW) read lock of the concrete acquirer
+        return extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+      end
+
       # NOTE: EVAL signature -> <lua script>, (number of keys), *(keys), *(arguments)
       result = redis_client.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, milliseconds)
       # TODO: upload scripts to the redis
 
       # @type var result: Integer
       if result == 1
-        { ok: true, result: :ttl_extended }
+        { ok: true, result: { extended_locks_count: 1 } }
+      else
+        { ok: false, result: :async_expire_or_no_lock }
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # Extends the live read lock of the acquirer:
+    #   - the read lock expiration (readers registry score), the registry TTL and the read lock
+    #     data TTL are extended;
+    #   - the write lock key is watched: an expired read lock can be already replaced by a writer,
+    #     so the expired (or replaced) read lock is never "revived";
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param acquirer_id [String]
+    # @param milliseconds [Integer]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def extend_read_lock_ttl(redis_client, lock_name, lock_key, acquirer_id, milliseconds)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+      read_lock_key = RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+
+      result = redis_client.with do |rconn|
+        rconn.multi(watch: [lock_key]) do |transact|
+          # @type var lock_state: [Integer, Array[String], Float?]
+          lock_state = rconn.pipelined do |pipeline|
+            pipeline.call('EXISTS', lock_key)
+            pipeline.call('TIME')
+            pipeline.call('ZSCORE', lock_readers_key, acquirer_id)
+          end
+          redis_time = RedisQueuedLocks::Resource.redis_time_ms(lock_state[1])
+          read_lock_expiration = lock_state[2].to_f
+
+          # NOTE: no write lock and the read lock of the acquirer is alive
+          if lock_state[0] == 0 && read_lock_expiration > redis_time
+            extended_ttl = (read_lock_expiration + milliseconds - redis_time).ceil
+            transact.call('ZADD', lock_readers_key, 'XX', 'INCR', milliseconds, acquirer_id)
+            transact.call('PEXPIRE', lock_readers_key, extended_ttl, 'NX')
+            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')
+          end
+        end
+      end
+
+      # NOTE:
+      #   - [] => there is no live read lock of the acquirer (nothing to extend);
+      #   - nil => the write lock is changed during the extension (the read lock can be expired);
+      #   - result[0] => the new read lock expiration (nil if the read lock is removed);
+      if result.is_a?(::Array) && !result.empty? && result[0] != nil
+        { ok: true, result: { extended_locks_count: 1 } }
+      else
+        { ok: false, result: :async_expire_or_no_lock }
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Extends all live read locks of the lock (the same rules as for `extend_read_lock_ttl`):
+    #   - each live read lock expiration (readers registry score) and its read lock data TTL are
+    #     extended by the given milliseconds; the registry TTL is extended to the longest read lock;
+    #   - expired read locks are not extended ("revived");
+    #   - the write lock key is watched (a writer can replace the expired read locks), the registry
+    #     is not watched: concurrent read lock acquirements/releases do not abort the extension
+    #     (read locks obtained after the registry snapshot are not extended, read locks released
+    #     after it are not revived cuz of `ZADD XX`);
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param milliseconds [Integer]
+    # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def extend_all_read_locks_ttl(redis_client, lock_name, lock_key, milliseconds)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+      extended_read_locks_count = 0
+
+      result = redis_client.with do |rconn|
+        rconn.multi(watch: [lock_key]) do |transact|
+          # @type var lock_state: [Integer, Array[String], Array[[String, Float]]]
+          lock_state = rconn.pipelined do |pipeline|
+            pipeline.call('EXISTS', lock_key)
+            pipeline.call('TIME')
+            pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
+          end
+          redis_time = RedisQueuedLocks::Resource.redis_time_ms(lock_state[1])
+
+          # NOTE: no write lock => extend all live read locks
+          if lock_state[0] == 0
+            registry_ttl = 0
+
+            lock_state[2].each do |(acquirer_id, read_lock_expiration)|
+              next unless read_lock_expiration > redis_time
+
+              read_lock_key =
+                RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+              extended_ttl = (read_lock_expiration + milliseconds - redis_time).ceil
+              registry_ttl = extended_ttl if extended_ttl > registry_ttl
+              extended_read_locks_count += 1
+
+              transact.call('ZADD', lock_readers_key, 'XX', 'INCR', milliseconds, acquirer_id)
+              transact.call('PEXPIRE', read_lock_key, extended_ttl, 'NX')
+              transact.call('PEXPIRE', read_lock_key, extended_ttl, 'GT')
+            end
+
+            if extended_read_locks_count > 0
+              transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'NX')
+              transact.call('PEXPIRE', lock_readers_key, registry_ttl, 'GT')
+            end
+          end
+        end
+      end
+
+      # NOTE:
+      #   - [] => there are no live read locks (nothing to extend);
+      #   - nil => the write lock is changed during the extension (read locks can be expired);
+      #   - result[index * 3] => the new read lock expiration of each extended read lock
+      #     (nil if the read lock is released during the extension => it is not counted);
+      extended_locks_count =
+        if result.is_a?(::Array)
+          extended_read_locks_count.times.count { |index| result[index * 3] != nil }
+        else
+          0
+        end
+
+      if extended_locks_count > 0
+        { ok: true, result: { extended_locks_count: } }
       else
         { ok: false, result: :async_expire_or_no_lock }
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength