redis_queued_locks 1.21.0 → 1.23.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Read/Write locks (`read_write_mode`):
+# Read/Write locks (`rw_mode`):
 #   - `:write` lock is exclusive: it is obtained when there is no write lock and no live read lock;
 #   - `:read` lock is shared: it is obtained when there is no write lock;
 #   - read locks are stored in the readers registry: a sorted set where the member is an acquirer
@@ -19,8 +19,9 @@
 #     - write lock request should be the first in the write lock queue (the classic lock queue)
 #       and should wait for all earlier read lock requests;
 #     - read lock request should wait for all earlier write lock requests;
-#   - `:random` access strategy ignores both queues (no ordering between modes, so
-#     a continuous flow of readers can starve writers);
+#   - `:random` access strategy ignores the order of both queues (no ordering between modes, so
+#     a continuous flow of readers can starve writers); its own lock request is queued like any
+#     lock request (`:queued` lock requests wait for it);
 #
 # Lock index (`RedisQueuedLocks::Resource::LOCK_INDEX_KEY`): only with the enabled lock index
 # (`lock_index_enabled`, `config['lock_index_enabled']`); with the disabled lock index (default)
@@ -37,9 +38,21 @@
 #   - each queueing drops the expired lock names from the index (`ZREMRANGEBYSCORE`): the index
 #     is maintained by the lock acquirement itself (no background jobs);
 #
+# Lock request priorities (`priority`, see `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`):
+#   - the position of the lock request (the score) is the enqueue time shifted by the priority
+#     band: requests of a higher priority are ahead of the requests of a lower priority in both
+#     queues (FIFO inside the same priority), so the queue heads and the order between modes
+#     (`find_opposite_request_ahead`) work with the positions as is;
+#   - dead lock requests are dropped per priority band (each band has its own time barrier):
+#     the band of the current request before the request is queued and the queue heads are read
+#     (both queues); a dead request of another band is dropped when it blocks the current request
+#     (the queue head or the earlier request of the opposite mode): its band and its enqueue time
+#     are decoded from its position, so the cost of an attempt does not depend on the number of
+#     priorities (see `drop_dead_requests_ahead`);
+#
 # @api private
 # @since 1.0.0
-# @version 1.20.0
+# @version 1.23.0
 # rubocop:disable Metrics/ModuleLength
 module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   require_relative 'try_to_lock/log_visitor'
@@ -101,8 +114,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @since 1.20.0
   LOCK_STATE_QUEUE_REPLIES_AT = 3
 
-  # Position of the first request of the request queue (`ZRANGE`) in the replies of the lock
-  # request queueing commands (`queue_lock_request`), relative to their first reply.
+  # Position of the first request of the request queue (`ZRANGE WITHSCORES`) in the replies of
+  # the lock request queueing commands (`queue_lock_request`), relative to their first reply.
   #
   # @return [Integer]
   #
@@ -120,11 +133,49 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @since 1.20.0
   OPPOSITE_QUEUE_HEAD_REPLY = 4
 
+  # The number of the replies of the lock request queueing commands (`queue_lock_request`) with
+  # the disabled lock index.
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.23.0
+  QUEUE_REPLIES = 5
+
+  # The number of the replies of the lock index commands of the lock request queueing
+  # (`queue_lock_request`, the enabled lock index only).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.23.0
+  QUEUE_LOCK_INDEX_REPLIES = 4
+
+  # The number of the commands of the read lock extension (`transact_read_lock_extension`) without
+  # the lock index command (the enabled lock index only: the last command).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.23.0
+  READ_LOCK_EXTENSION_COMMANDS = 8
+
+  # The maximum number of the round trips of one call of `drop_dead_requests_ahead` (the attempt or
+  # its pre-check; each round trip drops the dead blocking requests, the head of the write lock
+  # queue and the earlier request of the opposite mode, with the dead requests of their priority
+  # bands): the attempt fails when more dead lock requests block it (the next attempts drop them).
+  #
+  # @return [Integer]
+  #
+  # @api private
+  # @since 1.22.0
+  MAX_DEAD_REQUEST_REMOVALS = 5
+
   # @param redis [RedisClient]
   # @param logger [::Logger,#debug]
   # @param log_lock_try [Boolean]
   # @param lock_key [String]
-  # @param read_write_mode [Symbol] `:read` or `:write`
+  # @param rw_mode [Symbol] `:read` or `:write`
   # @param lock_key_queue [String] Queue of write lock requests.
   # @param read_lock_key_queue [String] Queue of read lock requests.
   # @param lock_readers_key [String] Registry of read lock holders.
@@ -135,6 +186,9 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @param acquirer_id [String]
   # @param host_id [String]
   # @param acquirer_position [Numeric]
+  #   The position of the lock request (the score: the enqueue time shifted by the priority band).
+  # @param priority [Integer]
+  #   The lock request priority (the band of `acquirer_position`).
   # @param ttl [Integer]
   # @param queue_ttl [Integer]
   # @param lock_index_enabled [Boolean]
@@ -154,14 +208,14 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   #
   # @api private
   # @since 1.0.0
-  # @version 1.21.0
+  # @version 1.22.0
   # rubocop:disable Metrics/MethodLength
   def try_to_lock(
     redis,
     logger,
     log_lock_try,
     lock_key,
-    read_write_mode,
+    rw_mode,
     lock_key_queue,
     read_lock_key_queue,
     lock_readers_key,
@@ -170,6 +224,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     acquirer_id,
     host_id,
     acquirer_position,
+    priority,
     ttl,
     queue_ttl,
     lock_index_enabled,
@@ -192,9 +247,9 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     # Step RW: the mode of the lock that is really held by the acquirer after the attempt
     #   (the requested mode or the mode of the already obtained lock for same-process conflicts);
     # @type var held_rw_mode: Symbol
-    held_rw_mode = read_write_mode
+    held_rw_mode = rw_mode
     # Step RW: read lock request flag
-    read_mode = (read_write_mode == :read)
+    read_mode = (rw_mode == :read)
     # Step RW: request queue of the current mode and the queue of the opposite mode
     request_queue = read_mode ? read_lock_key_queue : lock_key_queue
     opposite_request_queue = read_mode ? lock_key_queue : read_lock_key_queue
@@ -215,14 +270,14 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
 
     LogVisitor.start(
       logger, log_sampled, log_lock_try, lock_key,
-      queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+      queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
     )
 
     # Step X: start to work with lock acquiring
     result = redis.with do |rconn|
       LogVisitor.rconn_fetched(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
       )
 
       # Step PRE: (pre-check) the lock state without WATCH: the attempt that can not obtain
@@ -232,9 +287,9 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
       #   - see `precheck_lock` for details;
       if precheck
         inter_result = precheck_lock(
-          rconn, logger, log_sampled, log_lock_try, lock_key, read_write_mode, lock_readers_key,
+          rconn, logger, log_sampled, log_lock_try, lock_key, rw_mode, lock_readers_key,
           request_queue, opposite_request_queue, lock_name, acquirer_id, host_id,
-          acquirer_position, acquirer_dead_score, queue_ttl, lock_index_enabled,
+          acquirer_position, priority, acquirer_dead_score, queue_ttl, lock_index_enabled,
           lock_index_grace_period, fail_fast, access_strategy
         )
         next if inter_result
@@ -255,14 +310,14 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
         #   - read lock expiration of the current acquirer;
         #   - the longest read lock (the last one in the readers registry): write lock requests
         #     only (read lock requests do not wait for other readers);
-        #   - (eager queueing) the lock request queueing: Steps 1, 2.1, 3 (`queue_lock_request`);
+        #   - (eager queueing) the lock request queueing: Steps 2.1, 1, 3 (`queue_lock_request`);
         # NOTE: replies are read by their positions: see "pipeline layout" in `pipeline_lock_state`
         # @type var lock_state: Array[untyped]
         lock_state = rconn.pipelined do |pipeline|
           pipeline_lock_state(
             pipeline, lock_key, lock_readers_key, acquirer_id, read_mode, eager_queueing,
-            request_queue, opposite_request_queue, acquirer_position, acquirer_dead_score,
-            lock_name, queue_ttl, lock_index_enabled, lock_index_grace_period
+            request_queue, opposite_request_queue, acquirer_position, priority,
+            acquirer_dead_score, lock_name, queue_ttl, lock_index_enabled, lock_index_grace_period
           )
         end
         # @type var current_lock_obtainer: String?
@@ -296,7 +351,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
         if sp_conflict_rw_mode != nil
           LogVisitor.same_process_conflict_detected(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
           )
 
           # NOTE:
@@ -306,30 +361,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
 
           # SP-Conflict Step X2: self-process dead lock moment started.
           # SP-Conflict CHECK (Step CHECK): check chosen strategy and flag the current status
-          case conflict_strategy
-          when :work_through
-            # <SP-Conflict Moment>: work through => exit
-            sp_conflict_status = lock_upgrade ? :conflict_lock_upgrade : :conflict_work_through
-          when :extendable_work_through
-            # <SP-Conflict Moment>: extendable_work_through => extend the lock pttl and exit
-            sp_conflict_status =
-              lock_upgrade ? :conflict_lock_upgrade : :extendable_conflict_work_through
-          when :wait_for_lock
-            # <SP-Conflict Moment>: wait_for_lock => obtain a lock in classic way
-            sp_conflict_status = :conflict_wait_for_lock
-          when :dead_locking
-            # <SP-Conflict Moment>: dead_locking => exit and fail
-            sp_conflict_status = :conflict_dead_lock
-          else
-            # <SP-Conflict Moment>:
-            #   - unknown status => work in classic way <wait_for_lock>
-            #   - it is a case when the new status is added to the code base in the past
-            #     but is forgotten to be added here;
-            sp_conflict_status = :conflict_wait_for_lock
-          end
+          sp_conflict_status = same_process_conflict_status(conflict_strategy, lock_upgrade)
           LogVisitor.same_process_conflict_analyzed(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode, sp_conflict_status
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, sp_conflict_status
           )
         end
 
@@ -338,71 +373,17 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
           # SP-Conflict-Step FINAL (SPCF): extend the lock and work through
           #   - extend the lock ttl;
           #   - store extensions in lock metadata;
+          spc_processed_timestamp = Time.now.to_f
           if sp_conflict_rw_mode == :write
             held_rw_mode = :write
-
-            # SPCF Step 1: extend the lock pttl
-            #   - [REDIS RESULT]: in normal cases should return the last script command value
-            #     - for the current script should return:
-            #       <1> => timeout was set;
-            #       <0> => timeount was not set;
-            transact.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, ttl)
-            # SPCF Step <Meta>: store conflict-state additionals in lock metadata:
-            # SPCF Step 2: (lock meta-data)
-            #   - add the added ttl to reflect the real lock TTL in info;
-            #   - [REDIS RESULT]: in normal cases should return the value of <ttl> key
-            #     - for non-existent key value starts from <0> (zero)
-            transact.call('HINCRBY', lock_key, 'spc_ext_ttl', ttl)
-            # SPCF Step 3: (lock meta-data)
-            #   - increment the conflcit counter in order to remember
-            #     how many times dead lock happened;
-            #   - [REDIS RESULT]: in normal cases should return the value of <spc_cnt> key
-            #     - for non-existent key starts from 0
-            transact.call('HINCRBY', lock_key, 'spc_cnt', 1)
-            # SPCF Step 4: (lock meta-data)
-            #   - remember the last ext-timestamp and the last ext-initial ttl;
-            #   - [REDIS RESULT]: for normal cases should return the number of fields
-            #     were added/changed;
-            transact.call(
-              'HSET',
-              lock_key,
-              'l_spc_ext_ts', spc_processed_timestamp = Time.now.to_f,
-              'l_spc_ext_ini_ttl', ttl
+            transact_write_lock_extension(
+              transact, lock_key, lock_name, ttl, lock_index_enabled, spc_processed_timestamp
             )
           else
             held_rw_mode = :read
-            # SPCF Step 1 (read lock): extend the read lock of the current acquirer
-            #   - [REDIS RESULT]: the new read lock expiration time
-            #     (or nil if the read lock has been removed from the registry);
-            transact.call('ZADD', lock_readers_key, 'XX', 'INCR', ttl, acquirer_id)
-            # SPCF Step 2 (read lock): the registry should live as long as the longest read lock
-            #   - NX + GT => sets the registry TTL to max(current TTL, extended read lock TTL);
-            extended_read_lock_ttl = (own_read_lock_expiration.to_f + ttl.to_i - redis_time).ceil
-            transact.call('PEXPIRE', lock_readers_key, extended_read_lock_ttl, 'NX')
-            transact.call('PEXPIRE', lock_readers_key, extended_read_lock_ttl, 'GT')
-            # SPCF Step 3 (read lock data): the same reentrant lock data as for the write lock
-            transact.call('HINCRBY', read_lock_key, 'spc_ext_ttl', ttl)
-            transact.call('HINCRBY', read_lock_key, 'spc_cnt', 1)
-            transact.call(
-              'HSET',
-              read_lock_key,
-              'l_spc_ext_ts', spc_processed_timestamp = Time.now.to_f,
-              'l_spc_ext_ini_ttl', ttl
-            )
-            # SPCF Step 4 (read lock data): the read lock data lives as long as the read lock
-            transact.call('PEXPIRE', read_lock_key, extended_read_lock_ttl, 'NX')
-            transact.call('PEXPIRE', read_lock_key, extended_read_lock_ttl, 'GT')
-          end
-          # SPCF Step 5: (lock index) the lock (write or read) lives longer by the extension:
-          #   - the lock index score is increased by the extension (the upper bound of the lock
-          #     lifetime stays the upper bound);
-          #   - XX => locks without the index entry (of older RQL versions) are not indexed with
-          #     a wrong score (see `reindex_locks`);
-          #   - [REDIS RESULT]: the new lock index score (nil for the lock without the index entry);
-          #   - only with the enabled lock index (the last command of the transaction);
-          if lock_index_enabled
-            transact.call(
-              'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'XX', 'INCR', ttl, lock_name
+            transact_read_lock_extension(
+              transact, lock_readers_key, read_lock_key, lock_name, acquirer_id, ttl,
+              lock_index_enabled, own_read_lock_expiration, redis_time, spc_processed_timestamp
             )
           end
           inter_result = :extendable_conflict_work_through
@@ -410,53 +391,29 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
           # @type var spc_processed_timestamp: Float
           LogVisitor.reentrant_lock__extend_and_work_through(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
             sp_conflict_status, ttl, spc_processed_timestamp
           )
         # SP-Conflict-Step X2: switch to dead lock logic or not
         elsif sp_conflict_status == :conflict_work_through
           inter_result = :conflict_work_through
 
+          spc_processed_timestamp = Time.now.to_f
+
           if sp_conflict_rw_mode == :write
             held_rw_mode = :write
-
-            # SPCF Step X: (lock meta-data)
-            #   - increment the conflcit counter in order to remember
-            #     how many times dead lock happened;
-            #   - [REDIS RESULT]: in normal cases should return the value of <spc_cnt> key
-            #     - for non-existent key starts from 0
-            transact.call('HINCRBY', lock_key, 'spc_cnt', 1)
-            # SPCF Step 4: (lock meta-data)
-            #   - remember the last ext-timestamp and the last ext-initial ttl;
-            #   - [REDIS RESULT]: for normal cases should return the number of fields
-            #     were added/changed;
-            transact.call(
-              'HSET',
-              lock_key,
-              'l_spc_ts', spc_processed_timestamp = Time.now.to_f
-            )
+            transact_write_lock_work_through(transact, lock_key, spc_processed_timestamp)
           else
             held_rw_mode = :read
-
-            # SPCF Step X (read lock data): the same reentrant lock data as for the write lock
-            transact.call('HINCRBY', read_lock_key, 'spc_cnt', 1)
-            transact.call(
-              'HSET', read_lock_key, 'l_spc_ts', spc_processed_timestamp = Time.now.to_f
-            )
-            # SPCF Step X (read lock data): (NX) the read lock data should not outlive the read lock
-            #   (it is the case when the read lock data is dropped during the read lock life);
-            transact.call(
-              'PEXPIRE',
-              read_lock_key,
-              (own_read_lock_expiration.to_f - redis_time).ceil,
-              'NX'
+            transact_read_lock_work_through(
+              transact, read_lock_key, own_read_lock_expiration, redis_time, spc_processed_timestamp
             )
           end
 
           # @type var spc_processed_timestamp: Float
           LogVisitor.reentrant_lock__work_through(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
             sp_conflict_status, spc_processed_timestamp
           )
         # SP-Conflict-Step X2: switch to dead lock logic or not
@@ -467,7 +424,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
           # @type var spc_processed_timestamp: Float
           LogVisitor.single_process_lock_conflict__dead_lock(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
             sp_conflict_status, spc_processed_timestamp
           )
         # SP-Conflict-Step X2 (RW): read-to-write lock upgrade is not supported => exit and fail
@@ -478,7 +435,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
           # @type var spc_processed_timestamp: Float
           LogVisitor.single_process_lock_conflict__lock_upgrade(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
             sp_conflict_status, spc_processed_timestamp
           )
         # Reached the SP-Non-Conflict Mode (NOTE):
@@ -493,11 +450,12 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
           # Fast-Step X1: lock is already obtained. fail fast leads to "no try".
           inter_result = :fail_fast_no_try
         else
-          # Step 1: add an acquirer to the lock acquirement queue
           # Step 2.1: drop expired acquirers from the lock queues
+          # Step 1: add an acquirer to the lock acquirement queue
           # Step 3: get the actual acquirer waiting in the queue
           #   - one round trip for all of them (see `queue_lock_request`);
           #   - eager queueing: already done in the lock state round trip (Step 0.1);
+          #   - Step 2.2 (priorities) runs after them (see below);
           # @type var queue_replies: Array[untyped]
           queue_replies =
             if eager_queueing
@@ -506,30 +464,51 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
               rconn.pipelined do |pipeline|
                 queue_lock_request(
                   pipeline, request_queue, opposite_request_queue,
-                  acquirer_position, acquirer_id, acquirer_dead_score,
+                  acquirer_position, priority, acquirer_id, acquirer_dead_score,
                   lock_name, queue_ttl, lock_index_enabled, lock_index_grace_period
                 )
               end
             end
           # NOTE: the position of the first queueing reply (see "pipeline layout" in Step 0.1)
           queue_replies_at = eager_queueing ? LOCK_STATE_QUEUE_REPLIES_AT : 0
-          # @type var waiting_acquirer: String?
-          waiting_acquirer = queue_replies[queue_replies_at + QUEUE_HEAD_REPLY].first
+          # @type var waiting_request: [String, Float]?
+          waiting_request = queue_replies[queue_replies_at + QUEUE_HEAD_REPLY].first
           # @type var opposite_waiting_request: [String, Float]?
           opposite_waiting_request =
             queue_replies[queue_replies_at + OPPOSITE_QUEUE_HEAD_REPLY].first
 
           LogVisitor.acq_added_to_queue(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, priority
           )
           LogVisitor.remove_expired_acqs(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
+          )
+
+          # Step 2.2: (priorities) drop the dead lock requests of other priority bands that block
+          #   the current one (the queue head or the earlier request of the opposite mode) and get
+          #   the actual queue heads (no round trips while no dead request blocks the current one);
+          actual_queue_heads = drop_dead_requests_ahead(
+            rconn, rw_mode, request_queue, opposite_request_queue, acquirer_id,
+            acquirer_position, acquirer_dead_score, access_strategy, waiting_request,
+            opposite_waiting_request
           )
+          if actual_queue_heads
+            waiting_request, opposite_waiting_request, dropped_requests = actual_queue_heads
+            log_dropped_requests(
+              logger, log_sampled, log_lock_try, lock_key, queue_ttl, acquirer_id, host_id,
+              access_strategy, rw_mode, dropped_requests
+            )
+          end
+          waiting_acquirer = waiting_request ? waiting_request[0] : nil
+          # NOTE: the priority of the first request is decoded for logs only
+          waiting_priority = logged_request_priority(log_sampled, log_lock_try, waiting_request)
+
           LogVisitor.get_first_from_queue(
             logger, log_sampled, log_lock_try, lock_key,
-            queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode, waiting_acquirer
+            queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, waiting_acquirer,
+            waiting_priority
           )
 
           # Step 3.1 (RW) + Steps PRE-4.x, ROLLBACK 1.1, 1.2, 2, 3: the obstacle to the lock
@@ -548,102 +527,43 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
             # Step ROLLBACK: the lock can not be obtained now. retry!
             log_lock_obstacle(
               rconn, obstacle, logger, log_sampled, log_lock_try, lock_key, queue_ttl,
-              acquirer_id, host_id, access_strategy, read_write_mode,
-              waiting_acquirer, opposite_request_ahead, current_lock_obtainer
+              acquirer_id, host_id, access_strategy, rw_mode,
+              waiting_acquirer, waiting_priority, opposite_waiting_request, current_lock_obtainer
             )
             inter_result = obstacle
           elsif read_mode
             # NOTE: required lock is free and ready to be acquired! acquire! (read lock)
 
-            # Step 6.1: remove our acquirer from waiting queue
-            transact.call('ZREM', request_queue, acquirer_id)
-
-            # Step 6.2 (RW): drop expired read locks from the readers registry
-            transact.call('ZREMRANGEBYSCORE', lock_readers_key, '-inf', "(#{redis_time}")
-
-            # Step 6.3 (RW): register the read lock (expiration time in redis time)
-            transact.call('ZADD', lock_readers_key, redis_time + ttl.to_i, acquirer_id)
-
-            # Step 6.4 (RW): the registry should live as long as the longest read lock
-            #   - NX + GT => sets the registry TTL to max(current TTL, read lock TTL);
-            #   - in order to prevent "infinite registries" after process crashes;
-            transact.call('PEXPIRE', lock_readers_key, ttl, 'NX')
-            transact.call('PEXPIRE', lock_readers_key, ttl, 'GT')
-
-            # Step 6.5 (RW): store the read lock data (the same structure as the write lock data
-            #   without `acq_id`/`hst_id`: both are derived from the read lock acquirer id that is
-            #   a part of the data key and the registry member, so the info adds them on formatting)
-            #   - drop the data of the expired read lock of the current acquirer (if any);
-            #   - the read lock data lives as long as the read lock;
-            transact.call('DEL', read_lock_key)
-            transact.call(
-              'HSET',
-              read_lock_key,
-              'ts', timestamp = Time.now.to_f,
-              'ini_ttl', ttl,
-              *(meta.to_a if meta != nil) # steep:ignore
+            # Steps 6.1-6.6 (RW): see `transact_read_lock_obtaining`
+            timestamp = Time.now.to_f
+            # @type var timestamp: Float
+            transact_read_lock_obtaining(
+              transact, request_queue, lock_readers_key, read_lock_key, lock_name, acquirer_id, ttl,
+              lock_index_enabled, lock_index_grace_period, meta, redis_time, timestamp
             )
-            transact.call('PEXPIRE', read_lock_key, ttl)
-
-            # Step 6.6 (lock index): the lock name lives in the lock index as long as the read lock
-            #   (the upper bound of the read lock lifetime: client time + ttl + grace period);
-            #   - in the same transaction: an index entry dropped between the queueing and this
-            #     transaction (`#unlock`, `#clear_locks`) is restored with the read lock;
-            #   - GT => the score is never decreased (other keys of the lock can live longer);
-            #   - only with the enabled lock index (the last command of the transaction);
-            if lock_index_enabled
-              transact.call(
-                'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'GT',
-                RedisQueuedLocks::Resource.lock_index_time + ttl.to_i + lock_index_grace_period,
-                lock_name
-              )
-            end
 
             inter_result = :lock_obtaining
 
             LogVisitor.obtain__free_to_acquire(
               logger, log_sampled, log_lock_try, lock_key,
-              queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+              queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
             )
           else
             # NOTE: required lock is free and ready to be acquired! acquire! (write lock)
 
-            # Step 6.1: remove our acquirer from waiting queue
-            transact.call('ZREM', request_queue, acquirer_id)
-
-            # Step 6.2: acquire a lock and store an info about the acquirer and host
-            transact.call(
-              'HSET',
-              lock_key,
-              'acq_id', acquirer_id,
-              'hst_id', host_id,
-              'ts', timestamp = Time.now.to_f,
-              'ini_ttl', ttl,
-              *(meta.to_a if meta != nil) # steep:ignore
+            # Steps 6.1-6.4: see `transact_write_lock_obtaining`
+            timestamp = Time.now.to_f
+            # @type var timestamp: Float
+            transact_write_lock_obtaining(
+              transact, lock_key, request_queue, lock_name, acquirer_id, host_id, ttl,
+              lock_index_enabled, lock_index_grace_period, meta, timestamp
             )
 
-            # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
-            transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
-
-            # Step 6.4 (lock index): the lock name lives in the lock index as long as the lock
-            #   (the upper bound of the lock lifetime: client time + ttl + grace period);
-            #   - in the same transaction: an index entry dropped between the queueing and this
-            #     transaction (`#unlock`, `#clear_locks`) is restored with the lock;
-            #   - GT => the score is never decreased (other keys of the lock can live longer);
-            #   - only with the enabled lock index (the last command of the transaction);
-            if lock_index_enabled
-              transact.call(
-                'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'GT',
-                RedisQueuedLocks::Resource.lock_index_time + ttl.to_i + lock_index_grace_period,
-                lock_name
-              )
-            end
-
             inter_result = :lock_obtaining
 
             LogVisitor.obtain__free_to_acquire(
               logger, log_sampled, log_lock_try, lock_key,
-              queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+              queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
             )
           end
         end
@@ -829,24 +749,395 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
 
   private
 
-  # Queues the lock request and reads the lock queue state (Steps 1, 2.1, 3 and 3.2-3.4 of
+  # (SP-Conflict) The status of the conflict of the lock request with the lock that is already
+  # obtained by the current acquirer (Step CHECK of the attempt).
+  #
+  # @param conflict_strategy [Symbol]
+  # @param lock_upgrade [Boolean]
+  #   The conflict is a read-to-write lock upgrade: it can not "work through" (the read lock is not
+  #   exclusive, so the "work through" logic will work without an exclusive lock).
+  # @return [Symbol]
+  #
+  # @api private
+  # @since 1.23.0
+  def same_process_conflict_status(conflict_strategy, lock_upgrade)
+    case conflict_strategy
+    when :work_through
+      # <SP-Conflict Moment>: work through => exit
+      lock_upgrade ? :conflict_lock_upgrade : :conflict_work_through
+    when :extendable_work_through
+      # <SP-Conflict Moment>: extendable_work_through => extend the lock pttl and exit
+      lock_upgrade ? :conflict_lock_upgrade : :extendable_conflict_work_through
+    when :dead_locking
+      # <SP-Conflict Moment>: dead_locking => exit and fail
+      :conflict_dead_lock
+    else
+      # <SP-Conflict Moment>: wait_for_lock => obtain a lock in classic way
+      #   - unknown status => work in classic way <wait_for_lock>
+      #   - it is a case when the new status is added to the code base in the past
+      #     but is forgotten to be added here;
+      :conflict_wait_for_lock
+    end
+  end
+
+  # (SP-Conflict) Adds the commands of the write lock extension (reentrant
+  # `:extendable_work_through`) to the given transaction.
+  #
+  # NOTE: (transaction layout) 4 commands (5 with the enabled lock index): EVAL, HINCRBY, HINCRBY,
+  #   HSET (+ ZADD XX INCR); the replies are read by the attempt (`try_to_lock` Step 7);
+  #
+  # @param transact [RedisClient::Multi]
+  # @param lock_key [String]
+  # @param lock_name [String] The lock name (the member of the lock index).
+  # @param ttl [Integer] The extension (in milliseconds).
+  # @param lock_index_enabled [Boolean]
+  # @param spc_processed_timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_write_lock_extension(
+    transact,
+    lock_key,
+    lock_name,
+    ttl,
+    lock_index_enabled,
+    spc_processed_timestamp
+  )
+    # SPCF Step 1: extend the lock pttl
+    #   - [REDIS RESULT]: in normal cases should return the last script command value
+    #     - for the current script should return:
+    #       <1> => timeout was set;
+    #       <0> => timeount was not set;
+    transact.call('EVAL', EXTEND_LOCK_PTTL, 1, lock_key, ttl)
+    # SPCF Step <Meta>: store conflict-state additionals in lock metadata:
+    # SPCF Step 2: (lock meta-data)
+    #   - add the added ttl to reflect the real lock TTL in info;
+    #   - [REDIS RESULT]: in normal cases should return the value of <ttl> key
+    #     - for non-existent key value starts from <0> (zero)
+    transact.call('HINCRBY', lock_key, 'spc_ext_ttl', ttl)
+    # SPCF Step 3: (lock meta-data)
+    #   - increment the conflcit counter in order to remember
+    #     how many times dead lock happened;
+    #   - [REDIS RESULT]: in normal cases should return the value of <spc_cnt> key
+    #     - for non-existent key starts from 0
+    transact.call('HINCRBY', lock_key, 'spc_cnt', 1)
+    # SPCF Step 4: (lock meta-data)
+    #   - remember the last ext-timestamp and the last ext-initial ttl;
+    #   - [REDIS RESULT]: for normal cases should return the number of fields
+    #     were added/changed;
+    transact.call(
+      'HSET',
+      lock_key,
+      'l_spc_ext_ts', spc_processed_timestamp,
+      'l_spc_ext_ini_ttl', ttl
+    )
+    # SPCF Step 5: (lock index), see `transact_lock_index_extension`
+    transact_lock_index_extension(transact, lock_name, ttl, lock_index_enabled)
+  end
+
+  # (SP-Conflict) Adds the commands of the read lock extension (reentrant
+  # `:extendable_work_through`) to the given transaction.
+  #
+  # NOTE: (transaction layout) `READ_LOCK_EXTENSION_COMMANDS` commands (+ one command with
+  #   the enabled lock index): ZADD XX INCR is the first one (its `nil` reply = the read lock is
+  #   expired and removed from the registry during the extension);
+  #
+  # @param transact [RedisClient::Multi]
+  # @param lock_readers_key [String]
+  # @param read_lock_key [String,NilClass]
+  # @param lock_name [String] The lock name (the member of the lock index).
+  # @param acquirer_id [String]
+  # @param ttl [Integer,NilClass] The extension (in milliseconds).
+  # @param lock_index_enabled [Boolean]
+  # @param own_read_lock_expiration [Float,NilClass]
+  # @param redis_time [Integer] Redis server time (in milliseconds).
+  # @param spc_processed_timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_read_lock_extension(
+    transact,
+    lock_readers_key,
+    read_lock_key,
+    lock_name,
+    acquirer_id,
+    ttl,
+    lock_index_enabled,
+    own_read_lock_expiration,
+    redis_time,
+    spc_processed_timestamp
+  )
+    # SPCF Step 1 (read lock): extend the read lock of the current acquirer
+    #   - [REDIS RESULT]: the new read lock expiration time
+    #     (or nil if the read lock has been removed from the registry);
+    transact.call('ZADD', lock_readers_key, 'XX', 'INCR', ttl, acquirer_id)
+    # SPCF Step 2 (read lock): the registry should live as long as the longest read lock
+    #   - NX + GT => sets the registry TTL to max(current TTL, extended read lock TTL);
+    extended_read_lock_ttl = (own_read_lock_expiration.to_f + ttl.to_i - redis_time).ceil
+    transact.call('PEXPIRE', lock_readers_key, extended_read_lock_ttl, 'NX')
+    transact.call('PEXPIRE', lock_readers_key, extended_read_lock_ttl, 'GT')
+    # SPCF Step 3 (read lock data): the same reentrant lock data as for the write lock
+    transact.call('HINCRBY', read_lock_key, 'spc_ext_ttl', ttl)
+    transact.call('HINCRBY', read_lock_key, 'spc_cnt', 1)
+    transact.call(
+      'HSET',
+      read_lock_key,
+      'l_spc_ext_ts', spc_processed_timestamp,
+      'l_spc_ext_ini_ttl', ttl
+    )
+    # SPCF Step 4 (read lock data): the read lock data lives as long as the read lock
+    transact.call('PEXPIRE', read_lock_key, extended_read_lock_ttl, 'NX')
+    transact.call('PEXPIRE', read_lock_key, extended_read_lock_ttl, 'GT')
+    # SPCF Step 5: (lock index), see `transact_lock_index_extension`
+    transact_lock_index_extension(transact, lock_name, ttl, lock_index_enabled)
+  end
+
+  # (SP-Conflict) (lock index) The lock (write or read) lives longer by the extension:
+  #   - the lock index score is increased by the extension (the upper bound of the lock
+  #     lifetime stays the upper bound);
+  #   - XX => locks without the index entry (of older RQL versions) are not indexed with
+  #     a wrong score (see `reindex_locks`);
+  #   - [REDIS RESULT]: the new lock index score (nil for the lock without the index entry);
+  #   - only with the enabled lock index (the last command of the transaction);
+  #
+  # @param transact [RedisClient::Multi]
+  # @param lock_name [String]
+  # @param ttl [Integer,NilClass] The extension (in milliseconds).
+  # @param lock_index_enabled [Boolean]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_lock_index_extension(transact, lock_name, ttl, lock_index_enabled)
+    return unless lock_index_enabled
+
+    transact.call(
+      'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'XX', 'INCR', ttl, lock_name
+    )
+  end
+
+  # (SP-Conflict) Adds the commands of the write lock "work through" (reentrant `:work_through`)
+  # to the given transaction: the reentrant lock data only.
+  #
+  # @param transact [RedisClient::Multi]
+  # @param lock_key [String]
+  # @param spc_processed_timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_write_lock_work_through(transact, lock_key, spc_processed_timestamp)
+    # SPCF Step X: (lock meta-data)
+    #   - increment the conflcit counter in order to remember
+    #     how many times dead lock happened;
+    #   - [REDIS RESULT]: in normal cases should return the value of <spc_cnt> key
+    #     - for non-existent key starts from 0
+    transact.call('HINCRBY', lock_key, 'spc_cnt', 1)
+    # SPCF Step 4: (lock meta-data)
+    #   - remember the last ext-timestamp and the last ext-initial ttl;
+    #   - [REDIS RESULT]: for normal cases should return the number of fields
+    #     were added/changed;
+    transact.call(
+      'HSET',
+      lock_key,
+      'l_spc_ts', spc_processed_timestamp
+    )
+  end
+
+  # (SP-Conflict) Adds the commands of the read lock "work through" (reentrant `:work_through`)
+  # to the given transaction: the reentrant lock data only.
+  #
+  # @param transact [RedisClient::Multi]
+  # @param read_lock_key [String,NilClass]
+  # @param own_read_lock_expiration [Float,NilClass]
+  # @param redis_time [Integer] Redis server time (in milliseconds).
+  # @param spc_processed_timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_read_lock_work_through(
+    transact,
+    read_lock_key,
+    own_read_lock_expiration,
+    redis_time,
+    spc_processed_timestamp
+  )
+    # SPCF Step X (read lock data): the same reentrant lock data as for the write lock
+    transact.call('HINCRBY', read_lock_key, 'spc_cnt', 1)
+    transact.call('HSET', read_lock_key, 'l_spc_ts', spc_processed_timestamp)
+    # SPCF Step X (read lock data): (NX) the read lock data should not outlive the read lock
+    #   (it is the case when the read lock data is dropped during the read lock life);
+    transact.call(
+      'PEXPIRE',
+      read_lock_key,
+      (own_read_lock_expiration.to_f - redis_time).ceil,
+      'NX'
+    )
+  end
+
+  # Adds the commands of the read lock obtaining to the given transaction.
+  #
+  # @param transact [RedisClient::Multi]
+  # @param request_queue [String]
+  # @param lock_readers_key [String]
+  # @param read_lock_key [String,NilClass]
+  # @param lock_name [String] The lock name (the member of the lock index).
+  # @param acquirer_id [String]
+  # @param ttl [Integer,NilClass]
+  # @param lock_index_enabled [Boolean]
+  # @param lock_index_grace_period [Integer] In milliseconds.
+  # @param meta [NilClass,Hash<String|Symbol,Any>]
+  # @param redis_time [Integer] Redis server time (in milliseconds).
+  # @param timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_read_lock_obtaining(
+    transact,
+    request_queue,
+    lock_readers_key,
+    read_lock_key,
+    lock_name,
+    acquirer_id,
+    ttl,
+    lock_index_enabled,
+    lock_index_grace_period,
+    meta,
+    redis_time,
+    timestamp
+  )
+    # Step 6.1: remove our acquirer from waiting queue
+    transact.call('ZREM', request_queue, acquirer_id)
+
+    # Step 6.2 (RW): drop expired read locks from the readers registry
+    transact.call('ZREMRANGEBYSCORE', lock_readers_key, '-inf', "(#{redis_time}")
+
+    # Step 6.3 (RW): register the read lock (expiration time in redis time)
+    transact.call('ZADD', lock_readers_key, redis_time + ttl.to_i, acquirer_id)
+
+    # Step 6.4 (RW): the registry should live as long as the longest read lock
+    #   - NX + GT => sets the registry TTL to max(current TTL, read lock TTL);
+    #   - in order to prevent "infinite registries" after process crashes;
+    transact.call('PEXPIRE', lock_readers_key, ttl, 'NX')
+    transact.call('PEXPIRE', lock_readers_key, ttl, 'GT')
+
+    # Step 6.5 (RW): store the read lock data (the same structure as the write lock data
+    #   without `acq_id`/`hst_id`: both are derived from the read lock acquirer id that is
+    #   a part of the data key and the registry member, so the info adds them on formatting)
+    #   - drop the data of the expired read lock of the current acquirer (if any);
+    #   - the read lock data lives as long as the read lock;
+    transact.call('DEL', read_lock_key)
+    transact.call(
+      'HSET',
+      read_lock_key,
+      'ts', timestamp,
+      'ini_ttl', ttl,
+      *(meta.to_a if meta != nil) # steep:ignore
+    )
+    transact.call('PEXPIRE', read_lock_key, ttl)
+
+    # Step 6.6 (lock index): the lock name lives in the lock index as long as the read lock
+    #   (the upper bound of the read lock lifetime: client time + ttl + grace period);
+    #   - in the same transaction: an index entry dropped between the queueing and this
+    #     transaction (`#unlock`, `#clear_locks`) is restored with the read lock;
+    #   - GT => the score is never decreased (other keys of the lock can live longer);
+    #   - only with the enabled lock index (the last command of the transaction);
+    if lock_index_enabled
+      transact.call(
+        'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'GT',
+        RedisQueuedLocks::Resource.lock_index_time + ttl.to_i + lock_index_grace_period,
+        lock_name
+      )
+    end
+  end
+
+  # Adds the commands of the write lock obtaining to the given transaction.
+  #
+  # @param transact [RedisClient::Multi]
+  # @param lock_key [String]
+  # @param request_queue [String]
+  # @param lock_name [String] The lock name (the member of the lock index).
+  # @param acquirer_id [String]
+  # @param host_id [String]
+  # @param ttl [Integer,NilClass]
+  # @param lock_index_enabled [Boolean]
+  # @param lock_index_grace_period [Integer] In milliseconds.
+  # @param meta [NilClass,Hash<String|Symbol,Any>]
+  # @param timestamp [Float]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def transact_write_lock_obtaining(
+    transact,
+    lock_key,
+    request_queue,
+    lock_name,
+    acquirer_id,
+    host_id,
+    ttl,
+    lock_index_enabled,
+    lock_index_grace_period,
+    meta,
+    timestamp
+  )
+    # Step 6.1: remove our acquirer from waiting queue
+    transact.call('ZREM', request_queue, acquirer_id)
+
+    # Step 6.2: acquire a lock and store an info about the acquirer and host
+    transact.call(
+      'HSET',
+      lock_key,
+      'acq_id', acquirer_id,
+      'hst_id', host_id,
+      'ts', timestamp,
+      'ini_ttl', ttl,
+      *(meta.to_a if meta != nil) # steep:ignore
+    )
+
+    # Step 6.3: set the lock expiration time in order to prevent "infinite locks"
+    transact.call('PEXPIRE', lock_key, ttl) # NOTE: in milliseconds
+
+    # Step 6.4 (lock index): the lock name lives in the lock index as long as the lock
+    #   (the upper bound of the lock lifetime: client time + ttl + grace period);
+    #   - in the same transaction: an index entry dropped between the queueing and this
+    #     transaction (`#unlock`, `#clear_locks`) is restored with the lock;
+    #   - GT => the score is never decreased (other keys of the lock can live longer);
+    #   - only with the enabled lock index (the last command of the transaction);
+    if lock_index_enabled
+      transact.call(
+        'ZADD', RedisQueuedLocks::Resource::LOCK_INDEX_KEY, 'GT',
+        RedisQueuedLocks::Resource.lock_index_time + ttl.to_i + lock_index_grace_period,
+        lock_name
+      )
+    end
+  end
+
+  # Queues the lock request and reads the lock queue state (Steps 2.1, 1, 3 and 3.2-3.4 of
   # the attempt): the commands are added to the given pipeline (one round trip with other
   # pipelined commands).
-  # Replies (positions relative to the first one): [0] ZADD NX, [1] ZREMRANGEBYSCORE (request
-  # queue), [2] ZREMRANGEBYSCORE (opposite request queue), [QUEUE_HEAD_REPLY] ZRANGE (the first
-  # request of the request queue), [OPPOSITE_QUEUE_HEAD_REPLY] ZRANGE WITHSCORES (the first
-  # request of the opposite request queue); the enabled lock index only: [5] PEXPIRE NX, [6]
-  # PEXPIRE GT (the request queue TTL), [7] ZADD GT (the lock index), [8] ZREMRANGEBYSCORE
-  # (expired lock names of the lock index). Update these constants when the commands change
-  # (new commands go to the end: the replies are not read after `OPPOSITE_QUEUE_HEAD_REPLY`, so
-  # the conditional lock index commands do not shift the read replies).
+  # Replies (positions relative to the first one): [0] ZREMRANGEBYSCORE (request queue, the
+  # priority band of the request), [1] ZREMRANGEBYSCORE (opposite request queue, the priority band
+  # of the request), [2] ZADD NX, [QUEUE_HEAD_REPLY] ZRANGE WITHSCORES (the first request of
+  # the request queue), [OPPOSITE_QUEUE_HEAD_REPLY] ZRANGE WITHSCORES (the first request of
+  # the opposite request queue); the enabled lock index only: [5] PEXPIRE NX, [6] PEXPIRE GT (the
+  # request queue TTL), [7] ZADD GT (the lock index), [8] ZREMRANGEBYSCORE (expired lock names of
+  # the lock index). Update these constants when the commands change (new commands go to the end:
+  # the replies are not read after `OPPOSITE_QUEUE_HEAD_REPLY`, so the conditional lock index
+  # commands do not shift the read replies).
   #
   # @param pipeline [RedisClient::Pipeline]
   # @param request_queue [String] Queue of the requests of the requested lock mode.
   # @param opposite_request_queue [String] Queue of the requests of the opposite lock mode.
-  # @param acquirer_position [Numeric]
+  # @param acquirer_position [Numeric] The enqueue time shifted by the priority band.
+  # @param priority [Integer] The priority band of `acquirer_position`.
   # @param acquirer_id [String]
-  # @param acquirer_dead_score [Float] Requests queued before this score are expired.
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
   # @param lock_name [String] The lock name (the member of the lock index).
   # @param queue_ttl [Integer] Lifetime of the lock request (in seconds).
   # @param lock_index_enabled [Boolean] Send the lock index commands (Steps 3.2-3.4).
@@ -855,11 +1146,13 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   #
   # @api private
   # @since 1.20.0
+  # @version 1.22.0
   def queue_lock_request(
     pipeline,
     request_queue,
     opposite_request_queue,
     acquirer_position,
+    priority,
     acquirer_id,
     acquirer_dead_score,
     lock_name,
@@ -867,6 +1160,22 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     lock_index_enabled,
     lock_index_grace_period
   )
+    # Step 2.1: drop expired acquirers from the lock queues
+    #   - (RW) both queues are cleared: an expired request of the opposite mode should not
+    #     block the current request forever;
+    #   - (priorities) the requests of the priority band of the current request (the band has its
+    #     own time barrier, see `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`); a dead request of
+    #     another band is dropped when it blocks the current request (`drop_dead_requests_ahead`),
+    #     requests of lower priorities are never ahead of the current request;
+    #   - before the queueing (Step 1): the old (dead) position of the requeued request (its
+    #     position is reset after `queue_ttl`, see `dead_score_reached?`) is dropped first, so
+    #     `ZADD NX` adds its new position in the same round trip (after `ZADD NX` the old position
+    #     would be kept by `NX` and dropped by the removal: the request would be missing in the
+    #     queue in this attempt);
+    pipeline_dead_requests_removal(
+      pipeline, request_queue, opposite_request_queue, acquirer_dead_score, priority
+    )
+
     # Step 1: add an acquirer to the lock acquirement queue
     # NOTE:
     #   'NX' means "Only add new elements. Don't update already existing elements."
@@ -876,15 +1185,10 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     #       not in the queue now>>;
     pipeline.call('ZADD', request_queue, 'NX', acquirer_position, acquirer_id)
 
-    # Step 2.1: drop expired acquirers from the lock queues
-    #   - (RW) both queues are cleared: an expired request of the opposite mode should not
-    #     block the current request forever;
-    pipeline.call('ZREMRANGEBYSCORE', request_queue, '-inf', acquirer_dead_score)
-    pipeline.call('ZREMRANGEBYSCORE', opposite_request_queue, '-inf', acquirer_dead_score)
-
-    # Step 3: get the actual acquirer waiting in the queue
+    # Step 3: get the actual acquirer waiting in the queue (with its position: the band and
+    #   the liveness of the queue head are decoded from it, see `drop_dead_requests_ahead`)
     #   - (RW) and the first request of the opposite mode;
-    pipeline.call('ZRANGE', request_queue, '0', '0')
+    pipeline.call('ZRANGE', request_queue, '0', '0', 'WITHSCORES')
     pipeline.call('ZRANGE', opposite_request_queue, '0', '0', 'WITHSCORES')
 
     # NOTE: the disabled lock index: no lock index commands, lock request queues have no TTL
@@ -921,6 +1225,34 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     )
   end
 
+  # Adds the removal of the dead lock requests of the given priority band (both lock queues) to
+  # the given pipeline (see `queue_lock_request` and `drop_dead_requests_ahead`).
+  #
+  # @param pipeline [RedisClient::Pipeline]
+  # @param request_queue [String]
+  # @param opposite_request_queue [String]
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
+  # @param priority [Integer]
+  #   The priority band (see `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`).
+  # @return [void]
+  #
+  # @api private
+  # @since 1.22.0
+  def pipeline_dead_requests_removal(
+    pipeline,
+    request_queue,
+    opposite_request_queue,
+    acquirer_dead_score,
+    priority
+  )
+    band_floor = RedisQueuedLocks::Resource.lock_priority_band_floor(priority)
+    band_dead_score =
+      RedisQueuedLocks::Resource.lock_priority_band_dead_score(acquirer_dead_score, priority)
+    pipeline.call('ZREMRANGEBYSCORE', request_queue, band_floor, band_dead_score)
+    pipeline.call('ZREMRANGEBYSCORE', opposite_request_queue, band_floor, band_dead_score)
+  end
+
   # Adds the lock state commands to the given pipeline (the lock state of the attempt and of
   # the pre-check: one round trip).
   #
@@ -949,6 +1281,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @param request_queue [String]
   # @param opposite_request_queue [String]
   # @param acquirer_position [Numeric]
+  # @param priority [Integer]
   # @param acquirer_dead_score [Float]
   # @param lock_name [String] The lock name (the member of the lock index).
   # @param queue_ttl [Integer] In seconds.
@@ -958,6 +1291,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   #
   # @api private
   # @since 1.20.0
+  # @version 1.22.0
   def pipeline_lock_state(
     pipeline,
     lock_key,
@@ -968,6 +1302,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     request_queue,
     opposite_request_queue,
     acquirer_position,
+    priority,
     acquirer_dead_score,
     lock_name,
     queue_ttl,
@@ -981,7 +1316,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     if queueing
       queue_lock_request(
         pipeline, request_queue, opposite_request_queue,
-        acquirer_position, acquirer_id, acquirer_dead_score,
+        acquirer_position, priority, acquirer_id, acquirer_dead_score,
         lock_name, queue_ttl, lock_index_enabled, lock_index_grace_period
       )
     end
@@ -991,6 +1326,8 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
 
   # (RW) The request of the opposite mode that should obtain the lock earlier
   #   - FIFO between modes (`:queued` access strategy only);
+  #   - (priorities) positions are shifted by the priority bands: a request of a higher priority
+  #     is ahead of any request of a lower priority, requests of the same priority are FIFO;
   #   - equal positions are ordered by acquirer ids;
   #
   # @param access_strategy [Symbol]
@@ -1080,14 +1417,19 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @param acquirer_id [String]
   # @param host_id [String]
   # @param access_strategy [Symbol]
-  # @param read_write_mode [Symbol]
+  # @param rw_mode [Symbol]
   # @param waiting_acquirer [String,NilClass]
-  # @param opposite_request_ahead [String,NilClass]
+  # @param waiting_priority [Integer,NilClass]
+  #   The priority of the first request (decoded for logs only: `nil` without logs).
+  # @param opposite_waiting_request [Array<String,Float>,NilClass]
+  #   The first request of the opposite queue (the request ahead of the `*_request_is_ahead`
+  #   obstacles, see `find_opposite_request_ahead`).
   # @param current_lock_obtainer [String,NilClass]
   # @return [void]
   #
   # @api private
   # @since 1.20.0
+  # @version 1.22.0
   # rubocop:disable Metrics/MethodLength
   def log_lock_obstacle(
     rconn,
@@ -1100,59 +1442,354 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     acquirer_id,
     host_id,
     access_strategy,
-    read_write_mode,
+    rw_mode,
     waiting_acquirer,
-    opposite_request_ahead,
+    waiting_priority,
+    opposite_waiting_request,
     current_lock_obtainer
   )
     case obstacle
     when :dead_score_reached
       LogVisitor.exit__queue_ttl_reached(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
       )
     when :acquirer_is_not_first_in_queue
       LogVisitor.exit__no_first(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode, waiting_acquirer,
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, waiting_acquirer,
+        waiting_priority,
         # NOTE: lock data is extracted for logs only
         ((log_sampled && log_lock_try) ? rconn.call('HGETALL', lock_key).to_h : NO_LOCK_DATA)
       )
-    when :write_request_is_ahead
-      LogVisitor.exit__write_request_ahead(
-        logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
-        opposite_request_ahead #: String
-      )
-    when :read_request_is_ahead
-      LogVisitor.exit__read_request_ahead(
-        logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
-        opposite_request_ahead #: String
-      )
+    when :write_request_is_ahead, :read_request_is_ahead
+      ahead_request = opposite_waiting_request #: [String, Float]
+      # NOTE: the priority of the request ahead is decoded for logs only
+      ahead_priority = logged_request_priority(log_sampled, log_lock_try, ahead_request)
+      if obstacle == :write_request_is_ahead
+        LogVisitor.exit__write_request_ahead(
+          logger, log_sampled, log_lock_try, lock_key,
+          queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
+          ahead_request[0], ahead_priority
+        )
+      else
+        LogVisitor.exit__read_request_ahead(
+          logger, log_sampled, log_lock_try, lock_key,
+          queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
+          ahead_request[0], ahead_priority
+        )
+      end
     when :lock_is_still_acquired
       LogVisitor.exit__lock_still_obtained(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode,
-        waiting_acquirer, current_lock_obtainer, #: String
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode,
+        waiting_acquirer, waiting_priority,
+        current_lock_obtainer, #: String
         # NOTE: lock data is extracted for logs only
         ((log_sampled && log_lock_try) ? rconn.call('HGETALL', lock_key).to_h : NO_LOCK_DATA)
       )
     when :read_lock_is_still_acquired
       LogVisitor.exit__read_lock_still_obtained(
         logger, log_sampled, log_lock_try, lock_key,
-        queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode, waiting_acquirer
+        queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, waiting_acquirer,
+        waiting_priority
       )
     end
   end
   # rubocop:enable Metrics/MethodLength
 
+  # (priorities) The priority of the lock request for the try-lock logs (the first request of
+  # the queue, the request ahead): decoded only when the try-lock logs are written (log-only values
+  # are never computed without the logs: `log_sampled && log_lock_try`).
+  #
+  # @param log_sampled [Boolean]
+  # @param log_lock_try [Boolean]
+  # @param lock_request [Array<String,Float>,NilClass]
+  #   The acquirer and the position of the lock request.
+  # @return [Integer,NilClass] `nil` without the try-lock logs or without the lock request.
+  #
+  # @api private
+  # @since 1.22.0
+  def logged_request_priority(log_sampled, log_lock_try, lock_request)
+    return unless log_sampled && log_lock_try && lock_request
+
+    RedisQueuedLocks::Resource.lock_request_priority(lock_request[1])
+  end
+
+  # (priorities) Drops the dead lock requests of other priority bands that block the current lock
+  # request (`:queued` access strategy: the head of the write lock queue for write lock requests,
+  # the earlier lock request of the opposite mode for both modes) and reads the actual queue heads
+  # (Step 2.2 of the attempt and of its pre-check):
+  #   - the dead lock requests of the band of the current request are dropped by the queueing
+  #     (Step 2.1, before the queue heads are read) and requests of lower priorities are never
+  #     ahead of it: only a request of a higher priority can be a dead blocking request;
+  #   - the band and the enqueue time of the blocking request are decoded from its position (see
+  #     `RedisQueuedLocks::Resource::LOCK_PRIORITY_BAND`): no Redis commands to check the liveness,
+  #     any band is recognized (the priority range of the current RQL version is not used), the
+  #     time barrier is the barrier of the current request (`acquirer_dead_score`: its `queue_ttl`);
+  #   - the dead blocking requests (the head of the write lock queue and the earlier request of the
+  #     opposite mode) are dropped with all dead requests of their bands (both queues) in one round
+  #     trip with the reading of the actual queue heads; no round trips while no dead request
+  #     blocks the current one (the lock state does not matter: the attempt drops the dead blocking
+  #     requests even when the lock is obtained by another acquirer);
+  #   - up to `MAX_DEAD_REQUEST_REMOVALS` round trips (one or two bands each) per call;
+  #   - (infinite positions) RQL never writes them (manual writes of the queues, see
+  #     `RedisQueuedLocks::Resource.lock_request_priority`): a blocking request at `-inf` is always
+  #     dead (the highest band, no enqueue time) and is dropped with all requests at `-inf` of both
+  #     queues in the same round trip; a request at `+inf` is never ahead of the current request;
+  #   - the dropped blocking requests are returned, not logged: the attempt and its pre-check log
+  #     them at the same step (after the queueing log events, see `log_dropped_requests`);
+  #
+  # @param rconn [RedisClient]
+  # @param rw_mode [Symbol]
+  # @param request_queue [String]
+  # @param opposite_request_queue [String]
+  # @param acquirer_id [String]
+  # @param acquirer_position [Numeric]
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
+  # @param access_strategy [Symbol]
+  # @param waiting_request [Array<String,Float>,NilClass] The head of the request queue.
+  # @param opposite_waiting_request [Array<String,Float>,NilClass]
+  #   The head of the opposite request queue.
+  # @return [Array<Array<String,Float>,NilClass,Array<Array<String,Integer>>>,NilClass]
+  #   - the actual queue heads and the dropped blocking requests (the acquirer and the priority of
+  #     each one, in the order of the removal): `[waiting_request, opposite_waiting_request,
+  #     dropped_requests]` when at least one dead lock request is dropped;
+  #   - `nil` otherwise;
+  #
+  # @api private
+  # @since 1.22.0
+  # rubocop:disable Metrics/MethodLength
+  def drop_dead_requests_ahead(
+    rconn,
+    rw_mode,
+    request_queue,
+    opposite_request_queue,
+    acquirer_id,
+    acquirer_position,
+    acquirer_dead_score,
+    access_strategy,
+    waiting_request,
+    opposite_waiting_request
+  )
+    return unless access_strategy == :queued
+
+    read_mode = (rw_mode == :read)
+    round_trips = 0
+    # NOTE: allocated by the first removal only (no allocations while nothing dead blocks)
+    # @type var dropped_requests: Array[[String, Integer]]?
+    dropped_requests = nil
+
+    while round_trips < MAX_DEAD_REQUEST_REMOVALS
+      dead_requests = find_dead_requests_ahead(
+        read_mode, access_strategy, acquirer_id, acquirer_position, acquirer_dead_score,
+        waiting_request, opposite_waiting_request
+      )
+      break unless dead_requests
+
+      dead_head, dead_head_priority, dead_ahead, dead_ahead_priority = dead_requests
+
+      # NOTE: (pipeline layout) see `pipeline_dead_requests_ahead_removal`, then [-2] ZRANGE
+      #   WITHSCORES (the head of the request queue) and [-1] ZRANGE WITHSCORES (the head of
+      #   the opposite request queue);
+      # @type var queue_state: Array[untyped]
+      queue_state = rconn.pipelined do |pipeline|
+        pipeline_dead_requests_ahead_removal(
+          pipeline, request_queue, opposite_request_queue, acquirer_dead_score,
+          dead_head, dead_head_priority, dead_ahead, dead_ahead_priority
+        )
+        pipeline.call('ZRANGE', request_queue, '0', '0', 'WITHSCORES')
+        pipeline.call('ZRANGE', opposite_request_queue, '0', '0', 'WITHSCORES')
+      end
+      # @type var removed_requests: Array[[String, Integer]]
+      removed_requests = dropped_requests || []
+      removed_requests << [dead_head[0], dead_head_priority] if dead_head && dead_head_priority
+      removed_requests << [dead_ahead[0], dead_ahead_priority] if dead_ahead && dead_ahead_priority
+      dropped_requests = removed_requests
+      waiting_request = queue_state[-2].first
+      opposite_waiting_request = queue_state[-1].first
+      round_trips += 1
+    end
+
+    [waiting_request, opposite_waiting_request, dropped_requests] if dropped_requests
+  end
+  # rubocop:enable Metrics/MethodLength
+
+  # (priorities) The dead lock requests that block the current lock request (see
+  # `drop_dead_requests_ahead`, the same order as in `lock_obstacle`): the head of the write lock
+  # queue (write lock requests only) and the earlier lock request of the opposite mode; a live head
+  # of the write lock queue stops the removal (the attempt waits for it).
+  #
+  # @param read_mode [Boolean]
+  # @param access_strategy [Symbol]
+  # @param acquirer_id [String]
+  # @param acquirer_position [Numeric]
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
+  # @param waiting_request [Array<String,Float>,NilClass] The head of the request queue.
+  # @param opposite_waiting_request [Array<String,Float>,NilClass]
+  #   The head of the opposite request queue.
+  # @return [Array<Array<String,Float>,Integer,NilClass>,NilClass]
+  #   `[dead_head, dead_head_priority, dead_ahead, dead_ahead_priority]` (one of the pairs can be
+  #   `nil`) or `nil` when no dead lock request blocks the current one.
+  #
+  # @api private
+  # @since 1.23.0
+  def find_dead_requests_ahead(
+    read_mode,
+    access_strategy,
+    acquirer_id,
+    acquirer_position,
+    acquirer_dead_score,
+    waiting_request,
+    opposite_waiting_request
+  )
+    # @type var dead_head: [String, Float]?
+    dead_head = nil
+    # @type var dead_head_priority: Integer?
+    dead_head_priority = nil
+    if !read_mode && waiting_request && waiting_request[0] != acquirer_id
+      dead_head_priority = dead_request_priority(waiting_request, acquirer_dead_score)
+      return unless dead_head_priority
+
+      dead_head = waiting_request
+    end
+    # @type var dead_ahead: [String, Float]?
+    dead_ahead = nil
+    # @type var dead_ahead_priority: Integer?
+    dead_ahead_priority = nil
+    if find_opposite_request_ahead(
+      access_strategy, opposite_waiting_request, acquirer_position, acquirer_id
+    )
+      ahead_request = opposite_waiting_request #: [String, Float]
+      dead_ahead_priority = dead_request_priority(ahead_request, acquirer_dead_score)
+      dead_ahead = ahead_request if dead_ahead_priority
+    end
+    return unless dead_head_priority || dead_ahead_priority
+
+    [dead_head, dead_head_priority, dead_ahead, dead_ahead_priority]
+  end
+
+  # (priorities) Adds the removal of the dead blocking lock requests (see
+  # `find_dead_requests_ahead`) to the given pipeline: ZREMRANGEBYSCORE of both queues for each
+  # dropped band (one or two bands) and for the requests at `-inf` (a dead blocking request at
+  # `-inf` only).
+  #
+  # @param pipeline [RedisClient::Pipeline]
+  # @param request_queue [String]
+  # @param opposite_request_queue [String]
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
+  # @param dead_head [Array<String,Float>,NilClass]
+  # @param dead_head_priority [Integer,NilClass]
+  # @param dead_ahead [Array<String,Float>,NilClass]
+  # @param dead_ahead_priority [Integer,NilClass]
+  # @return [void]
+  #
+  # @api private
+  # @since 1.23.0
+  def pipeline_dead_requests_ahead_removal(
+    pipeline,
+    request_queue,
+    opposite_request_queue,
+    acquirer_dead_score,
+    dead_head,
+    dead_head_priority,
+    dead_ahead,
+    dead_ahead_priority
+  )
+    if dead_head_priority
+      pipeline_dead_requests_removal(
+        pipeline, request_queue, opposite_request_queue, acquirer_dead_score, dead_head_priority
+      )
+    end
+    if dead_ahead_priority && dead_ahead_priority != dead_head_priority
+      pipeline_dead_requests_removal(
+        pipeline, request_queue, opposite_request_queue, acquirer_dead_score, dead_ahead_priority
+      )
+    end
+    # NOTE: (infinite positions) a dead blocking request at `-inf` (a manual write: out of all
+    #   bands, see `RedisQueuedLocks::Resource.lock_request_priority`) is not covered by
+    #   the band removal of its decoded priority (it drops the dead requests of that band
+    #   only): the requests at `-inf` are dropped from both queues by their position;
+    if (dead_head && dead_head[1] == -Float::INFINITY) ||
+       (dead_ahead && dead_ahead[1] == -Float::INFINITY)
+      pipeline.call('ZREMRANGEBYSCORE', request_queue, '-inf', '-inf')
+      pipeline.call('ZREMRANGEBYSCORE', opposite_request_queue, '-inf', '-inf')
+    end
+  end
+
+  # (priorities) Logs the dead lock requests dropped by `drop_dead_requests_ahead` (the attempt
+  # and its pre-check log them at the same step: after the queueing log events).
+  #
+  # @param logger [::Logger,#debug]
+  # @param log_sampled [Boolean]
+  # @param log_lock_try [Boolean]
+  # @param lock_key [String]
+  # @param queue_ttl [Integer]
+  # @param acquirer_id [String]
+  # @param host_id [String]
+  # @param access_strategy [Symbol]
+  # @param rw_mode [Symbol]
+  # @param dropped_requests [Array<Array<String,Integer>>]
+  #   The acquirer and the priority of each dropped lock request.
+  # @return [void]
+  #
+  # @api private
+  # @since 1.22.0
+  def log_dropped_requests(
+    logger,
+    log_sampled,
+    log_lock_try,
+    lock_key,
+    queue_ttl,
+    acquirer_id,
+    host_id,
+    access_strategy,
+    rw_mode,
+    dropped_requests
+  )
+    return unless log_sampled && log_lock_try
+
+    dropped_requests.each do |dead_acquirer_id, dead_priority|
+      LogVisitor.dead_request_removed(
+        logger, log_sampled, log_lock_try, lock_key, queue_ttl, acquirer_id, host_id,
+        access_strategy, rw_mode, dead_acquirer_id, dead_priority
+      )
+    end
+  end
+
+  # (priorities) The priority band of the dead lock request (see `drop_dead_requests_ahead`): the
+  # band and the enqueue time are decoded from the position of the request (infinite positions:
+  # `-inf` is decoded to the highest band and is always dead, `+inf` to the lowest band and is never
+  # dead, see `RedisQueuedLocks::Resource.lock_request_priority`).
+  #
+  # @param lock_request [Array<String,Float>] The acquirer and the position of the lock request.
+  # @param acquirer_dead_score [Float]
+  #   Requests queued before this time are expired (the barrier of the default priority band).
+  # @return [Integer,NilClass]
+  #   The priority of the dead lock request, `nil` for a live one (its position is after the time
+  #   barrier of its band: the same barrier as the dropping of the dead requests of the band).
+  #
+  # @api private
+  # @since 1.22.0
+  def dead_request_priority(lock_request, acquirer_dead_score)
+    priority = RedisQueuedLocks::Resource.lock_request_priority(lock_request[1])
+    band_dead_score =
+      RedisQueuedLocks::Resource.lock_priority_band_dead_score(acquirer_dead_score, priority)
+    priority if lock_request[1] <= band_dead_score
+  end
+
   # Pre-check of the attempt (Step PRE): the lock state without WATCH (one round trip).
   #   - `fail_fast` attempts: the lock state only (the request is not queued: the failed "no try"
   #     attempt does not dequeue the request); fails with `:fail_fast_no_try` on the obtained lock;
   #   - retries: the lock state and the lock request queueing (the request is already queued by
   #     the previous attempts); fails with the obstacle of the classic logic (`lock_obstacle`)
-  #     and logs the same events as the failed attempt;
+  #     and logs the same events as the failed attempt in the same order;
+  #   - (priorities) retries drop the dead lock requests of other priority bands that block the
+  #     request before the decision (Step 2.2 of the attempt: one more round trip per dropped
+  #     band, see `drop_dead_requests_ahead`);
   #   - same-process conflicts (the lock is obtained by the current acquirer) and locks that can be
   #     obtained are not decided: the attempt continues with the WATCH/MULTI logic (`nil`);
   #   - the pre-check never obtains the lock (mutual exclusion relies on WATCH/MULTI only);
@@ -1162,7 +1799,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @param log_sampled [Boolean]
   # @param log_lock_try [Boolean]
   # @param lock_key [String]
-  # @param read_write_mode [Symbol]
+  # @param rw_mode [Symbol]
   # @param lock_readers_key [String]
   # @param request_queue [String]
   # @param opposite_request_queue [String]
@@ -1170,6 +1807,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   # @param acquirer_id [String]
   # @param host_id [String]
   # @param acquirer_position [Numeric]
+  # @param priority [Integer]
   # @param acquirer_dead_score [Float]
   # @param queue_ttl [Integer]
   # @param lock_index_enabled [Boolean]
@@ -1180,6 +1818,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
   #
   # @api private
   # @since 1.20.0
+  # @version 1.22.0
   # rubocop:disable Metrics/MethodLength
   def precheck_lock(
     rconn,
@@ -1187,7 +1826,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     log_sampled,
     log_lock_try,
     lock_key,
-    read_write_mode,
+    rw_mode,
     lock_readers_key,
     request_queue,
     opposite_request_queue,
@@ -1195,6 +1834,7 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     acquirer_id,
     host_id,
     acquirer_position,
+    priority,
     acquirer_dead_score,
     queue_ttl,
     lock_index_enabled,
@@ -1202,13 +1842,13 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     fail_fast,
     access_strategy
   )
-    read_mode = (read_write_mode == :read)
+    read_mode = (rw_mode == :read)
     # NOTE: the same pipeline layout and the same reply reading as in Step 0.1 of the attempt
     # @type var lock_state: Array[untyped]
     lock_state = rconn.pipelined do |pipeline|
       pipeline_lock_state(
         pipeline, lock_key, lock_readers_key, acquirer_id, read_mode, !fail_fast,
-        request_queue, opposite_request_queue, acquirer_position, acquirer_dead_score,
+        request_queue, opposite_request_queue, acquirer_position, priority, acquirer_dead_score,
         lock_name, queue_ttl, lock_index_enabled, lock_index_grace_period
       )
     end
@@ -1228,12 +1868,26 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
     # NOTE: the fail-fast check of the attempt (Fast-Step X0) without same-process conflicts
     return ((current_lock_obtainer || read_locked) ? :fail_fast_no_try : nil) if fail_fast
 
-    # @type var waiting_acquirer: String?
-    waiting_acquirer =
-      lock_state[LOCK_STATE_QUEUE_REPLIES_AT + QUEUE_HEAD_REPLY].first
+    # @type var waiting_request: [String, Float]?
+    waiting_request = lock_state[LOCK_STATE_QUEUE_REPLIES_AT + QUEUE_HEAD_REPLY].first
     # @type var opposite_waiting_request: [String, Float]?
     opposite_waiting_request =
       lock_state[LOCK_STATE_QUEUE_REPLIES_AT + OPPOSITE_QUEUE_HEAD_REPLY].first
+    # NOTE: (priorities) Step 2.2 of the attempt: the dead lock requests of other priority bands
+    #   that block the current one are dropped before the obstacle decision; they are logged at
+    #   the step of the attempt (after the queueing log events of the failed pre-check, they
+    #   follow the decision) or before the attempt that continues (it logs its own queueing);
+    actual_queue_heads = drop_dead_requests_ahead(
+      rconn, rw_mode, request_queue, opposite_request_queue, acquirer_id,
+      acquirer_position, acquirer_dead_score, access_strategy, waiting_request,
+      opposite_waiting_request
+    )
+    # @type var dropped_requests: Array[[String, Integer]]?
+    dropped_requests = nil
+    if actual_queue_heads
+      waiting_request, opposite_waiting_request, dropped_requests = actual_queue_heads
+    end
+    waiting_acquirer = waiting_request ? waiting_request[0] : nil
     # @type var opposite_request_ahead: String?
     opposite_request_ahead = find_opposite_request_ahead(
       access_strategy, opposite_waiting_request, acquirer_position, acquirer_id
@@ -1242,25 +1896,44 @@ module RedisQueuedLocks::Acquirer::AcquireLock::TryToLock
       read_mode, access_strategy, acquirer_id, waiting_acquirer, opposite_request_ahead,
       current_lock_obtainer, read_locked
     )
-    return unless obstacle
+    unless obstacle
+      if dropped_requests
+        log_dropped_requests(
+          logger, log_sampled, log_lock_try, lock_key, queue_ttl, acquirer_id, host_id,
+          access_strategy, rw_mode, dropped_requests
+        )
+      end
+      return
+    end
+
+    # NOTE: the priority of the first request is decoded for logs only
+    waiting_priority = logged_request_priority(log_sampled, log_lock_try, waiting_request)
 
-    # NOTE: the same log events as the failed attempt (queueing steps + the exit event)
+    # NOTE: the same log events as the failed attempt in the same order (queueing steps, the dropped
+    #   dead requests, the first request, the exit event)
     LogVisitor.acq_added_to_queue(
       logger, log_sampled, log_lock_try, lock_key,
-      queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+      queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, priority
     )
     LogVisitor.remove_expired_acqs(
       logger, log_sampled, log_lock_try, lock_key,
-      queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode
+      queue_ttl, acquirer_id, host_id, access_strategy, rw_mode
     )
+    if dropped_requests
+      log_dropped_requests(
+        logger, log_sampled, log_lock_try, lock_key, queue_ttl, acquirer_id, host_id,
+        access_strategy, rw_mode, dropped_requests
+      )
+    end
     LogVisitor.get_first_from_queue(
       logger, log_sampled, log_lock_try, lock_key,
-      queue_ttl, acquirer_id, host_id, access_strategy, read_write_mode, waiting_acquirer
+      queue_ttl, acquirer_id, host_id, access_strategy, rw_mode, waiting_acquirer,
+      waiting_priority
     )
     log_lock_obstacle(
       rconn, obstacle, logger, log_sampled, log_lock_try, lock_key, queue_ttl,
-      acquirer_id, host_id, access_strategy, read_write_mode,
-      waiting_acquirer, opposite_request_ahead, current_lock_obtainer
+      acquirer_id, host_id, access_strategy, rw_mode,
+      waiting_acquirer, waiting_priority, opposite_waiting_request, current_lock_obtainer
     )
     obstacle
   end