Struct tikv::server::lock_manager::waiter_manager::Waiter

pub(crate) struct Waiter {
    pub(crate) start_ts: TimeStamp,
    pub(crate) cb: StorageCallback,
    pub(crate) pr: ProcessResult,
    pub(crate) lock: Lock,
    pub diag_ctx: DiagnosticContext,
    delay: Delay,
    _lifetime_timer: HistogramTimer,
}

If a pessimistic transaction meets a lock, it will wait for the lock released in WaiterManager.

Waiter contains the context of the pessimistic transaction. Each Waiter has a timeout. Transaction will be notified when the lock is released or the corresponding waiter times out.

Fields

start_ts: TimeStamp

cb: StorageCallback

pr: ProcessResult

The result of Command::AcquirePessimisticLock.

It contains a KeyIsLocked error at the beginning. It will be changed to WriteConflict error if the lock is released or Deadlock error if it causes deadlock.

lock: Lock

diag_ctx: DiagnosticContext

delay: Delay

_lifetime_timer: HistogramTimer

Implementations

impl Waiter

fn new(
    start_ts: TimeStamp,
    cb: StorageCallback,
    pr: ProcessResult,
    lock: Lock,
    deadline: Instant,
    diag_ctx: DiagnosticContext
) -> Self

fn on_timeout<F: FnOnce()>(&self, f: F) -> impl Future<Output = ()>

The F will be invoked if the Waiter times out normally.

fn reset_timeout(&self, deadline: Instant)

fn notify(self)

Notify consumes the Waiter to notify the corresponding transaction going on.

fn conflict_with(&mut self, lock_ts: TimeStamp, commit_ts: TimeStamp)

Changes the ProcessResult to WriteConflict. It may be invoked more than once.

fn deadlock_with(
    &mut self,
    deadlock_key_hash: u64,
    wait_chain: Vec<WaitForEntry>
)

Changes the ProcessResult to Deadlock.

fn extract_key_info(&mut self) -> (Vec<u8>, Vec<u8>)

Extracts key and primary key from ProcessResult.