redis_queued_locks 1.17.0 → 1.19.0

data/lib/redis_queued_locks/acquirer/locks.rb

@@ -2,7 +2,10 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::Locks
+  # rubocop:disable Metrics/ClassLength
   class << self
     # @param redis_client [RedisClient]
     # @option scan_size [Integer]
@@ -23,9 +26,11 @@ module RedisQueuedLocks::Acquirer::Locks
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
     # @return [Set<String>]
+    #   - (RW) read locks are represented by their lock keys (`rql:lock:<lock_name>`) too;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def scan_locks(redis_client, scan_size)
       Set.new.tap do |lock_keys|
         redis_client.scan(
@@ -36,19 +41,33 @@ module RedisQueuedLocks::Acquirer::Locks
           # TODO: reduce unnecessary iterations
           lock_keys.add(lock_key)
         end
+
+        # NOTE: (RW) read locks (readers registries can contain expired read locks only)
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+          count: scan_size
+        ) do |lock_readers_key|
+          # TODO: reduce unnecessary iterations
+          lock_keys.add(RedisQueuedLocks::Resource.lock_key_from_readers(lock_readers_key))
+        end
       end
     end
 
+    # NOTE:
+    #   - the lock info is extracted by the module itself with the same approach as in `LockInfo`:
+    #     public operation modules do not reuse each other (they share logic via `Resource`,
+    #     `Utilities`), so the similar logic is duplicated on purpose;
+    #
     # @param redis_client [RedisClient]
     # @param lock_keys [Set<String>]
     # @return [Set<Hash<Symbol,Any>>]
     #
     # @api private
     # @since 1.0.0
-    # @version 1.9.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def extract_locks_info(redis_client, lock_keys)
-      # TODO: refactor with RedisQueuedLocks::Acquier::LockInfo
       Set.new.tap do |seeded_locks|
         # rubocop:disable Layout/LineLength
         # @type var seeded_locks: Set[{ lock: String, status: :released|:alive, info: Hash[String,untyped] }]
@@ -58,10 +77,16 @@ module RedisQueuedLocks::Acquirer::Locks
         lock_keys.each do |lock_key|
           # Step 1: extract lock info from redis
 
-          # @type var lock_info: Hash[String,String|Float|Integer]
+          # NOTE: (RW) readers registry of the lock
+          lock_name = lock_key.delete_prefix('rql:lock:')
+          lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
+
+          # @type var lock_info: RedisQueuedLocks::Acquirer::Locks::lockInfo
           lock_info = redis_client.pipelined do |pipeline|
             pipeline.call('HGETALL', lock_key)
             pipeline.call('PTTL', lock_key)
+            pipeline.call('TIME')
+            pipeline.call('ZRANGE', lock_readers_key, '0', '-1', 'WITHSCORES')
           end.yield_self do |result| # Step 2: format the result
             # Step 2.X: lock is released
             if result == nil
@@ -73,16 +98,22 @@ module RedisQueuedLocks::Acquirer::Locks
               #   - result[1] (PTTL) (Integer)
               #     => (without any mutation, integer is atomic)
 
-              # @type var result: [Hash[String,String|Float|Integer],Integer]
+              # rubocop:disable Layout/LineLength
+              # @type var result: [Hash[String,String|Float|Integer],Integer,Array[String],Array[[String, Float]]]
+              # rubocop:enable Layout/LineLength
               hget_cmd_res = result[0] # NOTE: HGETALL result (hash)
               pttl_cmd_res = result[1] # NOTE: PTTL result (integer)
 
-              # Step 2.Y: lock is released
+              # Step 2.Y: write lock is released
               if hget_cmd_res == {} || pttl_cmd_res == -2 # NOTE: key does not exist
-                {} #: Hash[String,String|Float|Integer]
+                # NOTE: (RW) read locks (or nothing if there are no live read locks)
+                read_lock_info(
+                  redis_client, lock_name, lock_key, result[2], result[3]
+                ) || {} #: Hash[String,String|Float|Integer]
               else
                 # Step 2.Z: lock is alive => format received info + add additional rem_ttl info
                 hget_cmd_res.tap do |lock_data|
+                  lock_data['rw_mode'] = 'write'
                   lock_data['ts'] = Float(lock_data['ts'])
                   lock_data['ini_ttl'] = Integer(lock_data['ini_ttl'])
                   lock_data['rem_ttl'] = ((pttl_cmd_res == -1) ? Float::INFINITY : pttl_cmd_res)
@@ -109,5 +140,71 @@ module RedisQueuedLocks::Acquirer::Locks
       end
     end
     # rubocop:enable Metrics/MethodLength
+
+    # Formats live read locks of the lock (expired read locks are ignored).
+    #
+    # NOTE: the same approach as in `LockInfo` (duplicated on purpose: operation modules are
+    #   independent of each other, see `extract_locks_info`);
+    #
+    # @param redis_client [RedisClient]
+    # @param lock_name [String]
+    # @param lock_key [String]
+    # @param redis_time [Array<String>] Result of the redis `TIME` command.
+    # @param read_locks [Array<Array<String,Float>>] Readers registry (acquirer id, expiration).
+    # @return [Hash<String,String|Numeric|Array<Hash<String,String|Numeric>>>,NilClass]
+    #   - `nil` is returned when there are no live read locks;
+    #   - each reader has the same data as the write lock (acq_id, hst_id, ts, ini_ttl, rem_ttl,
+    #     meta, reentrant lock data);
+    #
+    # @api private
+    # @since 1.18.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)
+      live_read_locks = read_locks.select { |(_acquirer_id, expiration)| expiration > now }
+      return nil if live_read_locks.empty?
+
+      # NOTE: read lock data (it can be absent if it is dropped during the read lock life)
+      # @type var read_locks_data: Array[Hash[String,String]]
+      read_locks_data = redis_client.pipelined do |pipeline|
+        live_read_locks.each do |(acquirer_id, _expiration)|
+          pipeline.call(
+            'HGETALL',
+            RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+          )
+        end
+      end
+
+      longest_rem_ttl = 0
+      readers = live_read_locks.each_with_index.map do |(acquirer_id, expiration), index|
+        rem_ttl = (expiration - now).ceil
+        longest_rem_ttl = rem_ttl if rem_ttl > longest_rem_ttl
+
+        # @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['ts'] = Float(reader['ts']) if reader['ts']
+        reader['ini_ttl'] = Integer(reader['ini_ttl']) if reader['ini_ttl']
+        reader['rem_ttl'] = rem_ttl
+        reader['spc_cnt'] = Integer(reader['spc_cnt']) if reader['spc_cnt']
+        reader['l_spc_ts'] = Float(reader['l_spc_ts']) if reader['l_spc_ts']
+        reader['spc_ext_ttl'] = Integer(reader['spc_ext_ttl']) if reader['spc_ext_ttl']
+        reader['l_spc_ext_ini_ttl'] =
+          Integer(reader['l_spc_ext_ini_ttl']) if reader['l_spc_ext_ini_ttl']
+        reader['l_spc_ext_ts'] = Float(reader['l_spc_ext_ts']) if reader['l_spc_ext_ts']
+        reader
+      end
+
+      {
+        'lock_key' => lock_key,
+        'rw_mode' => 'read',
+        'rem_ttl' => longest_rem_ttl,
+        'readers' => readers
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
   end
+  # rubocop:enable Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength

data/lib/redis_queued_locks/acquirer/queue_info.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::QueueInfo
   class << self
     # Returns an information about the required lock queue by the lock name. The result
@@ -12,41 +13,69 @@ module RedisQueuedLocks::Acquirer::QueueInfo
     #
     # @param redis_client [RedisClient]
     # @param lock_name [String]
-    # @return [Hash<String,Array<Hash<String,String|Numeric>>,NilClass]
-    #   - `nil` is returned when lock queue does not exist;
+    # @return [Hash<String,String|Array<Hash<String,String|Numeric>>,NilClass]
+    #   - `nil` is returned when lock queues (write and read) do not exist;
     #   - result format: {
     #     "lock_queue" => "rql:lock_queue:your_lock_name", # lock queue key in redis,
     #     "queue" => [
-    #       { "acq_id" => "rql:acq:123/456/789/987/identity", "score" => 123.456 },
-    #       { "acq_id" => "rql:acq:123/686/789/987/identity", "score" => 456.789 },
+    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "write" },
+    #       { "acq_id" => "rql:acq:123/686/789/987/id", "score" => 456.789, "rw_mode" => "write" },
     #       ...
-    #     ] # ordered set (by score) with information about an acquirer and their position in queue
+    #     ] # ordered set (by score) with information about an acquirer, their position in queue
+    #       # and the requested lock mode
+    #     <additional keys when the queue of read lock requests exists>:
+    #     "read_lock_queue" => "rql:lock_read_queue:your_lock_name", # read lock queue key in redis
+    #     "read_queue" => [
+    #       { "acq_id" => "rql:acq:123/456/789/987/id", "score" => 123.456, "rw_mode" => "read" },
+    #       ...
+    #     ] # read lock requests (positions are comparable with the write lock request positions)
     #   }
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def queue_info(redis_client, lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
 
       result = redis_client.pipelined do |pipeline|
         pipeline.call('EXISTS', lock_key_queue)
         pipeline.call('ZRANGE', lock_key_queue, '0', '-1', 'WITHSCORES')
+        pipeline.call('EXISTS', read_lock_key_queue)
+        pipeline.call('ZRANGE', read_lock_key_queue, '0', '-1', 'WITHSCORES')
       end
 
-      # @type var result: [Integer,Array[[String,Integer|Float]]]
+      # rubocop:disable Layout/LineLength
+      # @type var result: [Integer,Array[[String,Integer|Float]],Integer,Array[[String,Integer|Float]]]
+      # rubocop:enable Layout/LineLength
       exists_cmd_res = result[0]
       zrange_cmd_res = result[1]
+      read_exists_cmd_res = result[2]
+      read_zrange_cmd_res = result[3]
 
-      if exists_cmd_res == 1
+      if exists_cmd_res == 1 || read_exists_cmd_res == 1
         # NOTE: queue existed during the piepline invocation
-        {
+        # @type var queue_info: RedisQueuedLocks::Acquirer::QueueInfo::queueInfo
+        queue_info = {
           'lock_queue' => lock_key_queue,
-          'queue' => zrange_cmd_res.map { |val| { 'acq_id' => val[0], 'score' => val[1] } }
+          'queue' => zrange_cmd_res.map do |val|
+            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'write' }
+          end
         }
+        # NOTE: (RW) the queue of read lock requests
+        if read_exists_cmd_res == 1
+          queue_info['read_lock_queue'] = read_lock_key_queue
+          queue_info['read_queue'] = read_zrange_cmd_res.map do |val|
+            { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => 'read' }
+          end
+        end
+        queue_info
       else
         # NOTE: queue did not exist during the pipeline invocation
         nil
       end
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquirer/queues.rb

@@ -2,6 +2,7 @@
 
 # @api private
 # @since 1.0.0
+# @version 1.18.0
 module RedisQueuedLocks::Acquirer::Queues
   class << self
     # @param redis_client [RedisClient]
@@ -23,9 +24,11 @@ module RedisQueuedLocks::Acquirer::Queues
     # @param redis_client [RedisClient]
     # @param scan_size [Integer]
     # @return [Set<String>]
+    #   - (RW) queues of read lock requests are included;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def scan_queues(redis_client, scan_size)
       Set.new.tap do |lock_queues|
         # @type var lock_queues: Set[String]
@@ -38,21 +41,40 @@ module RedisQueuedLocks::Acquirer::Queues
           # @type var lock_queue: String
           lock_queues.add(lock_queue)
         end
+
+        # NOTE: (RW) queues of read lock requests
+        redis_client.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+          count: scan_size
+        ) do |read_lock_queue|
+          # TODO: reduce unnecessary iterations
+          # @type var read_lock_queue: String
+          lock_queues.add(read_lock_queue)
+        end
       end
     end
 
     # @param redis_client [RedisClient]
     # @param lock_queues [Set<String>]
     # @return [Set<Hash<Symbol,Any>>]
+    #   - each request: `{ 'acq_id' => String, 'score' => Float, 'rw_mode' => 'read'/'write' }`;
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
     def extract_queues_info(redis_client, lock_queues)
-      # TODO: refactor with RedisQueuedLocks::Acquier::QueueInfo
+      # NOTE: the same approach as in `QueueInfo` (duplicated on purpose: public operation modules
+      #   do not reuse each other, they share logic via `Resource`, `Utilities`);
       Set.new.tap do |seeded_queues|
         # Step X: iterate over each lock queue and extract their info
         # @type var seeded_queues: Set[Hash[Symbol,untyped]]
         lock_queues.each do |lock_queue|
+          # NOTE:
+          #   - (RW) the mode of the requests of the queue (`'read'` or `'write'`);
+          #   - lock queues are scanned by the lock queue patterns, so the mode is never `nil`;
+          rw_mode = RedisQueuedLocks::Resource.lock_queue_rw_mode(lock_queue) #: String
+
           # Step 1: extract lock queue info from reids
           queue_info = redis_client.pipelined do |pipeline|
             pipeline.call('EXISTS', lock_queue)
@@ -64,14 +86,16 @@ module RedisQueuedLocks::Acquirer::Queues
             zrange_cmd_res = result[1]
 
             if exists_cmd_res == 1 # Step 2.X: lock queue existed during the piepline invocation
-              zrange_cmd_res.map { |val| { 'acq_id' => val[0], 'score' => val[1] } }
+              zrange_cmd_res.map do |val|
+                { 'acq_id' => val[0], 'score' => val[1], 'rw_mode' => rw_mode }
+              end
             else
               # Step 2.Y: lock queue did not exist during the pipeline invocation
-              [] #: Array[Hash[String,Float]]
+              [] #: Array[Hash[String,String|Float]]
             end
           end
 
-          # @type var queue_info: Array[Hash[String,Float]]
+          # @type var queue_info: Array[Hash[String,String|Float]]
 
           # Step 3: push the lock queue info to the result store
           seeded_queues << {

data/lib/redis_queued_locks/acquirer/release_all_locks.rb

@@ -10,6 +10,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     # Release all locks:
     # - 1. clear all lock queus: drop them all from Redis database by the lock queue pattern;
     # - 2. delete all locks: drop lock keys from Redis by the lock key pattern;
+    # - 3. (RW) clear all read lock queues and drop all read locks (readers registries and data);
     #
     # @param redis [RedisClient]
     #   Redis connection client.
@@ -71,7 +72,7 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
-    # @version 1.14.0
+    # @version 1.18.0
     def release_all_locks(
       redis,
       batch_size,
@@ -129,6 +130,8 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
     #
     # @api private
     # @since 1.0.0
+    # @version 1.18.0
+    # rubocop:disable Metrics/MethodLength
     def fully_release_all_locks(redis, batch_size)
       result = redis.with do |rconn|
         rconn.pipelined do |pipeline|
@@ -151,10 +154,41 @@ module RedisQueuedLocks::Acquirer::ReleaseAllLocks
             # TODO: reduce unnecessary iterations
             pipeline.call('EXPIRE', lock_key, '0')
           end
+
+          # Step C (RW): release all read lock queues
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+            count: batch_size
+          ) do |read_lock_queue|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', read_lock_queue, '0')
+          end
+
+          # Step D (RW): release all read locks
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+            count: batch_size
+          ) do |lock_readers|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', lock_readers, '0')
+          end
+
+          # Step E (RW): release all read lock data
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::READ_LOCK_PATTERN,
+            count: batch_size
+          ) do |read_lock|
+            # TODO: reduce unnecessary iterations
+            pipeline.call('EXPIRE', read_lock, '0')
+          end
         end
       end
 
       { ok: true, result: { rel_key_cnt: result.sum } }
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/redis_queued_locks/acquirer/release_lock.rb

@@ -11,6 +11,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     # - 1. clear lock queue: al; related processes released
     #      from the lock aquierment and should retry;
     # - 2. delete the lock: drop lock key from Redis;
+    # - 3. (RW) clear the read lock queue and drop all read locks (the readers registry);
     # It is safe because the lock obtain logic is transactional and
     # watches the original lock for changes.
     #
@@ -71,7 +72,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     #
     # @api private
     # @since 1.0.0
-    # @version 1.14.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def release_lock(
       redis,
@@ -89,9 +90,15 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
     )
       lock_key = RedisQueuedLocks::Resource.prepare_lock_key(lock_name)
       lock_key_queue = RedisQueuedLocks::Resource.prepare_lock_queue(lock_name)
+      read_lock_key_queue = RedisQueuedLocks::Resource.prepare_read_lock_queue(lock_name)
+      lock_readers_key = RedisQueuedLocks::Resource.prepare_lock_readers(lock_name)
 
       rel_start_time = clock_gettime
-      fully_release_lock(redis, lock_key, lock_key_queue) => { ok:, result: } # steep:ignore
+      # steep:ignore:start
+      fully_release_lock(
+        redis, lock_name, lock_key, lock_key_queue, read_lock_key_queue, lock_readers_key
+      ) => { ok:, result: }
+      # steep:ignore:end
 
       # @type var ok: bool
       # @type var result: Hash[Symbol,Symbol]
@@ -131,36 +138,60 @@ module RedisQueuedLocks::Acquirer::ReleaseLock
 
     private
 
-    # Realease the lock: clear the lock queue and expire the lock.
+    # Realease the lock: clear the lock queues and expire the lock (write lock and read locks).
     #
     # @param redis [RedisClient]
+    # @param lock_name [String]
     # @param lock_key [String]
     # @param lock_key_queue [String]
+    # @param read_lock_key_queue [String]
+    # @param lock_readers_key [String]
     # @return [Hash<Symbol,Boolean|Hash<Symbol,Symbol>>]
     #   Format: {
     #     ok: true/false,
     #     result: {
-    #       queue: :released/:nothing_to_release,
-    #       lock: :released/:nothing_to_release
+    #       queue: :released/:nothing_to_release, # (any of the lock queues)
+    #       lock: :released/:nothing_to_release # (write lock or read locks)
     #     }
     #   }
     #
     # @api private
     # @since 1.0.0
-    def fully_release_lock(redis, lock_key, lock_key_queue)
-      # @type var result: [Integer,Integer]
+    # @version 1.18.0
+    def fully_release_lock(
+      redis,
+      lock_name,
+      lock_key,
+      lock_key_queue,
+      read_lock_key_queue,
+      lock_readers_key
+    )
+      # @type var result: [Integer,Integer,Integer,Integer]
       result = redis.with do |rconn|
+        # NOTE: (RW) data of read locks (it is a data carrier only: read locks are released via
+        #   the readers registry, so the data of concurrently obtained read locks expires itself)
+        # @type var read_lock_acquirers: Array[String]
+        read_lock_acquirers = rconn.call('ZRANGE', lock_readers_key, '0', '-1')
+
         rconn.multi do |transact|
           transact.call('ZREMRANGEBYSCORE', lock_key_queue, '-inf', '+inf')
           transact.call('EXPIRE', lock_key, '0')
+          transact.call('ZREMRANGEBYSCORE', read_lock_key_queue, '-inf', '+inf')
+          transact.call('EXPIRE', lock_readers_key, '0')
+          read_lock_acquirers.each do |acquirer_id|
+            transact.call(
+              'DEL',
+              RedisQueuedLocks::Resource.prepare_read_lock_key(lock_name, acquirer_id)
+            )
+          end
         end
       end
 
       {
         ok: true,
         result: {
-          queue: (result[0] != 0) ? :released : :nothing_to_release,
-          lock: (result[1] != 0) ? :released : :nothing_to_release
+          queue: (result[0] != 0 || result[2] != 0) ? :released : :nothing_to_release,
+          lock: (result[1] != 0 || result[3] != 0) ? :released : :nothing_to_release
         }
       }
     end

data/lib/redis_queued_locks/acquirer/release_locks_of.rb

@@ -2,12 +2,16 @@
 
 # @api private
 # @since 1.14.0
+# @version 1.18.0
+# rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::ReleaseLocksOf
   # @since 1.14.0
   extend RedisQueuedLocks::Utilities
 
+  # rubocop:disable Metrics/ClassLength
   class << self
-    # Release all queues and locks that belong to the given host and its associated acquirer.
+    # Release all queues and locks (write locks and read locks) that belong to the given host
+    # and its associated acquirer.
     #
     # @param refused_host_id [String]
     #   A host whose locks and queues should be released.
@@ -84,7 +88,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
     #
     # @api private
     # @since 1.14.0
-    # @version 1.15.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def release_locks_of(
       refused_host_id,
@@ -164,6 +168,7 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
     #
     # @api private
     # @since 1.14.0
+    # @version 1.18.0
     # rubocop:disable Metrics/MethodLength
     def fully_release_locks_of(
       refused_host_id,
@@ -203,6 +208,30 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
           rel_key_cnt += refused_locks.size
         end
 
+        # Step A (RW): drop read locks of the passed host/acquirer
+        #   - read locks store acquirer ids only (the host is a part of the acquirer id);
+        if RedisQueuedLocks::Resource.host_identifier_from_acquirer(refused_acquirer_id) ==
+           refused_host_id
+          rconn.scan(
+            'MATCH',
+            RedisQueuedLocks::Resource::LOCK_READERS_PATTERN,
+            count: lock_scan_size
+          ) do |lock_readers_key|
+            res = rconn.call('ZREM', lock_readers_key, refused_acquirer_id)
+            next if res == 0
+
+            rel_key_cnt += 1
+            # NOTE: drop the read lock data
+            rconn.call(
+              'DEL',
+              RedisQueuedLocks::Resource.prepare_read_lock_key(
+                RedisQueuedLocks::Resource.lock_name_from_readers(lock_readers_key),
+                refused_acquirer_id
+              )
+            )
+          end
+        end
+
         # Step B: drop passed host/acquirer from lock queues
         rconn.scan(
           'MATCH',
@@ -212,10 +241,21 @@ module RedisQueuedLocks::Acquirer::ReleaseLocksOf
           res = rconn.call('ZREM', lock_queue, refused_acquirer_id)
           tch_queue_cnt += 1 if res != 0
         end
+
+        # Step B (RW): drop passed host/acquirer from read lock queues
+        rconn.scan(
+          'MATCH',
+          RedisQueuedLocks::Resource::READ_LOCK_QUEUE_PATTERN,
+          count: queue_scan_size
+        ) do |read_lock_queue|
+          res = rconn.call('ZREM', read_lock_queue, refused_acquirer_id)
+          tch_queue_cnt += 1 if res != 0
+        end
       end
 
       { ok: true, result: { rel_key_cnt:, tch_queue_cnt: } }
     end
   end
-  # rubocop:enable Metrics/MethodLength
+  # rubocop:enable Metrics/MethodLength, Metrics/ClassLength
 end
+# rubocop:enable Metrics/ModuleLength