0 views collected around this technical thread.
This article explains what deadlocks are in C++ multithreaded programming, outlines their causes and four necessary conditions, presents common scenarios and code examples, and offers practical strategies such as consistent lock ordering, std::lock, std::scoped_lock, recursive mutexes, and lock hierarchies to avoid them.
This article explains the concepts of processes and threads, describes Python's Global Interpreter Lock (GIL) and its impact on concurrency, compares the low‑level _thread module with the higher‑level threading module, and provides example code illustrating thread creation, synchronization with locks, and common pitfalls.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario with SpringBoot and MySQL, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including early locking, AOP, pessimistic and optimistic database locks, blocking queues, and Disruptor queues—along with performance observations and a concise summary.
This article provides a comprehensive index of a MySQL internals series covering the transaction, lock, and undo modules, detailing each sub‑topic such as transaction initialization, two‑phase commit, various lock types, deadlock handling, and undo log management across numerous linked articles.
This article explains how to use Python's asyncio library to synchronize and communicate between coroutines, covering Event, Lock, Semaphore, Condition, and Queue primitives with clear code examples demonstrating each mechanism in practice.
This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.
This article explains how using Spring's @Transactional annotation together with explicit locks can cause unexpected concurrency issues, demonstrates the problem with sample code, analyzes why the lock becomes ineffective, and presents solutions such as separating transactional methods, using programmatic transactions, or locking the entire transaction.
This article explains the timing of Spring's @Transactional commit relative to lock release, analyzes why committing after unlock can cause overselling, shows how to trace the transaction lifecycle in the source code, and offers practical solutions to ensure atomicity in high‑concurrency scenarios.
This article explains how Dart implements multithreading through Isolates built on a C++ ThreadPool, detailing the roles of Task and Worker objects, the lock mechanisms with Monitor and MonitorLocker, and the lifecycle and scheduling logic that powers Dart's runtime concurrency.
This article introduces KeyDB, a high‑performance multithreaded fork of Redis, explaining its architecture, thread model, connection management, fastlock mechanism, and active‑replica features, while providing code examples and performance comparisons, and highlighting their impact on throughput and latency.
This article explains how KeyDB, a multithreaded fork of Redis, restructures the original single‑threaded design by introducing worker threads, per‑thread connection handling, a fastlock spin‑lock implementation, and an active‑replica feature that enables writable replicas with conflict‑resolution using timestamped keys.
This article explains the key differences between Java's Lock interface and the synchronized keyword, covering their nature, lock acquisition and release mechanisms, fairness, ability to query lock status, usage scenarios, and includes example code demonstrating each approach.
This article examines how executing an UPDATE before a slow SELECT within a @Transactional method in Spring can prolong MySQL write locks, and demonstrates code refactoring techniques—reordering operations and separating transactional boundaries—to improve overall system performance.
This article examines how INSERT, REPLACE and INSERT … ON DUPLICATE KEY UPDATE statements can cause deadlocks in MySQL InnoDB under various scenarios, explains the underlying lock types such as GAP, NEXT‑KEY and INSERT‑INTENTION locks, and offers practical recommendations to avoid them.
This article explains the core concepts of Java's AbstractQueuedSynchronizer, detailing its internal FIFO queue, state management, exclusive and shared modes, and provides complete code examples for custom lock implementation and usage.
The article explains Java’s AbstractQueuedSynchronizer framework and how ReentrantLock uses its inner Sync classes—FairSync and NonfairSync—to manage lock acquisition via CAS, queueing, spinning, and parking, detailing the acquire/release loops, fair vs non‑fair behavior, and interview‑ready insights.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL and JMeter, analyzes why naive lock‑and‑transaction code causes overselling, and presents six refined solutions—including controller‑level locking, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—along with performance test results.
The article investigates why an UPDATE statement on a MySQL 5.7 InnoDB table with RR isolation experiences high lock time, demonstrates how missing indexes cause full‑table scans and blocking, and shows how adding an index and using optimizer trace can diagnose and resolve the issue.
This article explains the core concepts and common pitfalls of Java's AbstractQueuedSynchronizer (AQS) and its derived utilities such as ReentrantLock, ReentrantReadWriteLock, CountDownLatch, Semaphore, as well as the design and behavior of blocking queues, thread‑pool parameters, CopyOnWriteArrayList, and ConcurrentHashMap, providing code examples and practical guidance.
This article explains what a spinlock is, outlines its advantages and disadvantages, describes suitable usage scenarios, and provides a detailed Java implementation using CAS, including code examples and an explanation of the underlying CAS algorithm.