Are Lock-Free Concurrent Algorithms Practically Wait-Free?

Lock-free concurrent algorithms guarantee that some concurrent operation will always make progress in a finite number of steps. Yet programmers prefer to treat concurrent code as if it were wait-free, guaranteeing that all operations always make progress. Unfortunately, designing wait-free algorithms is generally a very complex task, and the resulting algorithms are not always efficient. While obtaining efficient wait-free algorithms has been a long-time goal for the theory community, most non-blocking commercial code is only lock-free. This paper suggests a simple solution to this problem. We show that, for a large class of lock- free algorithms, under scheduling conditions which approximate those found in commercial hardware architectures, lock-free algorithms behave as if they are wait-free. In other words, programmers can keep on designing simple lock-free algorithms instead of complex wait-free ones, and in practice, they will get wait-free progress. Our main contribution is a new way of analyzing a general class of lock-free algorithms under a stochastic scheduler. Our analysis relates the individual performance of processes with the global performance of the system using Markov chain lifting between a complex per-process chain and a simpler system progress chain. We show that lock-free algorithms are not only wait-free with probability 1, but that in fact a general subset of lock-free algorithms can be closely bounded in terms of the average number of steps required until an operation completes. To the best of our knowledge, this is the first attempt to analyze progress conditions, typically stated in relation to a worst case adversary, in a stochastic model capturing their expected asymptotic behavior.

💡 Research Summary

**
The paper tackles a long‑standing gap between theory and practice in concurrent data structures. While lock‑free algorithms guarantee that some operation makes progress, programmers often assume wait‑free behavior, i.e., that every operation completes. Designing truly wait‑free algorithms is notoriously difficult and frequently incurs substantial overhead. The authors propose a stochastic scheduling model that more closely reflects the behavior of real multicore hardware, and they show that under this model a large class of lock‑free algorithms behave as if they were wait‑free.

Stochastic scheduler.
The core of the model is a “θ‑scheduler”: at each discrete time step a process is chosen at random, and every non‑faulty process receives a scheduling probability of at least θ > 0. This captures the intuition that modern OS schedulers do not deliberately starve any particular thread. Under such a scheduler any bounded lock‑free algorithm (i.e., one that guarantees some process makes progress within a finite bound) becomes wait‑free with probability 1. The authors prove that the set of executions that prevent a given process from ever progressing has measure zero.

Algorithmic class (SCU).
The analysis focuses on the SCU (Single Compare‑and‑Swap Universal) class, which includes a preamble followed by a scan‑validate‑CAS phase. This pattern underlies many well‑known lock‑free structures such as stacks, queues, hash tables, and the Linux RCU mechanism. By modeling each process’s execution as a Markov chain and then “lifting” this chain to a simpler system‑wide chain, the authors relate per‑process latency to global system latency.

Key technical contribution – Markov chain lifting.
The lifting technique shows that the expected number of system steps until any operation finishes (system latency) is exactly 1/n of the expected number of steps until a particular process finishes (individual latency). Consequently, on average the system completes requests n times faster than a single thread would on its own.

Performance bound.
Using an iterated balls‑into‑bins argument, the paper derives a tight bound on system latency: O(q + s √n), where q is the length of the preamble, s the length of the scan‑validate phase, and n the number of processes. This improves dramatically over worst‑case adversarial bounds that scale linearly with n. Empirical measurements on real hardware (Linux CFS scheduler) show that the uniform stochastic scheduler approximates long‑run behavior well, and observed latencies match the theoretical predictions.

Implications and limitations.
The results suggest that for many practical workloads, developers can continue to use simple lock‑free designs without adding complex helping mechanisms required for strict wait‑free guarantees, because the scheduler already provides the needed progress with probability 1 and with reasonable expected latency. However, the model assumes a uniform lower bound θ on scheduling probabilities, which may not hold in real‑time or priority‑biased environments. Moreover, the analysis is limited to the SCU pattern; algorithms that rely on multiple CAS operations, complex helping trees, or non‑linear data structures are not directly covered. Finally, “probability 1” does not eliminate the possibility of extremely long tail latencies, which may be unacceptable in safety‑critical systems.

Future directions.
The authors propose extending the framework to non‑uniform or dynamic scheduling probabilities, applying the lifting technique to broader classes of lock‑free algorithms, and integrating probabilistic latency guarantees with hard real‑time constraints (e.g., providing 99.9 % latency bounds). Such work could bridge the remaining gap between probabilistic progress guarantees and the deterministic guarantees demanded by mission‑critical applications.