BestHub
Sign in
Tagged articles

synchronization

223 articles · Page 2 of 3
Tencent Cloud Developer
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.

Goatomicmutex
0 likes · 19 min read
Understanding Go Concurrency: Goroutines, Scheduler, Threads and Synchronization
Sohu Tech Products
Sohu Tech Products
Jul 13, 2022 · Mobile Development

What Is a Lock? Understanding iOS Synchronization Primitives

This article explains the concept of locks in iOS, describing their purpose, the actions of acquiring and releasing, common lock types such as spin locks, mutexes, semaphores, and their implementations using OSSpinLock, pthread_mutex, NSCondition, NSLock, recursive locks, and read‑write locks, along with performance considerations and underlying principles.

LocksconcurrencyiOS
0 likes · 19 min read
What Is a Lock? Understanding iOS Synchronization Primitives
Java Architect Essentials
Java Architect Essentials
Jul 3, 2022 · Backend Development

Thread Safety Issues of SimpleDateFormat.parse() and format() Methods and Their Solutions

This article explains why SimpleDateFormat.parse() and SimpleDateFormat.format() are not thread‑safe in Java, analyzes the underlying causes involving shared Calendar objects, and presents three practical solutions—including per‑thread instances, synchronized blocks, and ThreadLocal usage—to eliminate concurrency bugs.

Date ParsingSimpleDateFormatThread Safety
0 likes · 11 min read
Thread Safety Issues of SimpleDateFormat.parse() and format() Methods and Their Solutions
Programmer DD
Programmer DD
Jun 29, 2022 · Fundamentals

Why Real-World Analogies Reveal the 3 Core Challenges of Concurrent Programming

The article explains that concurrent programming is deeply tied to real-life scenarios and outlines its three core problems—division of work, synchronization, and mutual exclusion—using company organization, task dependencies, and traffic flow analogies, plus Java code examples to illustrate each concept.

concurrencyjavamultithreading
0 likes · 9 min read
Why Real-World Analogies Reveal the 3 Core Challenges of Concurrent Programming
JavaEdge
JavaEdge
Jun 2, 2022 · Backend Development

How Does Java’s synchronized Work? A Deep Dive into Lock Mechanisms

This article simulates a Baidu interview to explain the underlying implementation of Java’s synchronized keyword, covering monitorenter/monitorexit bytecode, object header Mark Word, lock states, lock escalation from biased to heavyweight, and the role of CAS in lock acquisition and release.

JVMLockconcurrency
0 likes · 10 min read
How Does Java’s synchronized Work? A Deep Dive into Lock Mechanisms
Java Backend Technology
Java Backend Technology
May 23, 2022 · Backend Development

Is Your Spring MVC Controller Thread‑Safe? Understand and Fix It

This article explains what thread safety means, demonstrates how a simple counter can become unsafe under concurrent requests, shows Java code examples of the problem and its synchronized solution, and provides practical guidelines for ensuring Spring MVC controllers remain thread‑safe by avoiding shared mutable state or using synchronization mechanisms such as synchronized blocks or ThreadLocal.

ControllerJava concurrencyThread Safety
0 likes · 5 min read
Is Your Spring MVC Controller Thread‑Safe? Understand and Fix It
Top Architect
Top Architect
Apr 27, 2022 · Fundamentals

Understanding Thread Safety, Synchronization, and Locks in Java

This article explains the fundamentals of thread safety in Java, illustrating common pitfalls in producer‑consumer scenarios, demonstrating how synchronized, wait/notify, and the explicit Lock/Condition mechanisms can be used to avoid data races, deadlocks, and inconsistent state while providing complete code examples.

LockThread Safetyconcurrency
0 likes · 20 min read
Understanding Thread Safety, Synchronization, and Locks in Java
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Apr 22, 2022 · Fundamentals

Understanding Linux Kernel Mutex: Mechanism, Data Structures, and APIs

The Linux kernel’s mutex is a sleeping lock that serializes access by sleeping threads, enforces strict ownership rules, uses a state flag with a wait list and per‑CPU optimistic spin queue, offers APIs like mutex_init, lock, unlock and trylock, and employs handoff and MCS‑style spinning to improve performance, with OPPO’s team optimizing it to reduce UI jank.

Linux kernelconcurrencymutex
0 likes · 16 min read
Understanding Linux Kernel Mutex: Mechanism, Data Structures, and APIs
vivo Internet Technology
vivo Internet Technology
Apr 20, 2022 · Backend Development

FastDFS Overview: Principles, Architecture, Upload/Download Process, Synchronization, and Storage Management

FastDFS is a lightweight, open‑source distributed file system written in C that uses a three‑component architecture—client, tracker server for load‑balancing and discovery, and storage servers with push‑based binlog replication—to handle high‑concurrency upload/download of small to medium files, support group‑wide synchronization, optional trunk storage, Nginx anti‑leech integration, and extensible deduplication via FastDHT.

Distributed File SystemFastDFSUpload Download
0 likes · 15 min read
FastDFS Overview: Principles, Architecture, Upload/Download Process, Synchronization, and Storage Management
Top Architect
Top Architect
Mar 11, 2022 · Fundamentals

Operating System Fundamentals: Concurrency, Process Management, Memory Management, and Deadlock

This article provides a comprehensive overview of operating system fundamentals, covering concepts such as concurrency, shared resources, virtual memory, process and thread management, synchronization mechanisms, classic synchronization problems, memory paging and replacement algorithms, device management, disk scheduling, and deadlock detection and prevention.

DeadlockProcess ManagementScheduling
0 likes · 33 min read
Operating System Fundamentals: Concurrency, Process Management, Memory Management, and Deadlock
Selected Java Interview Questions
Selected Java Interview Questions
Jan 25, 2022 · Fundamentals

Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods

This article examines how Java's synchronized keyword and ReentrantLock behave when multiple threads invoke two synchronized methods of the same class, exploring scenarios with the same instance, different instances, and Runnable run methods, and summarizing the resulting concurrency rules.

ReentrantLockconcurrencyjava
0 likes · 15 min read
Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods
Programmer DD
Programmer DD
Jan 6, 2022 · Fundamentals

Why Java’s Biased Locking Matters—and Why It’s Being Deprecated

This article explains the evolution of Java synchronization mechanisms from the classic synchronized keyword to lightweight, biased, and heavyweight locks, explores how lock states transition, the impact of hashCode and wait, and why biased locking is being phased out in modern JDKs.

Biased LockingJVMconcurrency
0 likes · 26 min read
Why Java’s Biased Locking Matters—and Why It’s Being Deprecated
JD Retail Technology
JD Retail Technology
Dec 27, 2021 · Mobile Development

Understanding the Underlying Implementation of @synchronized in iOS

This article explains how the @synchronized directive works in iOS as a recursive mutex, demonstrates its usage with code examples, and delves into the low‑level implementation involving objc_sync_enter, objc_sync_exit, id2data, and the associated caching mechanisms.

iOSobjc_sync_enterrecursive lock
0 likes · 8 min read
Understanding the Underlying Implementation of @synchronized in iOS
DeWu Technology
DeWu Technology
Dec 26, 2021 · Fundamentals

Java Synchronized Mechanism Overview

Java's synchronized keyword provides mutual exclusion by using object monitors, offering class‑method, static‑method, and block locking patterns, while the JVM optimizes performance through biased, lightweight, and heavyweight lock strategies, making it essential knowledge for efficient concurrent programming.

JVMThread Safetyconcurrency
0 likes · 29 min read
Java Synchronized Mechanism Overview
Tencent Cloud Developer
Tencent Cloud Developer
Dec 20, 2021 · Backend Development

Go Concurrency Basics, Libraries, and Best Practices

The article explains Go’s scheduler (M, P, G), demonstrates goroutine, channel, and select usage, covers sync primitives, atomic ops, context cancellation, singleflight, common pitfalls, debugging tools, and a channel‑driven chatroom case study, offering best‑practice guidance for efficient concurrent programming.

Gochannelperformance
0 likes · 21 min read
Go Concurrency Basics, Libraries, and Best Practices
IT Architects Alliance
IT Architects Alliance
Nov 28, 2021 · Fundamentals

Understanding Synchronization, Blocking, and I/O Models in Linux

This article explains the concepts of synchronous vs. asynchronous execution, blocking vs. non‑blocking operations, user and kernel space, process switching, file descriptors, cache I/O, and compares various Linux I/O models such as select, poll, epoll, signal‑driven and asynchronous I/O.

IO modelsLinuxSELECT
0 likes · 15 min read
Understanding Synchronization, Blocking, and I/O Models in Linux
MaGe Linux Operations
MaGe Linux Operations
Oct 9, 2021 · Fundamentals

Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained

This article delves into Python's threading module, explaining thread safety, the role of various lock types—including Lock, RLock, Condition, Event, and Semaphore—along with their methods, usage patterns, common pitfalls like deadlocks, and practical code examples to illustrate proper synchronization techniques.

Locksconcurrencymultithreading
0 likes · 25 min read
Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 22, 2021 · Fundamentals

Understanding and Solving Deadlocks in Java: Demonstrations, Causes, Detection Tools, and Solutions

This article explains Java deadlocks with synchronized and Lock examples, outlines the four necessary conditions, introduces detection tools such as jstack, jconsole, jvisualvm and jmc, and presents practical solutions including sequential locking and polling lock techniques with optimizations to avoid loops and starvation.

DeadlockDebuggingLock
0 likes · 27 min read
Understanding and Solving Deadlocks in Java: Demonstrations, Causes, Detection Tools, and Solutions
Top Architect
Top Architect
Jun 12, 2021 · Fundamentals

Understanding Java Threads, Thread Pools, and Concurrency Mechanisms

This article provides a comprehensive guide to Java multithreading, covering thread concepts, lifecycle states, synchronization methods, thread creation techniques, ThreadPoolExecutor parameters, blocking queues, rejection policies, and inter‑thread communication mechanisms, including examples and best practices for efficient concurrent programming.

ThreadPoolExecutorconcurrencyjava
0 likes · 19 min read
Understanding Java Threads, Thread Pools, and Concurrency Mechanisms
New Oriental Technology
New Oriental Technology
May 31, 2021 · Backend Development

A Comprehensive Guide to Java Concurrency and Synchronization Mechanisms

This article provides an in-depth exploration of Java concurrency and synchronization mechanisms, detailing the evolution of the Java Memory Model, explaining core concepts like volatile, CAS, synchronized, and park/unpark, and illustrating their practical applications through code examples and JVM optimization insights.

CASJVM OptimizationJava concurrency
0 likes · 15 min read
A Comprehensive Guide to Java Concurrency and Synchronization Mechanisms
Python Crawling & Data Mining
Python Crawling & Data Mining
May 14, 2021 · Fundamentals

Master Python Threading: From Basics to Advanced Techniques

This article provides a comprehensive guide to Python threading, covering core concepts such as thread creation, synchronization primitives like locks, RLocks, conditions, semaphores, events, local storage, and timers, complete with practical code examples and explanations of their usage and pitfalls.

LockPythonSemaphore
0 likes · 12 min read
Master Python Threading: From Basics to Advanced Techniques
FunTester
FunTester
May 6, 2021 · Backend Development

Do Thread‑Safe Classes and synchronized Really Slow Down Performance Tests?

This article examines how adding Java thread‑safe classes and the synchronized keyword influences QPS in performance testing, presenting code modifications, benchmark results for 20 and 40 threads, and concluding that their impact on measured throughput is minimal.

Performance TestingQPSThread Safety
0 likes · 8 min read
Do Thread‑Safe Classes and synchronized Really Slow Down Performance Tests?
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 7, 2021 · Fundamentals

Unlocking Java Concurrency: Master Threads, Locks, and Thread Pools

This comprehensive guide explains why concurrency is essential for modern systems, introduces core metrics like response time and throughput, outlines the three pillars of thread safety, compares concurrency with parallelism, and provides practical solutions for deadlocks, thread creation, synchronization, and efficient thread‑pool usage in Java.

DeadlockThreadPoolconcurrency
0 likes · 87 min read
Unlocking Java Concurrency: Master Threads, Locks, and Thread Pools
Su San Talks Tech
Su San Talks Tech
Apr 6, 2021 · Backend Development

Mastering Java Locks: From Optimistic to Biased – A Complete Guide

This article provides a comprehensive overview of Java's lock mechanisms—including optimistic, pessimistic, spin, reentrant, read‑write, fair, unfair, shared, exclusive, heavyweight, lightweight, biased, segment, mutex, and synchronized locks—explaining their principles, typical usages, performance trade‑offs, and key differences with code examples.

Locksperformancesynchronization
0 likes · 15 min read
Mastering Java Locks: From Optimistic to Biased – A Complete Guide
Code Ape Tech Column
Code Ape Tech Column
Dec 17, 2020 · Backend Development

108 Essential Java Multithreading Interview Questions and Answers

This comprehensive guide compiles 108 common Java multithreading interview questions, covering the purpose of concurrency, thread creation methods, lifecycle nuances, synchronization utilities, memory visibility, thread safety levels, debugging techniques, executor frameworks, concurrent collections, atomic operations, lock implementations, and best‑practice recommendations.

ExecutorVolatileconcurrency
0 likes · 59 min read
108 Essential Java Multithreading Interview Questions and Answers
MaGe Linux Operations
MaGe Linux Operations
Dec 10, 2020 · Backend Development

Is Async Python Really Faster? Uncover the Sync vs Async Truth

This article explains the difference between synchronous and asynchronous Python, how each model handles concurrency, the two main async implementations (coroutine‑based and greenlet‑based), and when async can actually outperform sync in high‑load, I/O‑bound scenarios.

asyncbackendconcurrency
0 likes · 12 min read
Is Async Python Really Faster? Uncover the Sync vs Async Truth
High Availability Architecture
High Availability Architecture
Dec 7, 2020 · Fundamentals

Understanding the Java Memory Model: History, Definition, and Practical Implications

This article explains the evolution from single‑core to multi‑core computing, introduces memory models as a protocol for ordering memory operations, details the Java memory model’s definition, its impact on Java and other languages, and provides practical examples and insights into synchronization, volatile, and happens‑before rules.

Memory ModelVolatilehappens-before
0 likes · 26 min read
Understanding the Java Memory Model: History, Definition, and Practical Implications
DeWu Technology
DeWu Technology
Nov 23, 2020 · Fundamentals

PThread Essentials: Thread Creation, Synchronization, and Advanced Techniques

This session reviews PThread fundamentals and advanced techniques in C, covering thread creation, termination, attributes, mutexes, reader‑writer locks, condition variables, semaphores, barrier synchronization, and thread‑specific data, with code examples and a concluding homework assignment.

SemaphoreThread Specific Datacondition variable
0 likes · 11 min read
PThread Essentials: Thread Creation, Synchronization, and Advanced Techniques
Selected Java Interview Questions
Selected Java Interview Questions
Nov 8, 2020 · Backend Development

Designing a Scalable Feed Stream System Architecture

This article explains the principles, data models, storage choices, synchronization strategies, metadata handling, and scaling considerations for building a high‑performance feed‑stream system that can support millions to billions of users, with practical guidance on using NoSQL or relational databases.

NoSQLSystem DesignTablestore
0 likes · 21 min read
Designing a Scalable Feed Stream System Architecture
Selected Java Interview Questions
Selected Java Interview Questions
Oct 14, 2020 · Fundamentals

Understanding Java synchronized: Code Block Lock, Method Lock, and Thread Safety

This article explains Java's synchronized keyword, demonstrating both synchronized code block locks and method locks with complete code examples, analyzing execution results, and discussing memory-level locking, thread safety, performance drawbacks, and best practices for using synchronized in concurrent programming.

Code Examplejavasynchronization
0 likes · 8 min read
Understanding Java synchronized: Code Block Lock, Method Lock, and Thread Safety
Programmer DD
Programmer DD
Oct 11, 2020 · Backend Development

Designing Scalable Feed Stream Systems: Architecture, Storage, and Sync Strategies

This article explains how to design a high‑performance feed‑stream system—covering product definition, data categories, storage options, synchronization modes, metadata handling, commenting, likes, search, sorting, deletion, and update—so you can build a solution that scales to millions or billions of users.

Backend ArchitectureScalableSystem Design
0 likes · 21 min read
Designing Scalable Feed Stream Systems: Architecture, Storage, and Sync Strategies
Su San Talks Tech
Su San Talks Tech
Oct 7, 2020 · Backend Development

8 Proven Java Techniques to Ensure Thread‑Safe Data in Concurrent Apps

This article outlines eight practical Java approaches—including stateless design, immutability, safe publication, volatile fields, synchronized blocks, explicit locks, CAS operations, and ThreadLocal—to guarantee data safety in multithreaded environments, explaining each concept and providing concise code examples.

CASLockThread Safety
0 likes · 6 min read
8 Proven Java Techniques to Ensure Thread‑Safe Data in Concurrent Apps
Top Architect
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.

Volatileatomicconcurrency
0 likes · 8 min read
Understanding the volatile Keyword and Thread Synchronization in Java
Liangxu Linux
Liangxu Linux
Sep 3, 2020 · Fundamentals

Understanding Processes and Threads: A Factory Analogy for OS Fundamentals

This article explains core operating system concepts—CPU as a factory, the static nature of programs versus dynamic processes, how threads act as workers on production lines, and synchronization mechanisms like mutexes and semaphores, using clear analogies and diagrams.

concurrencyoperating-systemprocess
0 likes · 8 min read
Understanding Processes and Threads: A Factory Analogy for OS Fundamentals
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Aug 14, 2020 · Fundamentals

Linux Kernel Synchronization: Atomics, Spinlocks, Semaphores & Mutexes

This article explains the core synchronization mechanisms used in modern Linux kernels—including atomic operations, spinlocks, semaphores, and mutexes—detailing their definitions, underlying implementations, API usage, performance characteristics, and appropriate usage scenarios across different execution contexts such as process, interrupt, and soft‑interrupt contexts.

Linux kernelSemaphoreatomic-operations
0 likes · 12 min read
Linux Kernel Synchronization: Atomics, Spinlocks, Semaphores & Mutexes
macrozheng
macrozheng
Aug 6, 2020 · Backend Development

When ‘No‑Comment’ Java Code Triggers a Memory Leak – A ConcurrentHashMap Study

A newly hired architect boasts high‑concurrency expertise but writes un‑commented Java code that misuses ConcurrentHashMap, leading to memory leaks; the ensuing investigation reveals missing equals/hashCode implementations, race conditions in a visit method, and a debate between synchronized blocks and putIfAbsent for safe updates.

ConcurrentHashMapThread Safetybackend development
0 likes · 8 min read
When ‘No‑Comment’ Java Code Triggers a Memory Leak – A ConcurrentHashMap Study
FunTester
FunTester
Aug 4, 2020 · Backend Development

Mastering Java’s Phaser: A Flexible Alternative to CountDownLatch and CyclicBarrier

This article explains how Java’s Phaser class extends the capabilities of CountDownLatch and CyclicBarrier, offering dynamic phase management for multistage tasks, details its constructors and key methods, compares usage scenarios, and provides a complete code demo illustrating practical implementation.

Phaserconcurrencyjava
0 likes · 9 min read
Mastering Java’s Phaser: A Flexible Alternative to CountDownLatch and CyclicBarrier
Java Backend Technology
Java Backend Technology
Jul 31, 2020 · Backend Development

How a “No‑Comment” Java Code Caused a Massive Memory Leak – Lessons on ConcurrentHashMap

A senior architect’s over‑confident, un‑commented Java code using ConcurrentHashMap triggered a severe memory leak, revealing pitfalls in hashCode/equals implementation, non‑atomic map updates, and the trade‑offs between synchronized blocks and putIfAbsent for high‑concurrency monitoring.

ConcurrentHashMapjavamemory leak
0 likes · 8 min read
How a “No‑Comment” Java Code Caused a Massive Memory Leak – Lessons on ConcurrentHashMap
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 24, 2020 · Fundamentals

Understanding Java's AbstractQueuedSynchronizer (AQS): Concepts, Internal Implementation, and Resource Acquisition/Release

This article explains the core concepts of Java's AbstractQueuedSynchronizer (AQS), its internal FIFO double‑linked list structure, key code snippets, how threads acquire and release resources in exclusive and shared modes, and provides practical insights for mastering Java concurrency.

AQSAbstractQueuedSynchronizerLock
0 likes · 12 min read
Understanding Java's AbstractQueuedSynchronizer (AQS): Concepts, Internal Implementation, and Resource Acquisition/Release
Sohu Tech Products
Sohu Tech Products
Jul 8, 2020 · Fundamentals

Understanding Deadlocks: Causes, Conditions, Prevention, Detection, and Recovery

Deadlocks occur when multiple processes hold exclusive resources while waiting for each other, leading to indefinite blocking; this article explains deadlock concepts, resource types, the four necessary conditions, various detection and recovery methods, prevention strategies such as the banker’s algorithm, and related issues like livelocks and starvation.

DeadlockOperating Systemsconcurrency
0 likes · 28 min read
Understanding Deadlocks: Causes, Conditions, Prevention, Detection, and Recovery
Big Data Technology & Architecture
Big Data Technology & Architecture
Jul 8, 2020 · Fundamentals

Understanding Java Locks: Optimistic vs Pessimistic, Spin Locks, and ReentrantLock

This article explains the various types of locks provided by Java, compares optimistic and pessimistic locking, introduces spin locks and adaptive spin locks, details lock states such as biased, lightweight, and heavyweight, and examines fair versus non‑fair, reentrant versus non‑reentrant, and exclusive versus shared locks with source code references.

CASLocksReentrantLock
0 likes · 25 min read
Understanding Java Locks: Optimistic vs Pessimistic, Spin Locks, and ReentrantLock
Python Programming Learning Circle
Python Programming Learning Circle
Jun 4, 2020 · Fundamentals

Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication

This article provides a comprehensive guide to Python's multiprocessing module, covering how to create and manage processes, use join for synchronization, configure daemon processes, and employ synchronization primitives such as Lock, Semaphore, Event, and Queue for safe inter‑process communication, with complete code examples.

Interprocess CommunicationPythonconcurrency
0 likes · 12 min read
Python Multiprocessing Module: Process Creation, Synchronization, and Inter‑Process Communication
Java Captain
Java Captain
May 14, 2020 · Fundamentals

Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming

This article explains Java's volatile keyword as a lightweight synchronization mechanism, covering its role in ensuring visibility, ordering, and limited atomicity, the underlying Java Memory Model concepts of atomicity, visibility, and ordering, and when volatile is appropriate or insufficient in concurrent programming.

Memory ModelVolatileconcurrency
0 likes · 12 min read
Understanding Java volatile: Visibility, Ordering, and Usage in Concurrent Programming
FunTester
FunTester
May 9, 2020 · Fundamentals

Mastering Java Synchronization: Object vs Class Locks Explained

This guide explains Java's synchronized keyword, detailing how object‑level and class‑level locks work, provides code examples for each, and lists essential best‑practice tips and common pitfalls to avoid when writing thread‑safe Java code.

Locksconcurrencyjava
0 likes · 6 min read
Mastering Java Synchronization: Object vs Class Locks Explained
Selected Java Interview Questions
Selected Java Interview Questions
Mar 30, 2020 · Backend Development

Understanding Java Thread States and Synchronization Methods: wait/notify, sleep/yield, and join

This article explains Java thread lifecycle states, demonstrates how to use wait, notify, and notifyAll for inter‑thread coordination, compares sleep, yield, and join methods with practical code examples, and highlights important considerations such as monitor ownership and thread scheduling.

sleepsynchronizationwait/notify
0 likes · 15 min read
Understanding Java Thread States and Synchronization Methods: wait/notify, sleep/yield, and join
Programmer DD
Programmer DD
Mar 21, 2020 · Fundamentals

Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination

This article explains why busy‑waiting loops waste CPU in Java concurrency, introduces the wait/notify mechanism, shows how synchronized, wait() and notify()/notifyAll() work together, highlights common pitfalls such as using if instead of while, and provides practical code examples and best‑practice guidelines for safe thread coordination.

MESA ModelThread Coordinationconcurrency
0 likes · 14 min read
Why Does Concurrent Programming Need Wait/Notify? Unlock Efficient Thread Coordination
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Feb 28, 2020 · Fundamentals

Understanding Locks and Mutex Implementation in Go

This article explains the concept of locks, why they are needed in concurrent programming, and provides an in‑depth look at Go's synchronization primitives—including CAS, atomic operations, spinlocks, semaphores, and the evolution of the sync.Mutex implementation with code examples and performance considerations.

Lockbackendconcurrency
0 likes · 17 min read
Understanding Locks and Mutex Implementation in Go
FunTester
FunTester
Feb 18, 2020 · Backend Development

Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks

This article explains Java memory‑consistency problems, demonstrates how stale values arise with unsynchronized threads, shows how volatile and synchronized provide happens‑before guarantees, and illustrates common synchronization pitfalls such as reference locks and deadlocks with concrete code examples.

DeadlockMemory ModelVolatile
0 likes · 7 min read
Why Java’s volatile Can’t Replace Synchronization: Understanding Memory Consistency and Deadlocks
FunTester
FunTester
Feb 17, 2020 · Fundamentals

Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables

This article explains how Java threads share objects, why immutable objects are safest, how to make mutable collections thread‑safe using synchronized wrappers or concurrent classes, handles non‑thread‑safe types like SimpleDateFormat, and demonstrates race‑condition fixes with synchronized blocks and AtomicInteger.

AtomicIntegerCollectionsThread Safety
0 likes · 10 min read
Mastering Thread‑Safe Objects in Java: From Synchronized Collections to Atomic Variables
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Feb 7, 2020 · Game Development

Game Development and Educational Interactive Courseware: Elements, Rendering Pipeline, Synchronization, and Framework Design

This article presents a comprehensive overview of game development fundamentals, rendering techniques, synchronization methods, and the design of interactive educational courseware using the Cocos engine, illustrating how game concepts can be applied to create engaging learning experiences.

Cocos engineFramework DesignGame Development
0 likes · 17 min read
Game Development and Educational Interactive Courseware: Elements, Rendering Pipeline, Synchronization, and Framework Design
Architecture Digest
Architecture Digest
Jan 4, 2020 · Backend Development

Java Concurrency: Thread Safety, Visibility, Atomicity, and Lock Mechanisms

This article provides a comprehensive overview of Java concurrency concepts, covering thread‑safety issues, variable visibility, atomic operations, the use of synchronized, volatile, ReentrantLock, ReadWriteLock, CountDownLatch, and other AQS‑based synchronizers, with code examples illustrating each mechanism.

AQSLocksThread Safety
0 likes · 34 min read
Java Concurrency: Thread Safety, Visibility, Atomicity, and Lock Mechanisms
Meituan Technology Team
Meituan Technology Team
Dec 5, 2019 · Backend Development

Understanding AbstractQueuedSynchronizer (AQS) and ReentrantLock in Java

The article explains Java’s AbstractQueuedSynchronizer as the foundation of many concurrency utilities, details how ReentrantLock leverages AQS’s FIFO CLH queue, state field, and lock acquisition/release mechanisms, compares it with synchronized, and demonstrates building a custom lock with AQS.

AQSReentrantLockconcurrency
0 likes · 33 min read
Understanding AbstractQueuedSynchronizer (AQS) and ReentrantLock in Java
Programmer DD
Programmer DD
Dec 4, 2019 · Fundamentals

What a Fruit Store Can Teach You About Java Concurrency

This article uses a vivid fruit‑store analogy to explain Java multithreading concepts such as locks, synchronized blocks, wait/notify, thread states, time‑slicing, and volatile variables, helping readers grasp core concurrency mechanisms in an engaging narrative.

Locksconcurrencymultithreading
0 likes · 18 min read
What a Fruit Store Can Teach You About Java Concurrency
Programmer DD
Programmer DD
Nov 1, 2019 · Fundamentals

How to Break Java’s Deadlock: From Coffman Conditions to Practical Lock Strategies

This article explains why naive synchronized locks can cause deadlocks in Java, introduces the four Coffman conditions, and presents three practical solutions—acquiring all resources at once, using explicit locks with wait/notify, and ordering lock acquisition—to prevent deadlock in concurrent applications.

DeadlockLockscoffman-conditions
0 likes · 9 min read
How to Break Java’s Deadlock: From Coffman Conditions to Practical Lock Strategies
Programmer DD
Programmer DD
Oct 17, 2019 · Fundamentals

Why Simple Locks Fail When Protecting Multiple Related Resources

This article explains how using a lock that protects only a single resource can lead to incorrect behavior when multiple related resources are involved, demonstrates the problem with Java synchronized methods, and shows how a class‑level lock resolves the issue.

Locksconcurrencyjava
0 likes · 8 min read
Why Simple Locks Fail When Protecting Multiple Related Resources
Programmer DD
Programmer DD
Sep 15, 2019 · Fundamentals

Mastering Concurrency: The Three Core Pillars of Multithreaded Programming

Explore how concurrency can be broken down into three essential problems—division of work, synchronization/coordination, and mutual exclusion—using real‑world analogies and Java examples, and learn practical strategies like appropriate task sizing, thread communication, and locking mechanisms to write efficient, safe multithreaded code.

concurrencyjavamultithreading
0 likes · 7 min read
Mastering Concurrency: The Three Core Pillars of Multithreaded Programming
Architecture Digest
Architecture Digest
Sep 6, 2019 · Backend Development

Designing a Scalable Feed Stream System Architecture

This article explains the fundamentals, data model, storage options, synchronization strategies, metadata handling, and scaling considerations for building a high‑performance feed‑stream system used in social platforms such as micro‑blogs, friend circles, and short‑video feeds.

Streamarchitecturefeed
0 likes · 19 min read
Designing a Scalable Feed Stream System Architecture
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 26, 2019 · Backend Development

Scalable Feed Stream System Design: Architecture, Storage & Sync

This article explains the fundamentals and architecture of feed‑stream systems—defining feed data, outlining storage choices such as distributed NoSQL or MySQL, comparing push, pull, and hybrid synchronization models, handling metadata, search, ordering, and scaling considerations for billion‑user platforms.

backend designfeed streamscalable storage
0 likes · 20 min read
Scalable Feed Stream System Design: Architecture, Storage & Sync
21CTO
21CTO
Jul 2, 2019 · Backend Development

Designing a Scalable Feed Stream System for Billions of Users

This article explains how to design a high‑performance feed‑stream architecture—including product definition, data modeling, storage choices, synchronization modes, metadata handling, commenting, likes, sorting, search, and deletion—so that a system can support tens of millions to billions of users while remaining reliable and scalable.

Metadatafeed streamscalability
0 likes · 21 min read
Designing a Scalable Feed Stream System for Billions of Users
21CTO
21CTO
Apr 11, 2019 · Backend Development

Mastering Java Concurrency: Threads, Locks, ThreadPools, and More

This comprehensive guide explores Java concurrency fundamentals—including processes, threads, daemon threads, thread states, synchronization methods, scheduling algorithms, wait vs. sleep, ThreadLocal, locks, volatile, CAS, Unsafe, thread pools, executor policies, blocking queues, Fork/Join, atomic classes, barriers, semaphores, deadlock, IPC, and interruption—providing essential knowledge for building high‑performance backend systems.

LockThreadPoolconcurrency
0 likes · 26 min read
Mastering Java Concurrency: Threads, Locks, ThreadPools, and More
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 20, 2018 · Backend Development

Comprehensive Java Multithreading and Concurrency Interview Questions and Answers

This article compiles 46 essential Java multithreading and concurrency interview questions with detailed answers, covering fundamentals such as atomicity, visibility, ordering, thread creation methods, thread pools, synchronization mechanisms, lock types, AQS, deadlocks, and performance considerations for high‑performance backend development.

InterviewThreadPoolconcurrency
0 likes · 24 min read
Comprehensive Java Multithreading and Concurrency Interview Questions and Answers
Java Captain
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 concurrencyatomic
0 likes · 14 min read
Optimistic vs Pessimistic Locks and CAS Implementation in Java
Architect's Tech Stack
Architect's Tech Stack
Aug 12, 2018 · Backend Development

Understanding and Analyzing the Implementation of Java's Semaphore

This article explains the internal workings of Java's Semaphore, detailing its AQS-based architecture, fair and non‑fair synchronization strategies, core methods such as acquire, release, and their implementations, and provides a practical example demonstrating semaphore usage for thread coordination.

AQSSemaphoreThread Coordination
0 likes · 12 min read
Understanding and Analyzing the Implementation of Java's Semaphore
Architect's Tech Stack
Architect's Tech Stack
Aug 8, 2018 · Backend Development

Deep Dive into Java AQS Shared‑Lock Implementation

This article explains the execution flow, source‑code details, and wake‑up logic of Java's AbstractQueuedSynchronizer shared‑lock mode, covering acquireShared, doAcquireShared, setHeadAndPropagate, doReleaseShared, and releaseShared methods with full code snippets and practical guidance.

AQSSharedLockconcurrency
0 likes · 11 min read
Deep Dive into Java AQS Shared‑Lock Implementation
Programmer DD
Programmer DD
Jun 16, 2018 · Fundamentals

How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking

This article explains the internal mechanisms of Java's AbstractQueuedSynchronizer, detailing how the CLH synchronization queue, the shouldParkAfterFailedAcquire method, and the LockSupport utility work together to decide when a thread should spin, block, or be unblocked, with full code examples and step‑by‑step analysis.

AQSCLHQueueLockSupport
0 likes · 8 min read
How Java AQS Uses CLH Queues and LockSupport to Manage Thread Blocking
21CTO
21CTO
May 9, 2018 · Backend Development

Why Use Locks? Deep Dive into Java Synchronization, Volatile, and AQS

This article explains why locks are needed in concurrent programming, explores the fundamentals of volatile and synchronized, details monitor mechanisms, lock optimizations like biased and lightweight locks, compares CAS and AQS, and illustrates Java lock implementations with diagrams and code examples.

AQSCASLocks
0 likes · 11 min read
Why Use Locks? Deep Dive into Java Synchronization, Volatile, and AQS
MaGe Linux Operations
MaGe Linux Operations
Apr 15, 2018 · Fundamentals

Master Python Threading: From Basics to Advanced Synchronization

This article explains Python threading fundamentals, including thread context, kernel vs. user threads, the low‑level _thread module and the high‑level threading module, functional and class‑based thread creation, synchronization with locks, and using Queue for thread‑safe communication, all illustrated with complete code examples.

PythonQueueconcurrency
0 likes · 13 min read
Master Python Threading: From Basics to Advanced Synchronization
Java Architect Essentials
Java Architect Essentials
Mar 19, 2018 · Backend Development

40 Common Java Multithreading Interview Questions and Answers

This article compiles and answers 40 frequently asked Java multithreading interview questions, covering thread purpose, creation methods, key APIs, synchronization mechanisms, thread safety levels, performance considerations, and practical debugging techniques for developers seeking a solid understanding of concurrent programming.

InterviewThreadPoolconcurrency
0 likes · 29 min read
40 Common Java Multithreading Interview Questions and Answers