lock-free linked lists

This study addresses the correctness and efficiency of concurrent linked list access under multithreaded workloads by systematically implementing five representative designs: coarse-grained locking, fine-grained locking, lazy synchronization, optimistic synchronization, and lock-free structures. Through empirical evaluation in C++, the work demonstrates a strong correlation between algorithmic performance and workload characteristics—such as read-write ratios and key ranges—as well as thread count. The findings reveal that coarse-grained locking and lazy lists achieve optimal performance in read-heavy scenarios with small key ranges, whereas lock-free lists exhibit significant advantages under high concurrency and large key ranges. Notably, fine-grained locking consistently underperforms due to per-node locking overhead, challenging the common assumption that finer granularity inherently yields better scalability. These results provide empirical guidance for selecting appropriate concurrent data structures in practice.

This work addresses the problem of spurious counterexamples arising from model incompleteness in the liveness verification of mutual exclusion algorithms based on (non-)blocking and (non-)atomic shared registers. To resolve this issue, we introduce justness as a completeness criterion and integrate it with concurrency relations induced by different register semantics to construct a precise model-checking framework. This approach successfully uncovers correctness flaws in several classic mutual exclusion algorithms under specific register assumptions and enables the development of effective corrections. By aligning the verification model more faithfully with the underlying concurrency semantics, our method significantly enhances both the reliability and practical applicability of algorithmic verification for mutual exclusion protocols.

This work addresses the formal correctness verification of mutual exclusion algorithms built upon shared read/write registers—both atomic and non-atomic. We propose a model-checking framework grounded in *justness* as a completeness criterion, integrating multiple concurrency semantics to accurately model register behavior and incorporating strong fairness assumptions to eliminate spurious counterexamples—thereby significantly improving detection accuracy for liveness properties such as livelock compared to conventional weak fairness. Experimental evaluation validates several classical mutual exclusion algorithms, uncovering previously unreported violation traces concerning safety or liveness. Based on these findings, we propose targeted refinements to restore correctness. To our knowledge, this is the first application of justness-based reasoning to mutual exclusion verification under shared register models, advancing both the reliability and depth of concurrent algorithm verification.

To address the low execution efficiency of guard-based synchronization in shared-variable concurrent models, this paper proposes an efficient guard-atomic-action synchronization mechanism for object-oriented languages, wherein guard logic is deeply bound to objects to enable condition-driven atomic execution regions. Methodologically, it introduces the first integration of coroutine scheduling, OS thread pooling, object-granularity customized queue/stack memory management, dynamic guard-condition evaluation, and lazy wakeup. Its core contribution lies in overcoming the traditional loose coupling between guard synchronization and object models, achieving substantial reduction in synchronization overhead through synergistic runtime and language-semantic optimizations. Evaluation on the Lime experimental language demonstrates that the mechanism outperforms mainstream concurrent platforms—including C/Pthreads, Go, Erlang, Java, and Haskell—on synthetic benchmarks.

To address the challenge of simultaneously achieving scalability and online load balancing in high-throughput distributed databases—where dynamic indexing structures often suffer from coordination overhead or downtime—this paper proposes DiLi, a lock-free linked list supporting asynchronous dynamic distribution. DiLi introduces a novel “conditional lock-freedom” design that guarantees linearizability while enabling zero-downtime partition reconfiguration and load migration. It combines binary search–guided positioning with bounded linear traversal to efficiently support find, insert, and remove operations. On a single node, DiLi matches the performance of state-of-the-art lock-free linked lists; in multi-node deployments, its throughput scales nearly linearly with the number of nodes. Experimental evaluation under high-concurrency workloads demonstrates DiLi’s strong scalability, high availability, and low tail latency—making it particularly suitable for demanding distributed database scenarios.

Traditional reader-writer locks suffer from coarse-grained contention, making them ill-suited for concurrent data structures involving long-running operations. This work proposes SemanticLock, a synchronization mechanism that generalizes read-write semantics to arbitrary semantic conflict relationships among operations. By constructing an operation conflict graph, SemanticLock enables fine-grained concurrency control while allowing flexible specification of operation semantics. The approach has been integrated into array-based structures supporting both point and range queries, as well as an enhanced ConcurrentHashMap. Experimental results demonstrate that SemanticLock substantially improves concurrency performance under complex, long-duration operations.

This work addresses the challenges of latency and scalability in designing efficient concurrent primitives under high write contention in shared-memory systems. It introduces a novel approach based on a contention-resolution algorithm that transforms contention-prone hardware primitives into higher-level concurrent objects within an approximately synchronous randomized scheduling model. For the first time, the study achieves composable, low-latency concurrent primitives against an adaptive adversary, and establishes a theoretical lower bound for the space–latency tradeoff. Using only O(1) read–write registers and a single compare-and-swap (CAS) register, the construction yields—with high probability—O(log P) latency for a variety of primitives, including read–write registers, CAS, load-linked/store-conditional (LL/SC), fetch-and-increment, bounded max registers, and counters.

This work proposes an efficient and robust lock-free multi-word compare-and-swap (MCAS) algorithm that addresses the severe performance degradation under high contention and susceptibility to the ABA problem observed in existing approaches, which can lead to state inconsistency and redundant operation execution. The proposed algorithm incorporates a contention-aware helping mechanism that dynamically adjusts the number of concurrent helpers and integrates version embedding to effectively mitigate ABA issues. By combining exponential backoff, embedded counters, and a fast garbage collection path, the method ensures state consistency while significantly improving throughput. Experimental results demonstrate that the algorithm achieves up to three times the throughput of the current state-of-the-art lock-free MCAS implementation and successfully eliminates ABA-related errors in practical scenarios.

This work addresses atomicity violations in concurrent programs—a prevalent source of concurrency bugs—by introducing AtomSanitizer, a novel stream-based conflict serializability detection algorithm. AtomSanitizer achieves a time complexity of O(nk²), substantially outperforming existing approaches, and integrates a lightweight runtime monitoring mechanism within the ThreadSanitizer (TSAN) framework to enable low-overhead, real-time atomicity validation. Experimental evaluation demonstrates that AtomSanitizer consistently outperforms state-of-the-art detectors on standard benchmarks, with both time and memory overheads comparable to those of TSAN’s data race detection, thereby offering an efficient solution for runtime atomicity monitoring in concurrent software.