concurrency control

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.

Existing user-space coroutine/fiber synchronization mechanisms implicitly assume kernel scheduling, introducing unnecessary latency on critical paths and limiting high-concurrency throughput. This paper proposes Combine-and-Exchange Scheduling (CES), a novel synchronization paradigm for purely user-space cooperative scheduling. CES eliminates cross-thread overhead by retaining critical sections on the same thread during lock contention, while dynamically redistributing parallelizable tasks to idle threads. Crucially, it co-designs user-space synchronization primitives with the scheduler to fully bypass kernel intervention. Experimental evaluation demonstrates that CES achieves up to 3× higher throughput on application-level benchmarks and up to 8× speedup on microbenchmarks—significantly outperforming state-of-the-art user-space synchronization approaches.

Static synchronization mechanisms in distributed systems impose severe scalability bottlenecks by enforcing strong consistency even in the absence of actual conflicts. This work introduces the “dynamic concurrency” paradigm—the first approach to perform fine-grained, runtime state–aware conflict detection: synchronization is triggered only when concurrent operations induce genuine dependency conflicts under the current data state. Methodologically, we design a state-aware, generic conflict predicate that integrates dynamic conflict detection with lightweight synchronization arbitration. Experimental evaluation shows that our approach significantly reduces redundant synchronization overhead, achieving 32%–68% higher throughput and 41% lower latency under typical distributed workloads, while preserving linearizability. The core contribution lies in elevating conflict detection from static, operation-level reasoning to dynamic, state-level reasoning—establishing a novel, efficient foundation for concurrency control in high-concurrency distributed systems.

Concurrent programming faces a fundamental tension between expressiveness and determinism; conventional shared-memory models suffer from schedule-dependent behavior and non-reproducible outputs due to destructive updates. Method: This paper introduces Clock-Synchronized Memory (CSM), the first shared-memory abstraction that guarantees deterministic semantics for general-purpose concurrent programs—extending beyond the restricted primitives (e.g., registers, signals) supported in traditional synchronous programming (SP). Grounded in the formal mathematical semantics of SP, we design CSM memory primitives, a clock-synchronization protocol, and rigorously defined access rules, ensuring full compatibility with existing SP compilation and verification toolchains. Results: Experiments demonstrate that CSM significantly enhances expressiveness, modularity, and code reusability of concurrent programs while preserving formal verifiability. It provides a theoretically sound and practically deployable deterministic concurrency infrastructure for safety-critical systems.

This work addresses performance bottlenecks—low throughput, high tail latency, and poor scalability—of distributed locks under high contention and geo-distributed active-active deployments. We propose a latency-aware distributed locking mechanism: leveraging multi-datacenter topology modeling, it integrates a lightweight consensus protocol design with latency-aware scheduling, achieving substantial reduction in cross-region coordination overhead while preserving strong consistency. Experimental results demonstrate a 68% throughput improvement and a 52% reduction in P99 latency under high contention, with near-linear scalability as the number of nodes increases. Unlike conventional centralized or classical distributed lock schemes, our approach is the first to achieve both high efficiency and scalability in geo-distributed active-active settings while guaranteeing linearizability. The proposed lock primitive offers practical deployability, flexibility across heterogeneous infrastructures, and serves as a next-generation foundation for large-scale distributed systems.

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 problem of determining whether barrier placements in a control flow graph guarantee synchronization of all threads across every execution. To this end, it introduces the first formal definitions of convergent nodes, convergent edges, and well-synchronized programs, along with a novel set of branch-and-merge inference rules. By integrating path-sensitive information with thread divergence analysis, the paper presents a bidirectional, linear-time worklist algorithm that efficiently performs static analysis of synchronization regions. The proposed method significantly enhances the compiler’s ability to optimize barriers on warp-synchronous hardware, achieving both theoretical rigor and practical efficiency.

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 addresses the challenge of coordination in large language model (LLM)-based multi-agent systems, where nondeterministic LLM behavior can lead to subtle, hard-to-detect errors such as deadlocks or message mismatches. The paper introduces ZipperGen, a novel framework that formally incorporates Message Sequence Charts (MSCs) into LLM-driven multi-agent coordination for the first time. It employs a domain-specific language to decouple communication structure from LLM behavior and uses syntax-guided projection to derive local agent programs from a global specification, guaranteeing deadlock freedom by construction. This approach enables a verifiable coordination mechanism that is disentangled from LLM nondeterminism and supports runtime generation of structurally sound workflows. The framework’s ability to independently verify coordination properties is demonstrated through its application to consensus protocol diagnostics.

This work addresses critical limitations in conventional LLM agent loop paradigms—namely implicit dependencies, unbounded recovery, and variable execution histories—which hinder debuggability and controllability. To overcome these issues, the paper introduces SGH, a structured graph framework that, for the first time, integrates classical scheduling theory into LLM agent execution. SGH explicitly models control flow using a static directed acyclic graph (DAG), cleanly separating planning, execution, and recovery into three distinct logical layers. It further incorporates a strict escalation protocol and formal node state machines to enforce rigorous execution semantics. The framework is systematically evaluated across 70 systems, analyzing trade-offs among controllability, expressiveness, and implementability, while providing formal guarantees of termination and correctness. Seven traceable experimental suites are designed to empirically validate its efficacy.