Tagged articles

32 articles

Page 1 of 1

Apr 20, 2026 · Backend Development

Avoid Hidden Thread‑Safety Bugs in Spring Boot 3: 6 Common Pitfalls and Fixes

This article examines six typical concurrency mistakes in Spring Boot 3—misusing volatile, unsafe ConcurrentHashMap patterns, exposing mutable collections, removing synchronized, abusing parallel streams, and invisible shutdown flags—showing why they occur and providing concrete, thread‑safe code replacements.

ConcurrentHashMapJavaSpring Boot

0 likes · 9 min read

Avoid Hidden Thread‑Safety Bugs in Spring Boot 3: 6 Common Pitfalls and Fixes

BirdNest Tech Talk

Oct 9, 2025 · Fundamentals

What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety

Over the past two years, Go’s sync and sync/atomic packages have introduced new APIs like WaitGroup.Go, enhanced Map methods, modernized atomic types, restructured internal implementations, and added developer‑friendly safeguards such as noCopy, all aimed at improving usability, safety, and performance for concurrent Go programs.

APIGoatomic

0 likes · 12 min read

What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety

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++CASQueue

0 likes · 38 min read

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

Cognitive Technology Team

Jul 22, 2025 · Fundamentals

Why Non‑Blocking Algorithms Outperform Blocking Ones in Java Concurrency

This article explains the principles of non‑blocking algorithms, compares them with blocking concurrency approaches, and demonstrates Java implementations using volatile variables, atomic classes, optimistic locking, and templates, highlighting their advantages and challenges in multithreaded environments.

AlgorithmsNon-blockingatomic

0 likes · 24 min read

Why Non‑Blocking Algorithms Outperform Blocking Ones in Java Concurrency

Cognitive Technology Team

May 17, 2025 · Fundamentals

Should Go’s Memory Model Evolve? Proposals for Sync and Atomic API Guarantees

This article reviews the Go memory model first written in 2009, highlights missing documentation for sync and sync/atomic APIs, proposes concrete textual and typed‑atomic extensions, and explains why certain compiler optimizations must remain prohibited to preserve clear, race‑free semantics.

GoHappens-beforeMemory Model

0 likes · 24 min read

Should Go’s Memory Model Evolve? Proposals for Sync and Atomic API Guarantees

FunTester

Feb 18, 2025 · Fundamentals

Understanding Mutex Locks and Their Use in Go Concurrency

This article explains what a mutex is, why it is needed in concurrent programming, shows basic lock/unlock operations with Go code examples, compares mutexes with atomic operations, and provides best‑practice guidelines to avoid deadlocks and improve performance.

Synchronizationatomicconcurrency

0 likes · 8 min read

Understanding Mutex Locks and Their Use in Go Concurrency

Architecture Development Notes

Jan 26, 2025 · Fundamentals

Master Lock-Free Programming in Rust: Atomic Operations & Memory Ordering

This guide explains how to build high‑performance lock‑free data structures in Rust by using atomic operations, memory ordering semantics, and practical examples such as a thread‑safe counter and a lock‑free stack, followed by best‑practice recommendations.

atomicconcurrencylock‑free

0 likes · 4 min read

Master Lock-Free Programming in Rust: Atomic Operations & Memory Ordering

Raymond Ops

Jan 25, 2025 · Backend Development

Master Go Concurrency: Goroutines, Scheduler, and Synchronization Techniques

This article explains Go's concurrency model, detailing how goroutines are scheduled on logical processors, how to create and manage them, detect and resolve race conditions using atomic operations, mutexes, and channels, and demonstrates practical code examples for each concept.

BackendChannelatomic

0 likes · 19 min read

Master Go Concurrency: Goroutines, Scheduler, and Synchronization Techniques

BirdNest Tech Talk

Jan 15, 2025 · Backend Development

Data Race vs Race Condition in Go: Clear Differences and How to Fix Them

The article explains the distinction between a data race—simultaneous unsynchronized memory access by goroutines—and a race condition—logic errors caused by timing dependencies—using Go code examples, demonstrates how to reproduce each issue, and shows how mutexes or atomic operations can resolve them.

GoGoroutineatomic

0 likes · 5 min read

Data Race vs Race Condition in Go: Clear Differences and How to Fix Them

Raymond Ops

Jan 9, 2025 · Backend Development

Master Go Concurrency: Goroutines, Scheduler, Race Detection, and Channels Explained

This article walks through Go's concurrency model, detailing how goroutines are scheduled across logical processors, how to control parallelism with GOMAXPROCS, detect and resolve race conditions using atomic operations, mutexes, and channels, and provides practical code examples for each concept.

ChannelsGoGoroutine

0 likes · 18 min read

Master Go Concurrency: Goroutines, Scheduler, Race Detection, and Channels Explained

MaGe Linux Operations

Sep 28, 2024 · Backend Development

Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization

This comprehensive guide explains the fundamentals of concurrent programming in Go, covering the differences between parallelism and concurrency, process and thread concepts, and detailed usage of goroutines, channels, select statements, timers, mutexes, read‑write locks, wait groups, once, sync.Map, and atomic operations with practical code examples and diagrams.

ChannelGoroutineParallelism

0 likes · 42 min read

Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization

MaGe Linux Operations

Sep 11, 2024 · Backend Development

Mastering Go Concurrency: Goroutines, Channels, and Synchronization Explained

This article provides a comprehensive guide to Go's concurrency model, covering goroutine creation, the scheduler, communication via channels, handling race conditions, and synchronization techniques using atomic operations and mutexes, complete with practical code examples and visual diagrams.

ChannelGoGoroutine

0 likes · 27 min read

Mastering Go Concurrency: Goroutines, Channels, and Synchronization Explained

Architecture Development Notes

Jul 20, 2024 · Backend Development

Master Go Concurrency: Mutex, RWMutex, Cond, Atomic, Once & WaitGroup Explained

This article explores Go's built‑in concurrency primitives—including Mutex, RWMutex, Condition variables, atomic operations, sync.Once, and WaitGroup—detailing their purposes, usage patterns, and best‑practice guidelines to write correct and efficient concurrent programs.

GoroutineRWMutexatomic

0 likes · 13 min read

Master Go Concurrency: Mutex, RWMutex, Cond, Atomic, Once & WaitGroup Explained

Meituan Technology Team

Jul 18, 2024 · Fundamentals

Multithreading Programming: Concepts, Synchronization, and Best Practices

Multithreaded programming splits tasks across logical and hardware threads to exploit multicore CPUs, requiring careful use of synchronization primitives such as mutexes, read‑write locks, condition variables, and lock‑free atomics, while avoiding pitfalls like race conditions, deadlocks, and false sharing for correct, high‑performance software.

CLockSynchronization

0 likes · 65 min read

Multithreading Programming: Concepts, Synchronization, and Best Practices

MaGe Linux Operations

Apr 20, 2024 · Backend Development

Mastering Go Concurrency: Goroutines, Scheduler, Race Detection & Channels

This article explains Go's concurrency model, detailing how goroutines are scheduled onto logical processors, how to create and run them, handle race conditions with atomic operations, mutexes, and the race detector, and share data safely using unbuffered and buffered channels with practical code examples.

ChannelGoGoroutine

0 likes · 19 min read

Mastering Go Concurrency: Goroutines, Scheduler, Race Detection & Channels

MaGe Linux Operations

Apr 4, 2024 · Backend Development

Mastering Go Concurrency: Goroutines, Scheduler, and Safe Data Sharing

This article explains Go's concurrency model, detailing how goroutines are scheduled onto logical processors, how to create and run them, detect and resolve race conditions with atomic operations, mutexes, and channels, and demonstrates buffered versus unbuffered channel communication.

ChannelGoGoroutine

0 likes · 18 min read

Mastering Go Concurrency: Goroutines, Scheduler, and Safe Data Sharing

IT Services Circle

Mar 17, 2024 · Backend Development

Understanding the volatile Keyword in Java Concurrency

This article explains the Java volatile keyword, covering its underlying principles, effects on visibility and instruction reordering, appropriate usage scenarios, limitations, and provides a practical code example demonstrating how volatile ensures thread visibility and prevents dead loops in multithreaded programs.

CASJavaatomic

0 likes · 6 min read

Understanding the volatile Keyword in Java Concurrency

ITPUB

Jan 7, 2024 · Backend Development

Why Redis Distributed Locks Fail and How to Fix Leak and Mis‑release Issues

A Redis lock timeout caused users to be blocked for two hours, revealing problems with lock leakage and mis‑release; the article explains the root causes, proper use of SETNX with EXPIRE, and Lua scripts for atomic operations and safe lock deletion.

ExpireLuaatomic

0 likes · 7 min read

Why Redis Distributed Locks Fail and How to Fix Leak and Mis‑release Issues

php Courses

Nov 2, 2023 · Backend Development

Handling Concurrent Access and Race Conditions in PHP

This article explains essential techniques for managing concurrent access and race conditions in PHP, covering mutex locks, semaphores, atomic operations, queue-based processing, database access optimization, and transaction management to improve system reliability and performance.

PHPatomicconcurrency

0 likes · 5 min read

Handling Concurrent Access and Race Conditions in PHP

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.

CASJUCJava

0 likes · 6 min read

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

Mike Chen's Internet Architecture

Sep 27, 2022 · Backend Development

Four Common Ways to Implement Thread Synchronization in Java

This article explains the concept of thread synchronization in Java and provides detailed examples of four implementation methods—using the synchronized keyword, ReentrantLock, atomic variables, and ThreadLocal—along with code snippets and a comparison of their advantages and usage scenarios.

ReentrantLockThreadLocalatomic

0 likes · 6 min read

Four Common Ways to Implement Thread Synchronization in Java

Tencent Cloud Developer

Jul 25, 2022 · Backend Development

Understanding Go Concurrency: Goroutines, Scheduler, Threads and Synchronization

The article explains Go’s concurrency model, detailing how goroutines are lightweight work units scheduled by the Go runtime onto logical processors, the role of the scheduler, differences between concurrency and parallelism, thread limits, and practical synchronization tools such as WaitGroup, atomic operations, and mutexes.

GoSchedulerSynchronization

0 likes · 19 min read

Understanding Go Concurrency: Goroutines, Scheduler, Threads and Synchronization

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.

ABACASJava

0 likes · 5 min read

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

Programmer DD

Oct 23, 2020 · Databases

Mastering Redis Lua Scripting: Essential Syntax and Best Practices

This article explains how Redis introduced Lua scripting to combine multiple commands atomically, covers Lua basics, data types, control structures, script execution with EVAL/EVALSHA, script management commands, and practical tips for writing efficient, safe Redis Lua scripts.

CacheLuaScripting

0 likes · 14 min read

Mastering Redis Lua Scripting: Essential Syntax and Best Practices

Top Architect

Sep 4, 2020 · Fundamentals

Understanding the volatile Keyword and Thread Synchronization in Java

This article explains how the volatile keyword ensures visibility of shared variables across threads, illustrates its behavior with examples and code, discusses its limitations regarding atomicity, and presents solutions using synchronized blocks or atomic classes for proper thread synchronization in Java.

JavaSynchronizationatomic

0 likes · 8 min read

Understanding the volatile Keyword and Thread Synchronization in Java

Programmer DD

Jul 16, 2020 · Backend Development

Why Volatile Isn't Enough: Understanding Java Thread Visibility and Synchronization

This article explains how the volatile keyword guarantees visibility of shared variables across threads, demonstrates its limitations with non‑atomic operations, and shows how to achieve proper thread synchronization using atomic classes or synchronized blocks in Java.

Javaatomicthread visibility

0 likes · 10 min read

Why Volatile Isn't Enough: Understanding Java Thread Visibility and Synchronization

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.

BackendPHPServer

0 likes · 3 min read

Using Swoole Atomic for Lock‑Free Counters in PHP

Xiaokun's Architecture Exploration Notes

Feb 4, 2020 · Fundamentals

Unlocking Java’s CAS: How Unsafe Powers Atomic Operations and Solves ABA

This article explains the Compare‑and‑Swap (CAS) mechanism, its hardware‑level implementation via Java’s Unsafe class, provides sample code for basic CAS, atomic adders, custom atomic types, analyzes the ABA problem, and presents solutions such as versioned stamps and AtomicStampedReference.

CASJavaatomic

0 likes · 10 min read

Unlocking Java’s CAS: How Unsafe Powers Atomic Operations and Solves ABA

Java Captain

Sep 25, 2018 · Fundamentals

Optimistic vs Pessimistic Locks and CAS Implementation in Java

The article explains the concepts of pessimistic and optimistic locking, details how CAS (Compare‑And‑Swap) implements optimistic locks in Java, discusses their advantages, drawbacks such as the ABA problem and high spin costs, and compares CAS usage with synchronized blocks in concurrent programming.

CASJava concurrencySynchronization

0 likes · 14 min read

Optimistic vs Pessimistic Locks and CAS Implementation in Java

360 Zhihui Cloud Developer

Sep 18, 2018 · Backend Development

How to Implement Non‑Reentrant Functions in Go: Mutex and Atomic Solutions

This article explains what a non‑reentrant function is, why it matters in concurrent Go programs, and demonstrates two practical implementations—using a sync.Mutex and an atomic flag—to ensure a function runs only once at any given time.

GoGoroutineatomic

0 likes · 5 min read

How to Implement Non‑Reentrant Functions in Go: Mutex and Atomic Solutions

dbaplus Community

Jun 12, 2018 · Fundamentals

Master Java Concurrency: Memory Model, Atomic Operations, and Thread Pools Explained

This article walks through Java's concurrency fundamentals, covering the Java Memory Model, thread communication, atomic classes, synchronization techniques, safe object publication, and practical thread‑pool usage, while highlighting common pitfalls and performance considerations.

JMMJavaThreadPool

0 likes · 25 min read

Master Java Concurrency: Memory Model, Atomic Operations, and Thread Pools Explained

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.

CASJavaatomic

0 likes · 11 min read

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