BestHub
Sign in
Tagged articles

Lock-Free

56 articles · Page 1 of 1
Architect's Guide
Architect's Guide
Aug 26, 2026 · Backend Development

10 Powerful Performance‑Optimization Techniques You Should Try

The article surveys ten practical performance‑optimization tactics—from classic indexing, compression, and caching to prefetching, peak‑shaving, batch processing, and advanced methods such as resource squeezing, horizontal scaling, sharding, and lock‑free designs—explaining their trade‑offs, concrete examples, and when to apply each in real‑world systems.

Batch ProcessingCachingCompression
0 likes · 36 min read
10 Powerful Performance‑Optimization Techniques You Should Try
Dabaoshi
Dabaoshi
Aug 16, 2026 · Fundamentals

CAS and Java Atomic Classes Explained: Mechanics, Pitfalls, and LongAdder

This article demystifies Java's Compare‑And‑Swap (CAS) instruction, shows how atomic classes like AtomicInteger achieve lock‑free increments, discusses CAS's three main drawbacks, surveys the entire java.util.concurrent.atomic family, and explains how LongAdder improves high‑contention counting.

Atomic ClassesCASConcurrency
0 likes · 15 min read
CAS and Java Atomic Classes Explained: Mechanics, Pitfalls, and LongAdder
Random Bulletin
Random Bulletin
Jul 22, 2026 · Backend Development

Lock Optimization at Ten‑Million QPS: From Coarse Locks to Lock‑Free Designs

When a service’s QPS jumps from two to eight million, a single global lock can turn a multi‑core machine into a bottleneck, so the article walks through coarse‑lock problems, fine‑grained locking, read‑write separation, optimistic reads, CAS‑based lock‑free techniques, LongAdder and advanced data structures, showing when each step is appropriate for high‑throughput systems.

CASJavaLock-Free
0 likes · 19 min read
Lock Optimization at Ten‑Million QPS: From Coarse Locks to Lock‑Free Designs
Thought Artisan
Thought Artisan
Jul 1, 2026 · Mobile Development

Android 17 Binder Observability: Lock-Free Observer V2 & Kernel Netlink Events

Android 17 enhances Binder observability with a lock-free SPSC queue, boot-stable sharding, exponential latency histograms, and CPU sampling in the user-space Observer V2, while introducing a kernel Netlink channel for asynchronous, zero-overhead IPC error events like frozen transactions and spam detection.

Android 17BinderIPC
0 likes · 8 min read
Android 17 Binder Observability: Lock-Free Observer V2 & Kernel Netlink Events
Rust High-Frequency Quantitative Trading
Rust High-Frequency Quantitative Trading
Jun 9, 2026 · Interview Experience

How to Build a Low‑Latency C++ Trading System for a Million‑Dollar Quant Interview

This article explains what interviewers expect when they ask about implementing a low‑latency C++ trading system, covering hardware‑level concepts such as cache hierarchy, false sharing, NUMA, kernel bypass, CPU pinning, lock‑free programming, memory‑order semantics, and modern C++ techniques that together achieve microsecond‑ or nanosecond‑scale determinism.

C++Lock-FreeNUMA
0 likes · 34 min read
How to Build a Low‑Latency C++ Trading System for a Million‑Dollar Quant Interview
Alibaba Cloud Observability
Alibaba Cloud Observability
Jan 26, 2026 · Cloud Native

How LoongCollector Delivers 10× Throughput and 80% Resource Savings in Cloud‑Native Observability

LoongCollector, the open‑source cloud‑native collector behind Alibaba Cloud's Simple Log Service, achieves ten‑fold higher throughput, up to 80% lower CPU and memory usage, near‑linear scaling, zero‑copy processing, lock‑free event pools and adaptive concurrency, while guaranteeing enterprise‑grade reliability for petabyte‑scale log and metric ingestion.

Lock-Freeadaptive-concurrencycloud-native
0 likes · 16 min read
How LoongCollector Delivers 10× Throughput and 80% Resource Savings in Cloud‑Native Observability
Ubiquitous Tech
Ubiquitous Tech
Jan 23, 2026 · Backend Development

Three Redis Inventory Decrement Lock Patterns Explained

The article analyzes three Redis inventory‑deduction locking strategies—exclusive lock, segmented lock, and lock‑free/key‑quantization—detailing their key structures, suitable scenarios, advantages, drawbacks, and also covers Lua‑script atomic decrement, async queue buffering, and local pre‑deduction techniques.

Exclusive LockInventoryLock-Free
0 likes · 8 min read
Three Redis Inventory Decrement Lock Patterns Explained
Deepin Linux
Deepin Linux
Sep 27, 2025 · Fundamentals

Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency

Lock‑free queues replace costly mutexes with atomic operations, eliminating lock contention, deadlocks, and scalability limits, and this article explains their principles, classic implementations, C++ code examples, performance testing, and real‑world applications such as game engines and high‑throughput servers.

C++CASConcurrency
0 likes · 38 min read
Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency
Tencent Cloud Developer
Tencent Cloud Developer
Apr 28, 2025 · Backend Development

Performance Optimization Techniques for High‑Throughput Backend Systems

The article outlines seven practical performance‑optimization techniques for high‑throughput back‑ends—including replacing protobuf with native C++ classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc, implementing lock‑free double buffers, simplifying structs for specific scenarios, and leveraging profiling tools—while stressing balanced, incremental improvements.

C++Cache FriendlyLock-Free
0 likes · 16 min read
Performance Optimization Techniques for High‑Throughput Backend Systems
BirdNest Tech Talk
BirdNest Tech Talk
Oct 20, 2024 · Fundamentals

Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler

This article dissects Go's runtime GPM model and the lock‑free runq data structure, detailing its fields, core operations such as runqput, runqget, runqgrab, and their atomic implementations, while also comparing local and global queues and illustrating the code paths with concrete examples.

ConcurrencyData StructuresGo
0 likes · 24 min read
Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler
BirdNest Tech Talk
BirdNest Tech Talk
Oct 14, 2024 · Backend Development

Why Go’s lock‑free PoolDequeue outperforms channels by 10×

This article examines Go’s internal lock‑free single‑producer multi‑consumer queues—PoolDequeue and its dynamic extension PoolChain—detailing their design, atomic operations, and benchmark comparisons that show they can be up to ten times faster than standard channels in a producer‑consumer workload.

BenchmarkConcurrencyGo
0 likes · 13 min read
Why Go’s lock‑free PoolDequeue outperforms channels by 10×
FunTester
FunTester
Aug 15, 2024 · Backend Development

9 Proven Techniques to Supercharge Service Performance

This article outlines nine practical methods—caching, parallelization, batch processing, data compression, lock‑free design, sharding, request avoidance, pooling, and asynchronous handling—demonstrating how each can be applied to backend services to dramatically reduce latency and improve throughput.

Batch ProcessingCachingCompression
0 likes · 25 min read
9 Proven Techniques to Supercharge Service Performance
vivo Internet Technology
vivo Internet Technology
Aug 14, 2024 · Backend Development

Understanding Disruptor: High‑Performance In‑Memory Queue, Core Concepts, Demo, and Source Code Analysis

The article explains the Disruptor—an intra‑process, lock‑free, array‑based queue that achieves millions of operations per second—by covering its core concepts, demo code, source‑code mechanics, performance optimizations such as pre‑allocation and false‑sharing avoidance, and real‑world Vivo iTheme applications with best‑practice tips.

DisruptorHigh PerformanceJava
0 likes · 29 min read
Understanding Disruptor: High‑Performance In‑Memory Queue, Core Concepts, Demo, and Source Code Analysis
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 13, 2024 · Backend Development

Understanding Java Atomic Variables and Their Applications in Concurrent Programming

This article provides a comprehensive guide to Java atomic variables, explaining their core concepts, underlying CAS mechanism, key classes such as AtomicInteger, AtomicLong, AtomicReference, and AtomicBoolean, and demonstrating practical code examples, use‑cases, performance benefits, limitations, and comparisons with traditional lock‑based synchronization.

Atomic VariablesCASConcurrency
0 likes · 21 min read
Understanding Java Atomic Variables and Their Applications in Concurrent Programming
Su San Talks Tech
Su San Talks Tech
May 11, 2024 · Backend Development

Unlock Ultra‑Fast Java Concurrency with the Disruptor Framework

Disruptor is an open‑source, lock‑free Java framework that uses a ring‑buffer and sequencer to achieve ultra‑high‑throughput, handling millions of events per second, and is employed by projects like LMAX, Storm, Camel, and Log4j2, with detailed concepts, wait strategies, and usage examples.

ConcurrencyDisruptorJava
0 likes · 13 min read
Unlock Ultra‑Fast Java Concurrency with the Disruptor Framework
FunTester
FunTester
Apr 12, 2024 · Backend Development

Performance Optimization Techniques for Backend Systems: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Data Structures

The article presents practical backend performance optimization methods—including substituting Protobuf with native C++ classes, employing cache‑friendly data structures, integrating jemalloc/tcmalloc, using lock‑free double‑buffer designs, and tailoring data formats—to achieve up to three‑fold speed improvements and significant latency reductions.

C++Cache FriendlyLock-Free
0 likes · 15 min read
Performance Optimization Techniques for Backend Systems: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Data Structures
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 15, 2024 · Fundamentals

Unlocking High-Performance Multithreading: Lock-Free Techniques in iLogtail

This article explores the fundamentals of multithreaded programming, comparing traditional lock-based synchronization with advanced lock-free techniques, and demonstrates how iLogtail implements thread models, memory barriers, atomic operations, spin locks, double-buffering, and deferred reclamation to achieve scalable, high-performance concurrency.

C++Lock-FreeiLogtail
0 likes · 25 min read
Unlocking High-Performance Multithreading: Lock-Free Techniques in iLogtail
Architect
Architect
Mar 12, 2024 · Backend Development

Boost C++ Service Performance: 3× Faster with Classes, Cache‑Friendly Structures, jemalloc and Lock‑Free Designs

This article walks through a series‑by‑step performance‑tuning process for high‑throughput C++ services, replacing Protobuf with plain classes, adopting cache‑friendly hash tables, switching to jemalloc, implementing a double‑buffer lock‑free data structure, and tailoring data formats, each backed by concrete code examples, benchmark results, and analysis of trade‑offs.

BenchmarkC++Cache Friendly
0 likes · 20 min read
Boost C++ Service Performance: 3× Faster with Classes, Cache‑Friendly Structures, jemalloc and Lock‑Free Designs
High Availability Architecture
High Availability Architecture
Mar 6, 2024 · Backend Development

Performance Optimization Techniques: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Designs

This article presents practical performance‑optimization strategies for high‑throughput C++ services, including replacing Protobuf with hand‑written classes, adopting cache‑friendly data structures, using jemalloc/tcmalloc instead of the default allocator, employing lock‑free double‑buffer designs, tailoring data formats for specific workloads, and leveraging profiling tools to measure gains.

C++Cache FriendlyLock-Free
0 likes · 17 min read
Performance Optimization Techniques: Replacing Protobuf with C++ Classes, Cache‑Friendly Structures, jemalloc, and Lock‑Free Designs
Tencent Cloud Developer
Tencent Cloud Developer
Feb 29, 2024 · Backend Development

Performance Optimization Strategies for High‑Throughput Backend Services

The article outlines practical, continuous performance‑optimization tactics for high‑throughput back‑end services—replacing Protobuf with lightweight C++ classes, using cache‑friendly data structures, adopting jemalloc/tcmalloc, employing lock‑free double buffers, tailoring data formats, and leveraging profiling tools—to achieve multi‑fold speedups while balancing maintainability.

BackendC++Cache Friendly
0 likes · 18 min read
Performance Optimization Strategies for High‑Throughput Backend Services
Cognitive Technology Team
Cognitive Technology Team
Oct 5, 2023 · Backend Development

Lock‑Free Concurrency in Java: CAS, volatile and JUC Utilities

This article explains how Java achieves lock‑free concurrency using CAS and volatile for optimistic locking, discusses its advantages and drawbacks such as the ABA problem and contention hotspots, and presents solutions including versioned CAS classes and contention‑reduction techniques provided by the JUC package.

CASConcurrencyJUC
0 likes · 6 min read
Lock‑Free Concurrency in Java: CAS, volatile and JUC Utilities
Baidu Intelligent Cloud Tech Hub
Baidu Intelligent Cloud Tech Hub
May 25, 2023 · Cloud Native

How Baidu’s CFS Achieved Billion‑File Scale with a Lock‑Free Metadata Service

This article explains the design and evolution of Baidu Cloud File System's (CFS) metadata service, detailing how a novel lock‑free architecture and strategic data layout enable POSIX‑compatible, highly scalable storage that can handle billions of files while maintaining high performance and consistency.

Lock-Freecloud storagedistributed file system
0 likes · 42 min read
How Baidu’s CFS Achieved Billion‑File Scale with a Lock‑Free Metadata Service
ITPUB
ITPUB
Feb 18, 2023 · Backend Development

Mastering High‑Performance Backend: Lock‑Free, Zero‑Copy, Serialization, and More

This comprehensive guide explores essential backend techniques—including lock‑free programming, zero‑copy I/O, efficient serialization, pooling, concurrency, async processing, caching strategies, sharding, storage optimizations, and queue mechanisms—to build high‑performance, scalable services while highlighting practical code examples and real‑world trade‑offs.

BackendCachingHigh Performance
0 likes · 51 min read
Mastering High‑Performance Backend: Lock‑Free, Zero‑Copy, Serialization, and More
Selected Java Interview Questions
Selected Java Interview Questions
Dec 7, 2022 · Backend Development

Understanding Java Disruptor: Queues, Core Components, and High‑Performance Lock‑Free Design

This article introduces various Java queue implementations, explains the Disruptor framework’s architecture, demonstrates its usage with complete code examples, and analyzes core components such as RingBuffer, Sequencer, and WaitStrategy while addressing performance issues like false sharing and multi‑producer coordination.

DisruptorFalse sharingJava
0 likes · 12 min read
Understanding Java Disruptor: Queues, Core Components, and High‑Performance Lock‑Free Design
Senior Brother's Insights
Senior Brother's Insights
Jul 21, 2022 · Backend Development

Mastering Java CAS: How AtomicInteger Achieves Lock‑Free Concurrency

This article explains the fundamentals of Compare‑And‑Swap (CAS), its implementation in Java through the Unsafe class, demonstrates AtomicInteger's lock‑free operations, and discusses CAS drawbacks such as spin‑wait overhead, single‑variable limitation, and the ABA problem with mitigation strategies.

ABA problemCASLock-Free
0 likes · 15 min read
Mastering Java CAS: How AtomicInteger Achieves Lock‑Free Concurrency
Cognitive Technology Team
Cognitive Technology Team
May 22, 2022 · Fundamentals

Lock‑Free (Non‑Blocking) Algorithms and Their Implementation in Java

Lock‑free (non‑blocking) algorithms replace traditional locks with hardware primitives such as compare‑and‑swap (CAS) to ensure data consistency during concurrent access, offering superior scalability and eliminating deadlocks, and the article explains Java’s atomic variables, CAS‑based implementations, and how to address the ABA problem with AtomicStampedReference.

ABACASConcurrency
0 likes · 5 min read
Lock‑Free (Non‑Blocking) Algorithms and Their Implementation in Java
Code Ape Tech Column
Code Ape Tech Column
May 17, 2022 · Fundamentals

Understanding Compare‑And‑Swap (CAS), Its Mechanisms, and Common Pitfalls

This article explains the fundamentals of the compare‑and‑swap (CAS) atomic primitive, how CPUs guarantee its atomicity through bus and cache locking, illustrates a Java spin‑lock implementation using CAS, and discusses typical issues such as single‑variable limitation, long spin times, and the ABA problem with mitigation strategies.

ABA problemCASConcurrency
0 likes · 9 min read
Understanding Compare‑And‑Swap (CAS), Its Mechanisms, and Common Pitfalls
Tencent Cloud Developer
Tencent Cloud Developer
Mar 30, 2022 · Backend Development

Go High-Performance Programming: Concurrency Optimization Techniques

This article, the second in a Go high‑performance series, details concurrency optimizations including lock‑free data structures versus locked lists, sharding and RWMutex to cut lock contention, controlling goroutine creation with pooling, using sync.Once for cheap one‑time initialization, and employing sync.Cond for efficient goroutine notification.

BenchmarkConcurrencyGo
0 likes · 30 min read
Go High-Performance Programming: Concurrency Optimization Techniques
Baidu Geek Talk
Baidu Geek Talk
Jun 16, 2021 · Fundamentals

Concurrent Optimization Techniques in C++: SIMD, Out‑of‑Order Execution, and Lock‑Free/Wait‑Free Algorithms

The article reviews Baidu C++ engineers' concurrency optimizations, explaining why modern software must exploit parallelism and detailing SIMD vectorization, out‑of‑order execution, and micro‑architectural analysis, then compares mutex, lock‑free, and wait‑free synchronization, showcasing case studies where atomic and wait‑free designs dramatically improve multithreaded performance.

ConcurrencyLock-FreePerformance Optimization
0 likes · 35 min read
Concurrent Optimization Techniques in C++: SIMD, Out‑of‑Order Execution, and Lock‑Free/Wait‑Free Algorithms
Top Architect
Top Architect
Apr 6, 2021 · Backend Development

Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free

The article explains how Java 8's ConcurrentHashMap implements a lock‑free get() operation by replacing the Segment design with Node objects, using volatile fields and CAS, and how the volatile‑marked table array ensures visibility during resizing, making reads both safe and efficient.

ConcurrencyConcurrentHashMapJava
0 likes · 10 min read
Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free
Top Architect
Top Architect
Mar 11, 2021 · Fundamentals

Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free

This article explains how Java 8's ConcurrentHashMap implements the get operation without acquiring locks by using volatile fields, CAS, and a simplified node structure, contrasting it with the segment‑based design of JDK 1.7 and detailing the memory‑visibility guarantees provided by volatile.

ConcurrencyConcurrentHashMapJDK8
0 likes · 9 min read
Why ConcurrentHashMap.get() in Java 8 Is Lock‑Free
21CTO
21CTO
Jan 12, 2021 · Fundamentals

How to Build a Lock‑Free Queue Using CAS: Step‑by‑Step Guide

This article explains the fundamentals of lock‑free queues, covering CAS and other atomic operations, detailed enqueue and dequeue implementations, the ABA problem and its solutions, as well as array‑based lock‑free queue designs, providing code examples and practical insights.

ABA problemCASLock-Free
0 likes · 15 min read
How to Build a Lock‑Free Queue Using CAS: Step‑by‑Step Guide
JavaEdge
JavaEdge
Oct 8, 2020 · Backend Development

How Disruptor Achieves Lock-Free Speed: Single-Threaded Writes, Memory Barriers, and False Sharing

This article explains how the Disruptor library attains true lock‑free performance through single‑threaded writes, the use of memory barriers (volatile and happens‑before semantics), cache‑line alignment to eliminate false sharing, and a sequence‑barrier algorithm, providing code examples and practical optimization tips.

DisruptorFalse sharingJava concurrency
0 likes · 5 min read
How Disruptor Achieves Lock-Free Speed: Single-Threaded Writes, Memory Barriers, and False Sharing
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 22, 2020 · Backend Development

Understanding AtomicInteger, CAS, and Lock‑Free Concurrency in Java

This article explains how Java's AtomicInteger and related atomic classes provide lock‑free thread‑safe operations to replace non‑atomic constructs like i++, detailing their inheritance, underlying Unsafe mechanisms, CAS implementation, memory barriers, optimistic locking, the ABA problem, and practical code examples for increment, decrement, and custom CAS‑based locks.

CASConcurrencyJava
0 likes · 15 min read
Understanding AtomicInteger, CAS, and Lock‑Free Concurrency in Java
Laravel Tech Community
Laravel Tech Community
May 28, 2020 · Backend Development

Using Swoole Atomic for Lock‑Free Counters in PHP

Because PHP lacks native multithreading, Swoole adopts a multi‑process model and provides the Atomic class for lock‑free integer operations, which can be shared across worker processes; this guide explains its purpose, configuration, usage patterns, code examples, and important pitfalls.

BackendConcurrencyLock-Free
0 likes · 3 min read
Using Swoole Atomic for Lock‑Free Counters in PHP
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 13, 2020 · Databases

How HotRing Boosts In-Memory KV Store Performance by 2.58×

The article introduces HotRing, a hotspot‑aware in‑memory key‑value store from Alibaba's Tair team, explains the extreme traffic challenges of Alibaba's Double‑11 peak, details the design of ordered‑ring hashing, dynamic hotspot detection, lock‑free concurrency and rehashing, and shows how these innovations achieve up to 2.58× higher throughput than existing KV systems.

HotRingLock-FreeRCU
0 likes · 16 min read
How HotRing Boosts In-Memory KV Store Performance by 2.58×
FunTester
FunTester
Feb 24, 2020 · Backend Development

Achieving Thread‑Safe Java Performance Tests Without Locks

This article explains why traditional locking harms Java performance‑testing throughput, introduces lock‑free alternatives such as CAS and ThreadLocal, and provides a complete Java demo that shows how each thread can hold its own object to eliminate contention and boost speed.

ConcurrencyJavaLock-Free
0 likes · 5 min read
Achieving Thread‑Safe Java Performance Tests Without Locks
JavaEdge
JavaEdge
Jan 6, 2020 · Fundamentals

Understanding Java CAS: How Compare‑And‑Swap Powers Lock‑Free Concurrency

This article explains the Compare‑And‑Swap (CAS) primitive, its three operands, how Java's Unsafe class implements CAS methods, the internal workings of AtomicInteger, common pitfalls like spinning, single‑variable limits and the ABA problem, and the enhancements introduced in Java 8.

CASConcurrencyJDK8
0 likes · 9 min read
Understanding Java CAS: How Compare‑And‑Swap Powers Lock‑Free Concurrency
Programmer DD
Programmer DD
Aug 17, 2018 · Fundamentals

How LinkedTransferQueue Works: The Smart Lock‑Free Queue Behind Java Concurrency

LinkedTransferQueue, introduced in JDK 7, combines the capacity of traditional BlockingQueues with the lock‑free behavior of SynchronousQueue, using a sophisticated node‑based algorithm that matches producers and consumers without locking the whole queue, offering high‑performance concurrent data transfer.

BlockingQueueConcurrencyJava
0 likes · 16 min read
How LinkedTransferQueue Works: The Smart Lock‑Free Queue Behind Java Concurrency
Programmer DD
Programmer DD
Jul 18, 2018 · Backend Development

How Does Java’s ConcurrentLinkedQueue Achieve Lock‑Free Thread Safety?

This article explains the lock‑free design of Java's ConcurrentLinkedQueue, detailing its core invariants, the internal Node structure, and step‑by‑step analyses of the offer and poll methods with code snippets and visual illustrations to demystify its CAS‑based concurrency mechanisms.

CASConcurrentLinkedQueueJava
0 likes · 13 min read
How Does Java’s ConcurrentLinkedQueue Achieve Lock‑Free Thread Safety?
Qunar Tech Salon
Qunar Tech Salon
May 29, 2018 · Backend Development

Async Mutex: Eliminating Blocking in High‑Performance Concurrent Java Programs

This article analyses the performance challenges of high‑concurrency Java applications, explains how misuse of atomic operations and blocking degrade throughput, introduces an asynchronous monitor concept and a concrete AsyncMutex implementation, and presents experimental results showing its scalability advantages over traditional ReentrantLock‑based locking.

ConcurrencyJavaLock-Free
0 likes · 15 min read
Async Mutex: Eliminating Blocking in High‑Performance Concurrent Java Programs
Java Backend Technology
Java Backend Technology
Oct 31, 2017 · Backend Development

Unlock High-Performance Java with Lock-Free Concurrency and Atomic Classes

This article explains how lock-free techniques such as Compare-And-Swap (CAS) and Java's atomic classes—including AtomicBoolean, AtomicInteger, AtomicReference, and their array and field updaters—provide optimistic concurrency control, reduce context switches, and improve performance compared to traditional locking mechanisms.

CASConcurrencyJava
0 likes · 11 min read
Unlock High-Performance Java with Lock-Free Concurrency and Atomic Classes
Meituan Technology Team
Meituan Technology Team
Nov 18, 2016 · Backend Development

Understanding the Disruptor: High‑Performance Java Queue and Its Implementation

The Disruptor library provides a lock‑free, CAS‑driven ring‑buffer queue that eliminates lock contention and false sharing, delivering 4–7× higher throughput and nanosecond‑level latency compared to Java’s built‑in queues, and is employed by systems such as Log4j 2, Apache Storm, and Meituan‑Dianping.

ConcurrencyDisruptorJava
0 likes · 21 min read
Understanding the Disruptor: High‑Performance Java Queue and Its Implementation
Qunar Tech Salon
Qunar Tech Salon
Aug 3, 2016 · Backend Development

Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies

The article analyzes write‑mostly, read‑light cache scenarios such as driver location updates and counter increments, discusses lock bottlenecks, proposes horizontal sharding and per‑record locking, explores lock‑free approaches with data‑integrity signatures, and summarizes practical optimization techniques for high‑concurrency back‑end systems.

ConcurrencyLock-Freecache
0 likes · 8 min read
Optimizing Write‑Heavy High‑Concurrency Cache: Lock Granularity, Horizontal Sharding, and Lock‑Free Strategies
Alibaba Cloud Infrastructure
Alibaba Cloud Infrastructure
Jul 8, 2015 · Operations

Design and Implementation of High‑Concurrency (C10M) Load Balancing in Alibaba's AGW Middlebox

The article analyzes the challenges of scaling network devices to handle ten‑million concurrent connections (C10M) and describes Alibaba's AGW solution, which uses lock‑free data planes, hugepages, NUMA‑aware memory placement, and user‑space NIC drivers to achieve high‑performance four‑layer load balancing.

C10MLock-FreeNUMA
0 likes · 9 min read
Design and Implementation of High‑Concurrency (C10M) Load Balancing in Alibaba's AGW Middlebox