This article explains the fundamental differences between processes and threads, compares Thread and Runnable in Java, outlines thread lifecycle states, and details common concurrency methods such as sleep, join, yield, interrupt, wait, and synchronized, helping developers write robust multithreaded code.
This article explains how Java's synchronized(this) keyword creates an object lock that allows only one thread to execute a synchronized block at a time, demonstrates various scenarios with code examples, and shows how non‑synchronized sections remain concurrent while all synchronized sections on the same object are blocked.
This article explains the Java volatile keyword, covering its memory‑model semantics, how it guarantees visibility and ordering, why it does not provide atomicity, and demonstrates typical usage patterns such as flag signaling and double‑checked locking for singletons.
This article provides a comprehensive overview of Java concurrency, covering thread creation methods, thread pools, thread models, the Future and Fork/Join frameworks, volatile and CAS mechanisms, AQS, synchronized locks, and various concurrent queue implementations, with practical code examples and references for deeper study.
This article delves into Go's channel mechanism, explaining its three core signal properties—delivery guarantee, state, and data presence—while providing clear code examples for unbuffered, buffered, and context‑based channels to help developers write reliable concurrent programs.
This article explains essential Java concurrency concepts—including synchronous vs. asynchronous execution, concurrency vs. parallelism, critical sections, blocking and non‑blocking operations—covers thread states, creation methods, priorities, common thread APIs, and the Java Memory Model’s guarantees on atomicity, visibility, and ordering.
This article explains key Java concurrency concepts—including synchronization, parallelism, critical sections, blocking vs non‑blocking, thread lifecycle, priority, common thread methods, interrupt handling, and the Java Memory Model’s guarantees of atomicity, visibility, ordering, and happens‑before relations—providing practical examples and code snippets for backend developers.
This article explains the purpose of Java's ThreadLocal class, shows a practical example with code and output images, compares it to synchronized locking, and demonstrates how ThreadLocal provides each thread with an independent variable copy for safe concurrent access.
This article provides a comprehensive overview of Java's AbstractQueuedSynchronizer (AQS), explaining its design, exclusive and shared synchronization modes, key methods such as acquire, release, and their implementations, and demonstrates a simple Mutex application with detailed code analysis.
This article explains how unsynchronized access to instance variables can cause dirty reads in multithreaded Java programs, demonstrates the issue with sample code, shows how adding the synchronized keyword resolves it, and explores the behavior when multiple objects each hold their own lock.
This article explains Java's synchronized keyword, demonstrating how synchronized methods and blocks control thread execution order, prevent dirty reads, and illustrate the differences between synchronized and non‑synchronized code through multiple runnable examples.
This article compiles and clarifies forty common Java multithreading interview questions, covering thread creation, synchronization mechanisms, thread pools, memory model, and practical debugging techniques to help developers deepen their understanding and prepare for technical interviews.
This article introduces Python multithreading by comparing processes and threads, explains the Global Interpreter Lock, and details the thread and threading modules along with synchronization primitives, queue usage, and common FAQs for effective concurrent programming.
This article explains the purpose and mechanics of process sleep in the Linux kernel, describes how wait queues and wake‑up functions operate, and details why sleeping in interrupt context or while holding spinlocks, seqlocks, or RCU locks leads to deadlocks and system crashes.
The article explains how Linux spinlocks, originally designed for SMP systems, operate in UP kernels, why CONFIG_DEBUG_SPINLOCK changes their behavior, and which spinlock variants should be used in different interrupt and preemption contexts.
This article explains how to use Linux pthread condition variables, covering initialization, the pthread_cond_wait function, signal handling, and a complete C example that demonstrates thread coordination and mutex interaction for reliable multithreaded programming.
This article provides a detailed explanation of various Java lock mechanisms—including fair and unfair locks, spin locks, lock elimination, lock coarsening, reentrant, class and object locks, biased, lightweight, heavyweight, pessimistic and optimistic locks—as well as practical code examples and a lock state table to help developers understand concurrency control in the JVM.
This article describes the design and implementation of a Linux‑based distributed file system (DFS) that targets large‑scale data storage and access, detailing its architecture, goals, storage model, consistency mechanisms, thread‑safety approach, synchronization strategies, and recovery processes to ensure high availability and data integrity.
This article describes the design, architecture, and key features of a Linux‑based distributed file system that emphasizes horizontal scalability, data consistency, fault tolerance, and efficient handling of both small and large files without traditional metadata services.
This article provides an extensive overview of Java concurrency, covering synchronous vs asynchronous calls, critical sections, blocking and non‑blocking behavior, deadlock, starvation, livelock, concurrency levels, the Java Memory Model, atomicity, visibility, ordering, thread lifecycle, synchronization mechanisms, thread pools, and related utilities.
Learn how to implement distributed locks using Zookeeper by creating a root node, generating sequential child nodes for lock acquisition, monitoring predecessor nodes, and releasing locks through node deletion, ensuring consistency across multiple servers in a distributed environment.
The article outlines WeChat’s backend architecture, detailing extreme business requirements such as low latency and power efficiency, challenges of synchronizing diverse data across terminals, and solutions including a minimal sync protocol, high‑efficiency notification mechanisms, a three‑tier backend, unified RPC framework, coroutine‑based high‑concurrency RPC, and multi‑IDC distribution with strong consistency and disaster‑recovery strategies.
This article explains how to build a Java event‑notification system using the observer pattern, highlights typical mistakes such as concurrent modification and deadlocks, and presents several thread‑safe implementations ranging from synchronized blocks to CopyOnWriteArraySet and atomic primitives.
