redis_queued_locks 1.17.0 → 1.19.0

data/lib/redis_queued_locks/acquirer/release_read_lock.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 1.18.0
+module RedisQueuedLocks::Acquirer::ReleaseReadLock
+  # @since 1.18.0
+  extend RedisQueuedLocks::Utilities
+
+  class << self
+    # Release the read lock of the concrete acquirer (other read locks, the write lock and
+    # lock requests are not affected): drop the acquirer from the readers registry and drop
+    # its read lock data.
+    #
+    # @param redis [RedisClient]
+    #   Redis connection client.
+    # @param lock_name [String]
+    #   The lock name whose read lock should be released.
+    # @param acquirer_id [String]
+    #   The read lock acquirer.
+    # @param instrumenter [#notify]
+    #   See RedisQueuedLocks::Instrument::ActiveSupport for example.
+    # @param logger [::Logger,#debug]
+    #   - Logger object used from `configuration` layer (see config['logger']);
+    #   - See RedisQueuedLocks::Logging::VoidLogger for example;
+    # @param instrument [NilClass,Any]
+    #   - Custom instrumentation data wich will be passed to the instrumenter's payload
+    #     with :instrument key;
+    # @param log_sampling_enabled [Boolean]
+    # @param log_sampling_percent [Integer]
+    # @param log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+    # @param log_sample_this [Boolean]
+    # @param instr_sampling_enabled [Boolean]
+    #   - enables <instrumentaion sampling>: only the configured percent
+    #     of RQL cases will be instrumented;
+    # @param instr_sampling_percent [Integer]
+    #   - the percent of cases that should be instrumented;
+    # @param instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+    #   - percent-based sampler that decides should be RQL case instrumented or not;
+    # @param instr_sample_this [Boolean]
+    #   - marks the method that everything should be instrumneted
+    #     despite the enabled instrumentation sampling;
+    # @return [Hash<Symbol,Boolean<Hash<Symbol,Numeric|String|Symbol>>]
+    #   Format: {
+    #     ok: true,
+    #     result: {
+    #       rel_time: Numeric, # <milliseconds>
+    #       rel_key: String, # lock key
+    #       rel_acq_id: String, # read lock acquirer
+    #       lock_res: Symbol # :released or :nothing_to_release
+    #     }
+    #   }
+    #
+    # @api private
+    # @since 1.18.0
+    # rubocop:disable Metrics/MethodLength
+    def release_read_lock(
+      redis,
+      lock_name,
+      acquirer_id,
+      instrumenter,
+      logger,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
+    )
+      lock_key = RedisQueuedLocks::Resource.prepare_lock_key(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)
+
+      rel_start_time = clock_gettime
+      # steep:ignore:start
+      fully_release_read_lock(
+        redis, lock_readers_key, read_lock_key, acquirer_id
+      ) => { ok:, result: }
+      # steep:ignore:end
+
+      # @type var ok: bool
+      # @type var result: Hash[Symbol,Symbol]
+
+      time_at = Time.now.to_f
+      rel_end_time = clock_gettime
+      rel_time = ((rel_end_time - rel_start_time) / 1_000.0).ceil(2)
+
+      instr_sampled = RedisQueuedLocks::Instrument.should_instrument?(
+        instr_sampling_enabled,
+        instr_sample_this,
+        instr_sampling_percent,
+        instr_sampler
+      )
+
+      run_non_critical do
+        instrumenter.notify('redis_queued_locks.explicit_read_lock_release', {
+          lock_key: lock_key,
+          acq_id: acquirer_id,
+          lock_res: result[:lock],
+          rel_time: rel_time,
+          at: time_at,
+          instrument: instrument
+        })
+      end if instr_sampled
+
+      {
+        ok: true,
+        result: {
+          rel_time: rel_time,
+          rel_key: lock_key,
+          rel_acq_id: acquirer_id,
+          lock_res: result[:lock]
+        }
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    private
+
+    # @param redis [RedisClient]
+    # @param lock_readers_key [String]
+    # @param read_lock_key [String]
+    # @param acquirer_id [String]
+    # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
+    #   Format: { ok: true, result: { lock: :released/:nothing_to_release } }
+    #
+    # @api private
+    # @since 1.18.0
+    def fully_release_read_lock(redis, lock_readers_key, read_lock_key, acquirer_id)
+      # @type var result: [Integer,Integer]
+      result = redis.with do |rconn|
+        rconn.multi do |transact|
+          transact.call('ZREM', lock_readers_key, acquirer_id)
+          transact.call('DEL', read_lock_key)
+        end
+      end
+
+      { ok: true, result: { lock: (result[0] != 0) ? :released : :nothing_to_release } }
+    end
+  end
+end

data/lib/redis_queued_locks/acquirer.rb

@@ -6,6 +6,7 @@ module RedisQueuedLocks::Acquirer
   require_relative 'acquirer/acquire_lock'
   require_relative 'acquirer/lock_series_poc'
   require_relative 'acquirer/release_lock'
+  require_relative 'acquirer/release_read_lock'
   require_relative 'acquirer/release_all_locks'
   require_relative 'acquirer/release_locks_of'
   require_relative 'acquirer/is_locked'

data/lib/redis_queued_locks/client.rb

@@ -2,7 +2,7 @@
 
 # @api public
 # @since 1.0.0
-# @version 1.16.0
+# @version 1.18.0
 # rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Client
   # @return [RedisClient]
@@ -207,7 +207,28 @@ class RedisQueuedLocks::Client
   #       (with timeouts, retry delays, retry limits, etc - in classic way :));
   #     - `:dead_locking` - fail with deadlock exception;
   # @option read_write_mode [Symbol]
-  #   - ?
+  #   - The lock mode (read/write lock semantics);
+  #   - `:write` mode is used by default;
+  #   - Supports:
+  #     - `:write` - exclusive lock: waits for the write lock and for all read locks;
+  #     - `:read` - shared lock: waits for the write lock only (read locks of different
+  #       acquirers do not block each other);
+  #   - `:queued` access strategy orders read and write lock requests in FIFO between modes
+  #     (read lock request waits for earlier write lock requests, write lock request waits for
+  #     earlier read and write lock requests) so writers are not starved by readers;
+  #   - `:random` access strategy ignores lock queues (a continuous flow of readers can starve
+  #     writers);
+  #   - read lock specifics:
+  #     - read lock is released (with a block of code) or expired (by `ttl`) independently
+  #       of other read locks; `#unlock` releases all read locks and the write lock;
+  #     - each read lock has its own data (acquirer, host, timestamp, ttl, `:meta`, reentrant
+  #       lock data) that is returned by `#lock_info` for each reader;
+  #   - same-process conflicts (`conflict_strategy`) work for both modes:
+  #     - read lock request under the obtained write lock (or read lock) works as a reentrant
+  #       lock of the obtained lock;
+  #     - write lock request under the obtained read lock (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;
@@ -310,7 +331,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.13.0
+  # @version 1.18.0
   # rubocop:disable Metrics/MethodLength
   def lock(
     lock_name,
@@ -531,7 +552,7 @@ class RedisQueuedLocks::Client
   #
   # @api public
   # @since 1.0.0
-  # @version 1.13.0
+  # @version 1.18.0
   def lock!(
     lock_name,
     ttl: config['default_lock_ttl'],
@@ -596,6 +617,8 @@ class RedisQueuedLocks::Client
   end
   # rubocop:enable Metrics/MethodLength
 
+  # Releases the lock: the write lock, all read locks and all lock requests (write and read).
+  #
   # @param lock_name [String] The lock name that should be released.
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify]
@@ -615,14 +638,14 @@ class RedisQueuedLocks::Client
   #       rel_time: Integer, # <millisecnds>
   #       rel_key: String, # lock key
   #       rel_queue: String, # lock queue
-  #       queue_res: Symbol, # :released or :nothing_to_release
-  #       lock_res: Symbol # :released or :nothing_to_release
+  #       queue_res: Symbol, # :released or :nothing_to_release (write or read lock requests)
+  #       lock_res: Symbol # :released or :nothing_to_release (write lock or read locks)
   #     }
   #   }
   #
   # @api public
   # @since 1.0.0
-  # @version 1.6.0
+  # @version 1.18.0
   def unlock(
     lock_name,
     logger: config['logger'],
@@ -654,38 +677,126 @@ class RedisQueuedLocks::Client
   end
   alias_method :release_lock, :unlock
 
+  # Releases the read lock of the current acquirer (or of the custom acquirer passed via
+  # `acquirer_id:`) only: other read locks, the write lock and lock requests are not affected
+  # (`#unlock` releases the lock entirely). It is suitable for read locks obtained without
+  # a block of code.
+  #
+  # @param lock_name [String] The lock name whose read lock should be released.
+  # @option acquirer_id [String,NilClass]
+  #   - The acquirer whose read lock should be released (`nil` by default);
+  #   - `nil` => the current acquirer is used (calculated from `identity:`, see `#current_acquirer_id`);
+  #   - can be extracted from the lock data (`#lock_info`, `#locks_info`, `#queue_info`, `#queues_info`);
+  # @option identity [String]
+  #   Unique acquirer identity (the same as for `#lock`) that is used to calculate the current
+  #   acquirer id (see `#current_acquirer_id`). Ignored when `acquirer_id:` is passed: the acquirer id
+  #   already contains its own identity.
+  # @option logger [::Logger,#debug]
+  # @option instrumenter [#notify]
+  # @option instrument [NilClass,Any]
+  # @option log_sampling_enabled [Boolean]
+  # @option log_sampling_percent [Integer]
+  # @option log_sampler [#sampling_happened?,Module<RedisQueuedLocks::Logging::Sampler>]
+  # @option log_sample_this [Boolean]
+  # @option instr_sampling_enabled [Boolean]
+  # @option instr_sampling_percent [Integer]
+  # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
+  # @option instr_sample_this [Boolean]
+  # @return [Hash<Symbol,Any>]
+  #   Format: {
+  #     ok: true,
+  #     result: {
+  #       rel_time: Numeric, # <milliseconds>
+  #       rel_key: String, # lock key
+  #       rel_acq_id: String, # read lock acquirer
+  #       lock_res: Symbol # :released or :nothing_to_release
+  #     }
+  #   }
+  #
+  # @example Release the read lock of the current acquirer:
+  #   client.unlock_read('report')
+  #
+  # @example Release the read lock of a different acquirer:
+  #   client.unlock_read('report', acquirer_id: "rql:acq:62681/2016/2024/2032/b30ec5e4bea10512")
+  #
+  # @api public
+  # @since 1.18.0
+  # @version 1.19.0
+  def unlock_read(
+    lock_name,
+    acquirer_id: nil,
+    identity: uniq_identity,
+    logger: config['logger'],
+    instrumenter: config['instrumenter'],
+    instrument: nil,
+    log_sampling_enabled: config['log_sampling_enabled'],
+    log_sampling_percent: config['log_sampling_percent'],
+    log_sampler: config['log_sampler'],
+    log_sample_this: false,
+    instr_sampling_enabled: config['instr_sampling_enabled'],
+    instr_sampling_percent: config['instr_sampling_percent'],
+    instr_sampler: config['instr_sampler'],
+    instr_sample_this: false
+  )
+    RedisQueuedLocks::Acquirer::ReleaseReadLock.release_read_lock(
+      redis_client,
+      lock_name,
+      acquirer_id || current_acquirer_id(identity:),
+      instrumenter,
+      logger,
+      instrument,
+      log_sampling_enabled,
+      log_sampling_percent,
+      log_sampler,
+      log_sample_this,
+      instr_sampling_enabled,
+      instr_sampling_percent,
+      instr_sampler,
+      instr_sample_this
+    )
+  end
+  alias_method :release_read_lock, :unlock_read
+
   # @param lock_name [String]
-  # @return [Boolean]
+  # @return [Boolean] Is the lock obtained by a writer or by any reader.
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def locked?(lock_name)
     RedisQueuedLocks::Acquirer::IsLocked.locked?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
-  # @return [Boolean]
+  # @return [Boolean] Are there any write or read lock requests.
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def queued?(lock_name)
     RedisQueuedLocks::Acquirer::IsQueued.queued?(redis_client, lock_name)
   end
 
   # @param lock_name [String]
-  # @return [Hash<String,String|Numeric>,NilClass]
+  # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+  #   - write lock info or read locks info (when there is no write lock);
+  #   - see `RedisQueuedLocks::Acquirer::LockInfo.lock_info` for details;
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def lock_info(lock_name)
     RedisQueuedLocks::Acquirer::LockInfo.lock_info(redis_client, lock_name)
   end
 
   # @param lock_name [String]
   # @return [Hash<String|Array<Hash<String,String|Numeric>>,NilClass]
+  #   - write lock requests and read lock requests (when they exist);
+  #   - see `RedisQueuedLocks::Acquirer::QueueInfo.queue_info` for details;
   #
   # @api public
   # @since 1.0.0
+  # @version 1.18.0
   def queue_info(lock_name)
     RedisQueuedLocks::Acquirer::QueueInfo.queue_info(redis_client, lock_name)
   end
@@ -783,6 +894,16 @@ class RedisQueuedLocks::Client
   #
   # @param lock_name [String]
   # @param milliseconds [Integer] How many milliseconds should be added.
+  # @option read_write_mode [Symbol]
+  #   - `:write` (default) - extends the write lock (the method description above);
+  #   - `:read` - extends the read lock of the current acquirer only (an expired read lock or
+  #     a read lock replaced by a writer is not extended);
+  # @option all_read_locks [Boolean]
+  #   `:read` mode only (ignored for `:write` mode): extends all live read locks of the lock
+  #   instead of the read lock of the current acquirer (`false` by default).
+  # @option identity [String]
+  #   Unique acquirer identity (the same as for `#lock`) that is used to calculate the current
+  #   acquirer id for `:read` mode (see `#current_acquirer_id`).
   # @option logger [::Logger,#debug]
   # @option instrumenter [#notify] See `config['instrumenter']` docs for details.
   # @option instrument [NilClass,Any]
@@ -794,16 +915,21 @@ class RedisQueuedLocks::Client
   # @option instr_sampling_percent [Integer]
   # @option instr_sampler [#sampling_happened?,Module<RedisQueuedLocks::Instrument::Sampler>]
   # @option instr_sample_this [Boolean]
-  # @return [Hash<Symbol,Boolean|Symbol>]
-  #   - { ok: true, result: :ttl_extended }
+  # @return [Hash<Symbol,Boolean|Symbol|Hash<Symbol,Integer>>]
+  #   - { ok: true, result: { extended_locks_count: Integer } } - the number of extended locks:
+  #     `1` for the write lock and for the read lock of the current acquirer,
+  #     the number of extended read locks for `all_read_locks: true`;
   #   - { ok: false, result: :async_expire_or_no_lock }
   #
   # @api public
   # @since 1.0.0
-  # @version 1.6.0
+  # @version 1.18.0
   def extend_lock_ttl(
     lock_name,
     milliseconds,
+    read_write_mode: :write,
+    all_read_locks: false,
+    identity: uniq_identity,
     logger: config['logger'],
     instrumenter: config['instrumenter'],
     instrument: nil,
@@ -820,6 +946,9 @@ class RedisQueuedLocks::Client
       redis_client,
       lock_name,
       milliseconds,
+      read_write_mode,
+      all_read_locks,
+      current_acquirer_id(identity:),
       logger,
       instrumenter,
       instrument,
@@ -928,7 +1057,7 @@ class RedisQueuedLocks::Client
   # @example Release locks of a different host/acquirer:
   #   client.clear_locks_of(
   #     host_id: "rql:hst:62681/2016/2032/b30ec5e4bea10512",
-  #     acquirer_id: "ral:acq:62681/2016/2024/2032/b30ec5e4bea10512"
+  #     acquirer_id: "rql:acq:62681/2016/2024/2032/b30ec5e4bea10512"
   #   )
   #
   # @see #clear_current_locks

data/lib/redis_queued_locks/resource.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Resource
   # @return [String]
   #
@@ -21,17 +22,30 @@ module RedisQueuedLocks::Resource
   # @since 1.0.0
   LOCK_QUEUE_PATTERN = 'rql:lock_queue:*'
 
+  # NOTE:
+  #   - read/write keys use their own prefixes (not suffixes of the lock name) cuz the lock name
+  #     is an arbitrary string: `rql:lock_queue:<name>:read` collides with the queue of a lock
+  #     named "<name>:read";
+  #   - new prefixes are not matched by LOCK_PATTERN/LOCK_QUEUE_PATTERN
+  #     (`rql:lock_` vs `rql:lock:`) but are matched by KEY_PATTERN;
+  #   - write lock requests use the classic lock queue (LOCK_QUEUE_PATTERN);
   # @return [String]
   #
   # @api private
-  # @since ?.?.?
-  READ_LOCK_QUEUE_PATTERN = 'rql:lock_queue:*:read'
+  # @since 1.18.0
+  READ_LOCK_QUEUE_PATTERN = 'rql:lock_read_queue:*'
 
   # @return [String]
   #
   # @api private
-  # @since ?.?.?
-  WRITE_LOCK_QUEUE_PATTERN = 'rql:lock_queue:*:write'
+  # @since 1.18.0
+  LOCK_READERS_PATTERN = 'rql:lock_readers:*'
+
+  # @return [String]
+  #
+  # @api private
+  # @since 1.18.0
+  READ_LOCK_PATTERN = 'rql:lock_reader:*'
 
   # @return [String]
   #
@@ -105,22 +119,115 @@ module RedisQueuedLocks::Resource
       "rql:lock_queue:#{lock_name}"
     end
 
+    # Queue of read lock requests (write lock requests use the classic lock queue).
+    #
     # @param lock_name [String]
     # @return [String]
     #
     # @api private
-    # @api ?.?.?
+    # @since 1.18.0
     def prepare_read_lock_queue(lock_name)
-      "rql:lock_queue:#{lock_name}:read"
+      "rql:lock_read_queue:#{lock_name}"
     end
 
+    # Registry of read lock holders: a sorted set where the member is an acquirer id and
+    # the score is the read lock expiration time (redis server time, epoch milliseconds).
+    #
     # @param lock_name [String]
     # @return [String]
     #
     # @api private
-    # @api ?.?.?
-    def prepare_write_lock_queue(lock_name)
-      "rql:lock_queue:#{lock_name}:write"
+    # @since 1.18.0
+    def prepare_lock_readers(lock_name)
+      "rql:lock_readers:#{lock_name}"
+    end
+
+    # Read lock data of the concrete acquirer: a hash with the same structure as the write lock
+    # (acquirer, host, timestamp, ttl, meta, reentrant lock data). It is a data carrier only:
+    # the readers registry is the source of truth for the read lock existence.
+    #
+    # @param lock_name [String]
+    # @param acquirer_id [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 1.18.0
+    def prepare_read_lock_key(lock_name, acquirer_id)
+      "rql:lock_reader:#{lock_name}:#{acquirer_id}"
+    end
+
+    # Mode of the lock requests stored in the given lock queue.
+    #
+    # @param lock_queue [String]
+    #   Write lock queue (`rql:lock_queue:*`) or read lock queue (`rql:lock_read_queue:*`).
+    # @return [String,NilClass]
+    #   - `'write'` for the write lock queue, `'read'` for the read lock queue;
+    #   - `nil` for any other key (unreachable: lock queues are always passed consistently);
+    #
+    # @api private
+    # @since 1.18.0
+    def lock_queue_rw_mode(lock_queue)
+      # NOTE:
+      #   - `start_with?` instead of regexp `when`-matchers: no MatchData allocations;
+      #   - write lock queues are checked first: they are met more often than read lock queues;
+      case
+      when lock_queue.start_with?('rql:lock_queue:') then 'write'
+      when lock_queue.start_with?('rql:lock_read_queue:') then 'read'
+      else
+        # NOTE: unreachable: the logic always passes a consistent lock queue (read or write)
+        nil
+      end
+    end
+
+    # @param lock_readers_key [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 1.18.0
+    def lock_name_from_readers(lock_readers_key)
+      lock_readers_key.delete_prefix('rql:lock_readers:')
+    end
+
+    # @param lock_readers_key [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 1.18.0
+    def lock_key_from_readers(lock_readers_key)
+      "rql:lock:#{lock_readers_key.delete_prefix('rql:lock_readers:')}"
+    end
+
+    # Host identifier of the given acquirer
+    # (acquirer and host identifiers are built from the same process/thread/ractor/identity data):
+    #   - acquirer id: `rql:acq:<pid>/<thread>/<fiber>/<ractor>/<identity>`;
+    #   - host id: `rql:hst:<pid>/<thread>/<ractor>/<identity>` (the same as `host_identifier`);
+    #
+    # @param acquirer_id [String]
+    # @return [String]
+    #
+    # @api private
+    # @since 1.18.0
+    def host_identifier_from_acquirer(acquirer_id)
+      # NOTE:
+      #   - the host id is the acquirer id with another prefix and without the fiber part, so it is
+      #     built in place from the acquirer id copy (one allocation: no intermediate strings and
+      #     arrays of `delete_prefix`/`split`, no substrings);
+      #   - 8 is the size of the `rql:acq:` prefix;
+      #   - byte positions are used cuz identity can contain any (multibyte) symbols;
+      thread_end = acquirer_id.byteindex('/', acquirer_id.byteindex('/', 8).to_i + 1).to_i
+      fiber_end = acquirer_id.byteindex('/', thread_end + 1).to_i
+      host_id = acquirer_id.dup
+      host_id.bytesplice(thread_end, fiber_end - thread_end, '') # NOTE: drop "/<fiber>"
+      host_id.bytesplice(0, 8, 'rql:hst:')
+    end
+
+    # @param redis_time [Array<String>] Result of the redis `TIME` command (seconds, microseconds).
+    # @return [Integer] Redis server time (epoch, in milliseconds).
+    #
+    # @api private
+    # @since 1.18.0
+    def redis_time_ms(redis_time)
+      (Integer(redis_time[0]) * 1_000) + (Integer(redis_time[1]) / 1_000)
     end
 
     # @return [Float] Redis's <Set> score that is calculated from the time (epoch) as a float.
@@ -241,3 +348,4 @@ module RedisQueuedLocks::Resource
     end
   end
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/swarm/flush_zombies.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.9.0
+# rubocop:disable Metrics/ClassLength
 class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElement::Isolated
   class << self
     # @param redis_client [RedisClient]
@@ -18,6 +19,7 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
     #
     # @api private
     # @since 1.9.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def flush_zombies(
       redis_client,
@@ -65,6 +67,32 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
         # NOTE: (steep) steep can't use <Set>s for splats
         rconn.call('DEL', *zombie_locks) if zombie_locks.any? # steep:ignore
 
+        # Step 3 (RW): find zombie read locks (read locks of zombie hosts) and drop them
+        #   - read locks store acquirer ids only (the host is a part of the acquirer id);
+        #   - readers registry is reported as a zombie lock if any of its read locks is dropped;
+        rconn.scan(
+          'MATCH', RedisQueuedLocks::Resource::LOCK_READERS_PATTERN, count: lock_scan_size
+        ) do |lock_readers_key|
+          # @type var read_lock_acquirers: Array[String]
+          read_lock_acquirers = rconn.call('ZRANGE', lock_readers_key, '0', '-1')
+          zombie_readers = read_lock_acquirers.select do |acquirer_id|
+            zombie_hosts.include?(RedisQueuedLocks::Resource.host_identifier_from_acquirer(acquirer_id))
+          end
+          next if zombie_readers.empty?
+
+          rconn.call('ZREM', lock_readers_key, *zombie_readers)
+          # NOTE: drop the zombie read lock data
+          lock_name = RedisQueuedLocks::Resource.lock_name_from_readers(lock_readers_key)
+          rconn.call(
+            'DEL',
+            *zombie_readers.map do |acquirer_id|
+              RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+            end
+          )
+          zombie_locks << lock_readers_key
+          zombie_acquirers.merge(zombie_readers)
+        end
+
         # Step 4: find zombie requests => and drop them
         # TODO: indexing (in order to prevent full database scan);
         # NOTE: original redis does not support indexing so we need to use
@@ -77,6 +105,15 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
           end
         end
 
+        # Step 4 (RW): drop zombie requests from the queues of read lock requests
+        rconn.scan(
+          'MATCH', RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN, count: queue_scan_size
+        ) do |read_lock_queue|
+          zombie_acquirers.each do |zombie_acquirer|
+            rconn.call('ZREM', read_lock_queue, zombie_acquirer)
+          end
+        end
+
         # Step 5: drop zombies from the swarm
         rconn.call('HDEL', RedisQueuedLocks::Resource::SWARM_KEY, *zombie_hosts)
 
@@ -134,3 +171,4 @@ class RedisQueuedLocks::Swarm::FlushZombies < RedisQueuedLocks::Swarm::SwarmElem
     end
   end
 end
+# rubocop:enable Metrics/ClassLength