Skip to content
Tagged articles

Concurrency

500 articles · Page 1 of 5
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Nov 18, 2026 · Artificial Intelligence

CNN for Java Engineers: From Model Understanding to Production Inference Deployment

This article explains CNN fundamentals — local receptive fields, weight sharing, equivariance — and provides Java engineers a practical roadmap from reading model summaries to deploying stable inference services using DJL and ONNX Runtime, covering preprocessing contracts, concurrency pitfalls, native memory management, quantization trade-offs, and observability strategies.

CNNConcurrencyDJL
0 likes · 49 min read
CNN for Java Engineers: From Model Understanding to Production Inference Deployment
Node.js Tech Stack
Node.js Tech Stack
Nov 18, 2026 · Backend Development

Node.js Green Threads: 8 OS Threads Run 1,000 Isolated V8 Isolates, Beating Workers

Node.js adds an experimental Green Threads module (node:green_threads) that runs thousands of isolated V8 isolates on a shared pool of 8 OS threads, cutting per-instance memory from 6.2 MB to 1.4 MB and achieving higher QPS than Worker threads while providing strong fault isolation for multi-tenant scripting.

ConcurrencyExperimental FeatureGreen Threads
0 likes · 9 min read
Node.js Green Threads: 8 OS Threads Run 1,000 Isolated V8 Isolates, Beating Workers
Raymond Ops
Raymond Ops
Nov 11, 2026 · Operations

Kernel Parameter Tuning for Nginx: A Verified Methodology for 300% Concurrency Gains

This article presents a systematic, hypothesis-driven methodology for tuning Linux kernel parameters to improve Nginx concurrency, covering file descriptor limits, listen queue configuration, network buffer tuning, and safe canary deployment with rollback procedures, all validated through metrics and load testing.

ConcurrencyNginxOperations
0 likes · 25 min read
Kernel Parameter Tuning for Nginx: A Verified Methodology for 300% Concurrency Gains
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 10, 2026 · Backend Development

Java CyclicBarrier: Reusable Thread Barrier with Callback for Parallel Aggregation

This article explains Java's CyclicBarrier synchronization utility, highlighting its reusability and callback support compared to CountDownLatch, and demonstrates its use in two examples: a basic three-thread barrier with a callback and a parallel array sum calculation where threads compute partial sums and aggregate at the barrier.

ConcurrencyCountDownLatchCyclicBarrier
0 likes · 6 min read
Java CyclicBarrier: Reusable Thread Barrier with Callback for Parallel Aggregation
Architect's Guide
Architect's Guide
Nov 7, 2026 · Backend Development

Thread Pool Misuse in Production: Key Lessons from a Real Incident

A production timeout incident caused by unbounded CompletableFuture.get() calls and shared thread pools leads to a comprehensive guide on proper thread pool configuration, isolation, timeout handling, ThreadLocal cleanup, dynamic queue sizing, core thread calculation formulas, and ParallelStream pitfalls.

CompletableFutureConcurrencyJava
0 likes · 17 min read
Thread Pool Misuse in Production: Key Lessons from a Real Incident
Raymond Ops
Raymond Ops
Oct 30, 2026 · Operations

Nginx Optimization Guide: Doubling Concurrency via Configuration Tuning

This comprehensive guide details a systematic Nginx optimization process covering worker processes, connection handling, buffering, caching, compression, proxy settings, rate limiting, and monitoring, demonstrating how proper configuration tuning can triple concurrency on the same hardware with concrete examples and verification steps.

ConcurrencyNginxOperations
0 likes · 41 min read
Nginx Optimization Guide: Doubling Concurrency via Configuration Tuning
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 20, 2026 · Backend Development

Spring Boot @Transactional Pitfalls: Deadlocks, Long Transactions & Propagation Failures

This article analyzes three critical @Transactional pitfalls in Spring Boot 3.5.0: deadlocks from inconsistent lock ordering during concurrent transfers, long transactions holding row locks during external RPC calls causing blocking and inconsistency, and nested transaction propagation causing unexpected rollbacks despite try-catch. Solutions include consistent lock ordering, transaction splitting, and using REQUIRES_NEW or programmatic transactions.

@TransactionalConcurrencyDeadlock
0 likes · 11 min read
Spring Boot @Transactional Pitfalls: Deadlocks, Long Transactions & Propagation Failures
Java Tech Workshop
Java Tech Workshop
Oct 18, 2026 · Backend Development

How Virtual Threads Cut Latency from 50s to 1s in a Real Java 21 Service

The article details a real-world migration from a fixed 200-thread pool to Java 21 virtual threads, showing how serial calls to three 1-second external services caused 50-second tail latencies under load, and how virtual threads eliminated queuing by decoupling waiting from expensive OS threads, while covering pinning risks, ThreadLocal pitfalls, and migration steps.

ConcurrencyJava 21Performance Optimization
0 likes · 21 min read
How Virtual Threads Cut Latency from 50s to 1s in a Real Java 21 Service
SpringMeng
SpringMeng
Oct 18, 2026 · Interview Experience

China Merchants Bank Java Backend Interview: 20 Technical Questions & Answers

A developer shares their successful China Merchants Bank Java backend interview experience, detailing 20 technical questions covering HashMap, ConcurrentHashMap, synchronization, thread pools, Redis cache penetration, MySQL indexing, Spring Boot auto-configuration, Agent memory, RAG, multi-agent orchestration, and more, with answers and preparation tips.

AgentAuto-ConfigurationBackend
0 likes · 35 min read
China Merchants Bank Java Backend Interview: 20 Technical Questions & Answers
Architect's Guide
Architect's Guide
Oct 17, 2026 · Backend Development

5 Java Thread Communication Techniques: From volatile to LockSupport

This article explains five Java thread communication methods—volatile flag, Object wait/notify, CountDownLatch, ReentrantLock with Condition, and LockSupport—with runnable code examples showing how each coordinates a producer thread adding items and a consumer thread triggered at the fifth addition.

ConcurrencyCountDownLatchJava
0 likes · 10 min read
5 Java Thread Communication Techniques: From volatile to LockSupport
samdeepthink
samdeepthink
Oct 15, 2026 · Fundamentals

Java Condition: Fine-Grained Thread Wakeup vs notifyAll Pitfalls

This article demonstrates the evolution from synchronized/wait/notify to Lock/Condition for producer-consumer patterns, showing how notifyAll causes spurious wakeups with multiple threads and how Condition enables precise signaling via separate condition queues for producers and consumers.

ConcurrencyConditionJava
0 likes · 14 min read
Java Condition: Fine-Grained Thread Wakeup vs notifyAll Pitfalls
samdeepthink
samdeepthink
Oct 14, 2026 · Backend Development

Java Lock vs synchronized: Timeout, Interrupt & Fair Locking Explained

This article compares Java's synchronized keyword with the Lock interface (ReentrantLock), demonstrating how Lock provides finer-grained control through timeout acquisition (tryLock), interruptible locking (lockInterruptibly), fair/non-fair policies, and manual unlock in finally blocks, with code examples for each scenario.

ConcurrencyFair LockJava
0 likes · 9 min read
Java Lock vs synchronized: Timeout, Interrupt & Fair Locking Explained
21CTO
21CTO
Oct 14, 2026 · Backend Development

Linus Torvalds Uses AI for Linux Kernel Patches: 3x Read Throughput, Unresolved Memory Issues

Linus Torvalds employed Claude Code to create an 8-patch series that removes a page-cache contention bottleneck for tiny concurrent reads, boosting 8-thread throughput from ~10M to ~32M reads/sec on a laptop, but the patches delay memory reuse via RCU grace periods and still have regressions, leaving them unmerged as of October 2024.

AI-assisted codingClaude CodeConcurrency
0 likes · 9 min read
Linus Torvalds Uses AI for Linux Kernel Patches: 3x Read Throughput, Unresolved Memory Issues
samdeepthink
samdeepthink
Oct 9, 2026 · Backend Development

CyclicBarrier vs CountDownLatch: Who Waits? Java Concurrency Deep Dive

This article explains the key differences between Java's CyclicBarrier and CountDownLatch, focusing on which threads wait, thread lifecycle after signaling, reusability, and a practical pressure-test example using CountDownLatch to simulate concurrent requests.

ConcurrencyCountDownLatchCyclicBarrier
0 likes · 8 min read
CyclicBarrier vs CountDownLatch: Who Waits? Java Concurrency Deep Dive
TonyBai
TonyBai
Oct 5, 2026 · Backend Development

Go's 10-Year Select Proposal Revived: bradfitz's Mutex.LockChan() Demo

The article traces the 10-year history of Go issue #16620, which sought to make sync.Cond selectable, explains the level-vs-edge-triggered conflict, reviews community workarounds, and details bradfitz's new Mutex.LockChan() demo that enables cancellable locking via select.

ConcurrencyGoGo proposal
0 likes · 14 min read
Go's 10-Year Select Proposal Revived: bradfitz's Mutex.LockChan() Demo
Java Tech Workshop
Java Tech Workshop
Oct 3, 2026 · Backend Development

LRU Cache in 3 Lines: How LinkedHashMap Does the Heavy Lifting

This article demonstrates how to build a bounded LRU cache in three lines by extending LinkedHashMap with access-order enabled and overriding removeEldestEntry, detailing the internal doubly-linked list mechanics, thread-safety limitations, memory overhead, and when to migrate to Caffeine for advanced features like TTL and high concurrency.

CachingCaffeineConcurrency
0 likes · 22 min read
LRU Cache in 3 Lines: How LinkedHashMap Does the Heavy Lifting
Java Captain
Java Captain
Sep 30, 2026 · Interview Experience

WXG First-Round Interview: 60 Questions from Algorithms to Agent Design

A shared WXG first-round interview experience lists 60 questions covering self-introduction, algorithms (IP-to-uint64, linked-list folding, uniform sampling), system design, AI tools, large-model hallucinations, RAG, vector search, collaborative filtering, 12306 ticketing architecture, Redis internals, MySQL B+ trees, concurrency locks, and design patterns.

AlgorithmsB* treeConcurrency
0 likes · 7 min read
WXG First-Round Interview: 60 Questions from Algorithms to Agent Design
samdeepthink
samdeepthink
Sep 28, 2026 · Backend Development

Java Semaphore Decoupling: Thread-Agnostic Permits vs. Lock Coupling

This article explains Java Semaphore's core decoupling property—where any thread can acquire or release permits—contrasting it with ReentrantLock's thread-owned locking, demonstrates with Java 17 code examples, and shows real-world rate-limiting applications in Sentinel, Dubbo, and Tomcat.

ConcurrencyDecouplingJava
0 likes · 8 min read
Java Semaphore Decoupling: Thread-Agnostic Permits vs. Lock Coupling
samdeepthink
samdeepthink
Sep 23, 2026 · Backend Development

RabbitMQ Livelock: Emergency Fixes for Message Re-delivery Loops

The article explains livelock using a RabbitMQ incident where unacknowledged messages cause endless re-delivery, and describes two production fixes: immediate try-catch with ACK to stop the loop, then bug fix; and a configurable "empty consumption" switch to discard messages when replay is possible.

ConcurrencyMessage QueueRabbitMQ
0 likes · 6 min read
RabbitMQ Livelock: Emergency Fixes for Message Re-delivery Loops
Lao Guo's Learning Space
Lao Guo's Learning Space
Sep 23, 2026 · Artificial Intelligence

M5 Ultra Mac Studio: The Dream Machine for Local AI Agents?

Federico Viticci's four-day deep test of the M5 Ultra Mac Studio (256GB unified memory) reveals 1.2TB/s bandwidth, 2.5x faster prefill, up to 93.5% faster long-context generation, and superior concurrency for 24/7 local AI agent workflows at near-zero cost, outperforming RTX 5090 in usability.

ConcurrencyM5 UltraMac Studio
0 likes · 12 min read
M5 Ultra Mac Studio: The Dream Machine for Local AI Agents?
JD Tech
JD Tech
Sep 22, 2026 · Backend Development

18 Advanced Java Coding Practices for High-Performance, Low-CPU Systems (Part 2)

This article details 18 advanced Java coding techniques (19-36) for high-performance, low-CPU systems, covering void/null avoidance, nested code flattening, final/static method optimization, primitive type usage, collection pre-sizing, memory management, immutable collections, loop optimization, wrapper caching, exception reuse, stack trace reduction, try-catch narrowing, bitwise operations, regex precompilation, memory alignment, constant-first comparisons, and batch processing.

Coding Best PracticesConcurrencyJVM
0 likes · 52 min read
18 Advanced Java Coding Practices for High-Performance, Low-CPU Systems (Part 2)
samdeepthink
samdeepthink
Sep 21, 2026 · Fundamentals

Java final Visibility: JMM Freeze, This Escape, and Lock-Free Guarantees

This article explains how Java's final keyword ensures cross-thread visibility of final fields through the JMM's freeze action at constructor end, provided the this reference does not escape during construction, demonstrating with a code example that shows a race condition when this escapes and the correct behavior when final fields are properly frozen.

ConcurrencyJMMJava
0 likes · 7 min read
Java final Visibility: JMM Freeze, This Escape, and Lock-Free Guarantees
samdeepthink
samdeepthink
Sep 16, 2026 · Fundamentals

Java Happens-Before: Visibility Guarantees Beyond Temporal Order

This article demystifies Java's happens-before rules, showing why temporal order doesn't guarantee visibility, and how volatile combined with program order ensures a non-volatile variable's visibility across threads through a concrete code example.

ConcurrencyHappens-BeforeJMM
0 likes · 13 min read
Java Happens-Before: Visibility Guarantees Beyond Temporal Order
samdeepthink
samdeepthink
Sep 15, 2026 · Backend Development

Java 17 Memory Barriers: Why They're Needed and How to Use Them

This article explains Java memory barriers using a simple two-thread example, detailing how compiler reordering, CPU out-of-order execution, and cache inconsistency cause visibility issues, and shows how volatile and VarHandle provide acquire/release semantics to guarantee correct ordering in Java 17.

CPU reorderingConcurrencyJMM
0 likes · 9 min read
Java 17 Memory Barriers: Why They're Needed and How to Use Them
IT Services Circle
IT Services Circle
Sep 8, 2026 · Fundamentals

What Does await Actually Wait For? 10 Misconceptions That Break Async Code

This article dissects 10 common misconceptions about JavaScript's await keyword, explaining how it evaluates expressions, waits only for Promise settlement — not side effects — and why patterns like forEach with async callbacks, bare setTimeout, and Promise.all can cause silent bugs in production.

ConcurrencyError HandlingJavaScript
0 likes · 16 min read
What Does await Actually Wait For? 10 Misconceptions That Break Async Code
LuTiao Programming
LuTiao Programming
Sep 7, 2026 · Backend Development

Virtual Threads Eliminated Thread Pools — Until MySQL Connections Ran Out

After upgrading to Java 25 and Spring Boot 4, the author enabled virtual threads and removed custom thread pools for IO-heavy aggregation endpoints. While code simplified dramatically, the bottleneck shifted from thread exhaustion to HikariCP connection pool exhaustion, revealing that virtual threads don't increase downstream capacity. The solution: limit scarce resources (DB connections, HTTP clients) directly rather than limiting threads.

ConcurrencyHikariCPIO-bound
0 likes · 12 min read
Virtual Threads Eliminated Thread Pools — Until MySQL Connections Ran Out
Java Tech Enthusiast
Java Tech Enthusiast
Sep 7, 2026 · Backend Development

Java Virtual Threads: Why Production Adoption Lagged Behind the Hype

The article analyzes why Java virtual threads, despite promising million-concurrency with minimal code changes, see little production adoption due to pinning with synchronized, ThreadLocal memory pressure, incomplete framework support, and CPU-bound workload mismatch, while showing benchmarks where they excel in I/O-heavy services but migration costs deter legacy systems.

ConcurrencyJDK 21Java
0 likes · 12 min read
Java Virtual Threads: Why Production Adoption Lagged Behind the Hype
macrozheng
macrozheng
Sep 7, 2026 · Backend Development

Java Virtual Threads: Why the 'Million Concurrency' Promise Failed in Production

This article analyzes why Java virtual threads, despite promising million-concurrency with minimal overhead, see little production adoption due to pinning with synchronized blocks, ThreadLocal memory explosions, incomplete framework support, and unsuitability for CPU-bound workloads, while showing benchmarks where they excel in I/O-heavy scenarios.

ConcurrencyJDK 21Java
0 likes · 12 min read
Java Virtual Threads: Why the 'Million Concurrency' Promise Failed in Production
IT Learning Made Simple
IT Learning Made Simple
Sep 6, 2026 · Fundamentals

Dining Philosophers Problem: 5 Classic Deadlock Solutions

This article explains the classic Dining Philosophers deadlock problem, illustrates why naive locking causes deadlock with code, and presents five solutions—waiter semaphore, odd-even ordering, atomic acquisition, resource hierarchy, and monitor—each with pseudocode, trade-offs, and real-world analogies like database connection pools.

ConcurrencyDeadlockOperating Systems
0 likes · 12 min read
Dining Philosophers Problem: 5 Classic Deadlock Solutions
Cloud Architecture
Cloud Architecture
Sep 3, 2026 · Backend Development

TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning

This article details the engineering implementation and performance optimization of TCC distributed transactions in Go microservices, using an order placement scenario with inventory locking and wallet freezing, covering data models, idempotent state machines, recovery workers, hotspot optimization, and observability.

ConcurrencyGoIdempotency
0 likes · 33 min read
TCC Is Not a Silver Bullet: Engineering Go Microservice Distributed Transactions with Performance Tuning
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Sep 2, 2026 · Backend Development

Java Thread Pool Deep Dive: 7 Core Parameters, 4 Rejection Policies & Tuning Formulas

This comprehensive guide covers Java thread pool internals including seven core parameters with bank analogies, task execution flow, four rejection strategies with production pitfalls, CPU/IO-bound thread sizing formulas, common Executors pitfalls, state transitions, and graceful shutdown patterns with code examples.

ConcurrencyExecutorServiceJava
0 likes · 41 min read
Java Thread Pool Deep Dive: 7 Core Parameters, 4 Rejection Policies & Tuning Formulas
Java Tech Enthusiast
Java Tech Enthusiast
Sep 2, 2026 · Backend Development

Recreating WeChat‑style Message Recall in Spring Boot: Why Deleting Isn’t Enough

The article walks through a complete Spring Boot implementation of WeChat‑like message recall, explaining why a simple DELETE is insufficient and detailing how to use a status flag, conditional UPDATE, WebSocket, Redis/MQ, and multi‑device session management to synchronize recall across all clients, even under concurrency and offline scenarios.

ConcurrencyMQMySQL
0 likes · 11 min read
Recreating WeChat‑style Message Recall in Spring Boot: Why Deleting Isn’t Enough
LuTiao Programming
LuTiao Programming
Aug 31, 2026 · Backend Development

Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot

The article examines a common duplicate‑order bug caused by client retries after network timeouts, explains why @Transactional alone cannot guarantee idempotency, critiques simple Redis SETNX solutions, and presents a robust Spring Boot design that stores idempotency records together with order data in a single MySQL transaction, uses request fingerprints, unique keys, and owner tokens to safely replay or reject retries while handling concurrency and cleanup.

@TransactionalAPI designConcurrency
0 likes · 19 min read
Why Disabled Buttons Still Produce Duplicate Orders – Rebuilding Idempotency in Spring Boot
LuTiao Programming
LuTiao Programming
Aug 29, 2026 · Backend Development

Dropping findById()+save(): Spring Data Now Handles It with a Single SQL

The article explains how the traditional find‑by‑id‑then‑save pattern causes two database round‑trips and concurrency bugs, and shows that Spring Data 4.1’s single‑statement Upsert (JdbcAggregateTemplate.upsert) lets the database decide INSERT or UPDATE in one SQL, reducing latency and race conditions while outlining its limitations and ideal use cases.

ConcurrencyJDBCSpring Boot
0 likes · 13 min read
Dropping findById()+save(): Spring Data Now Handles It with a Single SQL
Rain's Path to Java Mastery
Rain's Path to Java Mastery
Aug 25, 2026 · Backend Development

Java Thread Safety: 5 Core Approaches Compared with Code Examples & Interview Insights

This comprehensive guide covers five categories of Java thread safety solutions — from stateless objects and immutable classes to volatile, locks, and thread confinement — with performance comparisons, code examples for DCL, CAS, ReentrantLock, and ThreadLocal, plus analysis of deadlock, ABA problem, and memory leaks for backend interview preparation.

Atomic OperationsConcurrencyJava
0 likes · 23 min read
Java Thread Safety: 5 Core Approaches Compared with Code Examples & Interview Insights
ITPUB
ITPUB
Aug 25, 2026 · Databases

From Modeling to Systematic Theory: Tracing a Decade of Database Consistency Evolution (2020‑2025)

The article reviews a speaker’s ten‑year journey from building multi‑level consistency models and defining over twenty new data anomalies to exposing ANSI‑SQL’s isolation flaws, unveiling the “Eight Immortals” consistency diagram, proposing the CCDB architecture with zero‑time unlock, and finally codifying three concurrent‑system design principles.

CCDBConcurrencyConsistency
0 likes · 30 min read
From Modeling to Systematic Theory: Tracing a Decade of Database Consistency Evolution (2020‑2025)
Architect Chen
Architect Chen
Aug 25, 2026 · Fundamentals

Java Thread States Explained: 6 States with Visual Diagrams

This article provides a comprehensive explanation of Java's six thread states—New, Runnable, Blocked, Waiting, Timed Waiting, and Terminated—with visual diagrams illustrating each state's transitions and typical triggers such as lock acquisition, wait/notify, and timeout mechanisms.

ConcurrencyJavaJava Interview
0 likes · 3 min read
Java Thread States Explained: 6 States with Visual Diagrams
Java Backend Technology
Java Backend Technology
Aug 25, 2026 · Backend Development

Are Java Virtual Threads Losing Their Momentum?

The article examines why the early hype around Java virtual threads has faded, detailing technical pitfalls such as pinning and ThreadLocal memory bloat, incomplete ecosystem support, and misuse in CPU‑bound workloads, while also presenting benchmark data that shows they still excel in I/O‑heavy scenarios.

ConcurrencyJDKJava
0 likes · 10 min read
Are Java Virtual Threads Losing Their Momentum?
Dabaoshi
Dabaoshi
Aug 21, 2026 · Backend Development

Concurrency Series Finale: Virtual Threads and Structured Concurrency

The article explains why platform threads are costly, how JDK 21 virtual threads eliminate that cost, and provides practical guidance on creating, using, and debugging virtual threads, including pinning pitfalls, rules against pooling, structured concurrency, ScopedValue, and a detailed model‑selection comparison.

ConcurrencyJDK 21Java
0 likes · 34 min read
Concurrency Series Finale: Virtual Threads and Structured Concurrency
Dabaoshi
Dabaoshi
Aug 20, 2026 · Backend Development

Mastering Asynchronous Orchestration in Java: From Future Limits to CompletableFuture and Fork/Join

The article explains how to replace blocking Future with CompletableFuture for efficient asynchronous orchestration, covering task chaining, parallel execution, exception handling, and Fork/Join, and demonstrates a complete seckill order pipeline that reduces latency by parallelizing independent steps.

CompletableFutureConcurrencyForkJoin
0 likes · 19 min read
Mastering Asynchronous Orchestration in Java: From Future Limits to CompletableFuture and Fork/Join
liandk
liandk
Aug 20, 2026 · Databases

Master MySQL Locks: Row, Table, and Gap Lock Basics, Pitfalls & Live Code

Understanding MySQL’s lock types—table, row, and gap locks—reveals how they act as resource tokens to ensure data consistency under concurrency, while the article details their characteristics, appropriate and prohibited use cases, common pitfalls like lock degradation and deadlocks, and provides hands‑on SQL examples to reproduce and avoid these issues.

ConcurrencyDeadlockLocks
0 likes · 10 min read
Master MySQL Locks: Row, Table, and Gap Lock Basics, Pitfalls & Live Code
Ray's Galactic Tech
Ray's Galactic Tech
Aug 19, 2026 · Backend Development

Designing a 12‑State Payment System State Machine from Pending to Completed

This article presents a complete design for a 12‑state payment order state machine that handles high‑concurrency scenarios such as payment callbacks arriving after an order has been cancelled, using explicit state transitions, database CAS updates, Redis + DB idempotency, Outbox pattern and Kafka‑driven asynchronous processing to achieve reliable, auditable and compensatable order lifecycle management.

ConcurrencyIdempotencyKafka
0 likes · 39 min read
Designing a 12‑State Payment System State Machine from Pending to Completed
Dabaoshi
Dabaoshi
Aug 18, 2026 · Backend Development

ConcurrentHashMap Deep Dive: Understanding Java’s Core Concurrent Container

This article explains why HashMap isn’t thread‑safe, how Hashtable’s single lock hurts performance, and walks through the evolution from JDK 1.7 segment locks to JDK 1.8’s CAS‑plus‑synchronized bucket locking, including lock‑free size counting and a comparison with CopyOnWriteArrayList for read‑heavy scenarios.

ConcurrencyConcurrentHashMapCopyOnWriteArrayList
0 likes · 17 min read
ConcurrentHashMap Deep Dive: Understanding Java’s Core Concurrent Container
Dabaoshi
Dabaoshi
Aug 18, 2026 · Backend Development

Thread Pool Mechanics and Tuning: Avoid new Thread() in Production

This article explains why creating raw threads in production is costly, breaks down the seven ThreadPoolExecutor parameters, shows the exact execution flow of a submitted task, compares queue choices and Executors factories, and provides practical tuning, rejection‑policy and graceful‑shutdown guidance.

ConcurrencyExecutorServiceJava
0 likes · 16 min read
Thread Pool Mechanics and Tuning: Avoid new Thread() in Production
Niu Liu
Niu Liu
Aug 18, 2026 · Industry Insights

Go vs Java and the Mystery of China’s Missing Programming Language: What’s the Real Technical Gap?

The article compares Go and Java across history, concurrency, performance, ecosystem and developer experience, examines why Japan, not China, has produced influential languages, notes emerging Chinese language projects, and offers concrete paths for engineers to deepen their low‑level technical understanding.

Asia Tech CultureConcurrencyGo
0 likes · 16 min read
Go vs Java and the Mystery of China’s Missing Programming Language: What’s the Real Technical Gap?
Mike Chen Rui
Mike Chen Rui
Aug 18, 2026 · Operations

Comprehensive Guide to Nginx Concurrency Testing Tools

This article reviews four Nginx concurrency testing tools—Apache Bench, wrk, JMeter, and Gatling—providing command examples, key parameters, and usage scenarios, and compares their suitability for simple verification, high‑load testing, complex business flows, and code‑driven performance automation.

ConcurrencyGatlingJMeter
0 likes · 3 min read
Comprehensive Guide to Nginx Concurrency Testing Tools
Dabaoshi
Dabaoshi
Aug 17, 2026 · Fundamentals

Concurrency 07: Understanding Deadlocks and Thread‑Safety Strategies

This article explains how deadlocks arise from four necessary conditions, shows how to detect them with jstack, outlines practical ways to prevent deadlock, distinguishes livelock and starvation, and presents three prioritized approaches—immutability, thread confinement, and synchronization—to achieve thread safety in Java.

ConcurrencyDeadlockImmutable
0 likes · 16 min read
Concurrency 07: Understanding Deadlocks and Thread‑Safety Strategies
Yumin Fish Harvest
Yumin Fish Harvest
Aug 17, 2026 · Backend Development

How to Implement Distributed ID Generation with Segment Mode? A Double‑Buffer Issuer in Practice

The article analyses lock contention caused by per‑request ID generation, derives a segment‑based solution that batches IDs using a configurable step, defines a left‑closed/right‑open interval schema in MySQL, and builds a double‑buffer Java issuer with asynchronous pre‑loading, thorough concurrency handling, testing, and configuration guidelines.

ConcurrencyJavaMySQL
0 likes · 21 min read
How to Implement Distributed ID Generation with Segment Mode? A Double‑Buffer Issuer in Practice
Dabaoshi
Dabaoshi
Aug 16, 2026 · Backend Development

AQS Deep Dive: How Java’s AbstractQueuedSynchronizer Powers Concurrency

This article dissects Java’s AbstractQueuedSynchronizer (AQS), explaining its three core components—volatile state, CAS, and a FIFO wait queue—how exclusive and shared modes operate, the step‑by‑step lock acquisition flow, ReentrantLock implementation details, fairness trade‑offs, and the underlying template‑method design pattern.

AQSConcurrencyJava
0 likes · 15 min read
AQS Deep Dive: How Java’s AbstractQueuedSynchronizer Powers Concurrency
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
Open Source Tech Hub
Open Source Tech Hub
Aug 16, 2026 · Backend Development

PHP 8.6 Gains Native Async: 70+ Functions Turn Non‑Blocking

The True Async project plans to embed coroutine‑based, non‑blocking I/O directly into the PHP 8.6 core, offering an experimental v0.9.3 extension that supports over 70 native functions, a database pool, an HTTP server, and a low‑intrusion API that lets synchronous‑style code run concurrently, while warning that it is not yet production‑ready.

ConcurrencyPHPasync
0 likes · 11 min read
PHP 8.6 Gains Native Async: 70+ Functions Turn Non‑Blocking
Deepin Linux
Deepin Linux
Aug 16, 2026 · Fundamentals

Embedded Development Pitfall Guide: Are You Using Global Variables Correctly?

Global variables are convenient in embedded projects but can cause memory waste, tight module coupling, hard‑to‑track bugs, and portability issues, especially in RTOS multitasking; this article explains the underlying memory layout, common traps, and practical techniques to use globals safely.

Best PracticesConcurrencyRTOS
0 likes · 19 min read
Embedded Development Pitfall Guide: Are You Using Global Variables Correctly?
TonyBai
TonyBai
Aug 15, 2026 · Backend Development

Is the Rust Rewrite Movement Truly Blazingly Fast or Just Blazingly Hyped?

The article analyzes the three‑year Rust rewrite movement, presenting concrete performance gains, binary‑size challenges, new bugs, learning‑curve costs, and real‑world cases of both success and abandonment to help developers decide whether a Rust rewrite is worthwhile.

Binary SizeConcurrencyPerformance
0 likes · 15 min read
Is the Rust Rewrite Movement Truly Blazingly Fast or Just Blazingly Hyped?
21CTO
21CTO
Aug 14, 2026 · Artificial Intelligence

Don’t Just Focus on Python – Build Enterprise‑Grade AI Agent Architectures with Elixir and Clojure

The article compares Python, Clojure, and Elixir for building production‑ready AI agents, detailing their concurrency models, state isolation, fault tolerance, and distributed scaling, and provides concrete code samples, a feature matrix, and guidance on choosing the right language for different team and workload requirements.

AI agentsClojureConcurrency
0 likes · 12 min read
Don’t Just Focus on Python – Build Enterprise‑Grade AI Agent Architectures with Elixir and Clojure
Dabaoshi
Dabaoshi
Aug 13, 2026 · Fundamentals

Why Concurrency Is Hard: The Surprising Result of Two Threads Incrementing an int

The article explains why Java concurrency is difficult by showing that two threads each incrementing an int ten thousand times may not produce twenty thousand, then explores the motivations for multithreading, the differences between concurrency and parallelism, and the three core challenges of visibility, atomicity, and ordering.

ConcurrencyJavaMultithreading
0 likes · 23 min read
Why Concurrency Is Hard: The Surprising Result of Two Threads Incrementing an int
Golang Shines
Golang Shines
Aug 13, 2026 · Backend Development

Why Interviewers Favor These 5 Go Questions—and How to Ace Them

This article breaks down the five Go interview questions interviewers love, explains the underlying concepts such as goroutine and channel mechanics, empty‑interface pitfalls, map concurrency, defer execution, and Go modules, provides high‑scoring code examples, and offers concrete preparation tips to showcase engineering thinking and practical skills.

ConcurrencyGoInterview
0 likes · 9 min read
Why Interviewers Favor These 5 Go Questions—and How to Ace Them
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Aug 13, 2026 · Backend Development

Why asyncio.gather Errors Don’t Halt All Branches and How to Design Robust Failure Strategies

The article explains that asyncio.gather only propagates the first exception without cancelling other awaitables, distinguishes fan‑out/fan‑in from a Supervisor role, and demonstrates a pure‑Python pattern for classifying required versus optional branches, handling failures, and merging results safely.

ConcurrencyError HandlingFan-out
0 likes · 12 min read
Why asyncio.gather Errors Don’t Halt All Branches and How to Design Robust Failure Strategies
samdeepthink
samdeepthink
Aug 13, 2026 · Databases

Why High Traffic Makes SQL JOINs a Bottleneck

When traffic spikes, a multi‑table JOIN can hold database connections far longer than separate single‑table queries, quickly exhausting the connection pool and slowing the entire system, as demonstrated by concrete timing examples and a practical workaround.

ConcurrencyConnection PoolDatabase Connections
0 likes · 3 min read
Why High Traffic Makes SQL JOINs a Bottleneck
Golang Shines
Golang Shines
Aug 10, 2026 · Backend Development

Understanding Go Goroutine and Channel: Usage, Pitfalls, and Deadlock Diagnosis

The article explains Go's native concurrency with lightweight goroutines and channel communication, outlines common deadlock errors, details unbuffered and buffered channel behavior, proper close rules, select usage, and presents graceful shutdown techniques using channels, context, and sync.WaitGroup, plus practical code examples.

ConcurrencyContextDeadlock
0 likes · 20 min read
Understanding Go Goroutine and Channel: Usage, Pitfalls, and Deadlock Diagnosis
IT Learning Made Simple
IT Learning Made Simple
Aug 9, 2026 · Fundamentals

Deadlock Illustrated: Two Programmers Stuck Over a Meeting Room

The article explains deadlock by describing two programmers who each hold a meeting room and wait for the other, defines deadlock and its four necessary conditions, provides real‑world analogies, shows a Python threading example that deadlocks, and outlines prevention, avoidance, detection, and best‑practice strategies.

ConcurrencyDeadlockMultithreading
0 likes · 8 min read
Deadlock Illustrated: Two Programmers Stuck Over a Meeting Room
IT Learning Made Simple
IT Learning Made Simple
Aug 8, 2026 · Fundamentals

Processes and Threads: The Boss with N Clones

The article explains processes as independent execution units and threads as lightweight CPU‑scheduled workers, using a boss‑and‑employees metaphor, code samples in Python and Java, practical scenarios, common pitfalls like race conditions and deadlocks, and guidance on when to choose multiprocessing versus multithreading.

ConcurrencyDeadlockMultithreading
0 likes · 9 min read
Processes and Threads: The Boss with N Clones
Architecture & Thinking
Architecture & Thinking
Aug 8, 2026 · Fundamentals

Java Memory Model and Instruction Reordering: From Happens‑Before to Memory Barriers Explained

Most hidden thread‑safety bugs in Java stem from instruction reordering and memory‑visibility issues rather than simple atomicity conflicts; this article dissects the hardware‑level reordering, JMM’s happens‑before rules, and memory‑fence mechanisms, illustrating each concept with concrete code examples and classic concurrency pitfalls.

ConcurrencyHappens-BeforeJava
0 likes · 15 min read
Java Memory Model and Instruction Reordering: From Happens‑Before to Memory Barriers Explained
DeepHub IMBA
DeepHub IMBA
Aug 6, 2026 · Backend Development

10 Practical Python API Tips to Turn Scripts from Working to Robust

This article presents ten concrete Python techniques for handling APIs—automatic retries, response caching, environment‑based secrets, Pydantic schema validation, clean pagination, WebSocket streaming, rate‑limiting, concurrent requests, mock responses, and GraphQL—each illustrated with runnable code to make scripts more reliable and efficient.

APIConcurrencyGraphQL
0 likes · 8 min read
10 Practical Python API Tips to Turn Scripts from Working to Robust
Ray's Galactic Tech
Ray's Galactic Tech
Aug 5, 2026 · Backend Development

Mastering Go Concurrency: From Worker Pools to Production‑Ready Pipelines

This article analyzes why naïve goroutine usage fails in high‑throughput microservices, outlines five common concurrency pitfalls, and walks through a complete production‑grade Go pipeline—covering worker pools, semaphores, fan‑out/fan‑in, back‑pressure, error classification, observability, and step‑by‑step code implementation for an order‑processing service.

ConcurrencyGoObservability
0 likes · 29 min read
Mastering Go Concurrency: From Worker Pools to Production‑Ready Pipelines
IT Services Circle
IT Services Circle
Aug 4, 2026 · Fundamentals

Why Understanding Lock‑Free Queues Is Essential for High Concurrency

The article explains that locks are not the root cause of performance bottlenecks, examines how locked and lock‑free queues work, compares their trade‑offs with concrete benchmarks, and provides a decision guide to choose the right queue implementation for different concurrency and latency requirements.

C#CASConcurrency
0 likes · 23 min read
Why Understanding Lock‑Free Queues Is Essential for High Concurrency
liandk
liandk
Aug 2, 2026 · Databases

Why Transaction Timeouts and Deadlocks Occur: Master MySQL Row, Table, Gap Locks

This article breaks down MySQL’s locking mechanisms—table, row, and gap locks—explaining their principles, performance trade‑offs, when they are triggered, how they relate to index usage, and provides practical deadlock avoidance techniques and a concise cheat‑sheet for common concurrency problems.

ConcurrencyDeadlockLocks
0 likes · 7 min read
Why Transaction Timeouts and Deadlocks Occur: Master MySQL Row, Table, Gap Locks
Dabaoshi
Dabaoshi
Aug 1, 2026 · Fundamentals

JVM Concurrency Deep Dive: JMM and Low‑Level Synchronization

This article explains the three fundamental problems of Java concurrency—visibility, atomicity, and ordering—describes how the Java Memory Model and happens‑before rules address them, and details the low‑level implementations and optimizations of volatile, synchronized, lock upgrading, and the removal of biased locking in JDK 15‑17.

ConcurrencyJVMJava Memory Model
0 likes · 18 min read
JVM Concurrency Deep Dive: JMM and Low‑Level Synchronization
IT Services Circle
IT Services Circle
Aug 1, 2026 · Backend Development

Can Virtual Threads in Java 21 Replace CompletableFuture for Asynchronous Programming?

With Java 21's cheap virtual threads, many of the blocking‑IO patterns that forced developers to write CompletableFuture callback chains can now be expressed as straightforward synchronous code, yet CompletableFuture still offers powerful task‑orchestration features that virtual threads alone cannot replace.

Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 9 min read
Can Virtual Threads in Java 21 Replace CompletableFuture for Asynchronous Programming?
Java Tech Workshop
Java Tech Workshop
Jul 28, 2026 · Fundamentals

Why Is AQS the Cornerstone of Java Concurrency?

The article explains how Java's AbstractQueuedSynchronizer (AQS) serves as the foundational framework for most JUC utilities by encapsulating state, a FIFO wait queue, and template methods, and demonstrates its design through detailed source analysis of ReentrantLock, Semaphore, CountDownLatch, and a custom latch.

AQSAbstractQueuedSynchronizerConcurrency
0 likes · 17 min read
Why Is AQS the Cornerstone of Java Concurrency?
Code Archaeology
Code Archaeology
Jul 28, 2026 · Backend Development

How Jackson Rewrote Buffer Pooling for Java Virtual Threads

Jackson replaced its ThreadLocal-based buffer recycling with a pluggable RecyclerPool abstraction, iterated through multiple default pool implementations including a flawed LockFreePool, removed the leaky LockFreePool in 3.x, and fixed a TOCTOU race in BufferRecycler using atomic updates.

Buffer PoolingConcurrencyJackson
0 likes · 10 min read
How Jackson Rewrote Buffer Pooling for Java Virtual Threads
Java Baker
Java Baker
Jul 28, 2026 · Backend Development

Choosing the Right Distributed Lock: A Guide for Architects

Distributed locks are essential for coordinating access to shared resources across multiple machines; this article compares common solutions—Redis locks, database optimistic and logical locks, DB row locks, and Zookeeper locks—detailing their principles, pros, cons, implementation details, and best‑fit scenarios.

ConcurrencyJavaOptimistic Lock
0 likes · 15 min read
Choosing the Right Distributed Lock: A Guide for Architects
liandk
liandk
Jul 25, 2026 · Fundamentals

Why 90% of Developers Misunderstand Sync vs Async vs Blocking vs Non‑Blocking (And How to Fix It)

The article clarifies the often‑confused concepts of synchronous, asynchronous, blocking, and non‑blocking operations by introducing two independent dimensions, illustrating each with real‑world analogies, mapping them to BIO/NIO/AIO models, and offering practical guidance for choosing the right approach in different scenarios.

AIOConcurrencyNIO
0 likes · 5 min read
Why 90% of Developers Misunderstand Sync vs Async vs Blocking vs Non‑Blocking (And How to Fix It)
Random Bulletin
Random Bulletin
Jul 24, 2026 · Backend Development

Context Propagation at Ten‑Million QPS: From ThreadLocal to Explicit

The article examines a real‑world incident where ThreadLocal leakage caused user data mix‑ups, then walks through the evolution of context propagation—from implicit ThreadLocal to TTL patches, Reactor Context, ScopedValue, and Go's explicit context—highlighting trade‑offs and best practices for high‑throughput systems.

ConcurrencyContextPropagationGoContext
0 likes · 15 min read
Context Propagation at Ten‑Million QPS: From ThreadLocal to Explicit
Mike Chen Rui
Mike Chen Rui
Jul 22, 2026 · Operations

What TPS Threshold Defines High Concurrency in Payment Systems?

The article defines TPS (transactions per second), lists typical payment‑related operations that constitute a transaction, shows a concrete 1000‑TPS example, and presents an industry‑wide TPS classification table that helps determine when a payment system can be considered high‑concurrency, with practical thresholds for business, core, and large‑scale platforms.

ConcurrencyPerformanceTPS
0 likes · 3 min read
What TPS Threshold Defines High Concurrency in Payment Systems?
Coder Life Journal
Coder Life Journal
Jul 21, 2026 · Backend Development

Why ThreadPoolExecutor Won’t Expand When the Queue Isn’t Full

The article explains that ThreadPoolExecutor’s execution flow first fills core threads, then enqueues tasks, and only creates non‑core threads after the work queue is full, so a high maximumPoolSize (e.g., 100) does not guarantee rapid thread growth, and queue choice and rejection policies critically shape scaling behavior.

ConcurrencyJavaQueue
0 likes · 9 min read
Why ThreadPoolExecutor Won’t Expand When the Queue Isn’t Full
Random Bulletin
Random Bulletin
Jul 21, 2026 · Backend Development

Thread Pool Design for Million‑QPS Systems: From Shared to Isolated

The article explains how a shared thread pool can turn a localized slowdown into a system‑wide outage, then walks through the bulkhead isolation pattern, bounded queues, trade‑offs between thread‑pool and semaphore isolation, sizing formulas, monitoring metrics, and dynamic tuning for high‑QPS services.

Concurrencybulkhead patterndynamic thread pool
0 likes · 16 min read
Thread Pool Design for Million‑QPS Systems: From Shared to Isolated
liandk
liandk
Jul 21, 2026 · Fundamentals

Master Processes and Threads: A Plain‑Language Guide to Concurrency for Beginners

This article demystifies processes and threads with everyday analogies, outlines their core differences, explains why multithreading speeds up programs, and highlights common pitfalls such as thread‑safety issues, excessive threads, and crashes, providing interview‑ready knowledge for developers.

ConcurrencyInterviewoperating system
0 likes · 5 min read
Master Processes and Threads: A Plain‑Language Guide to Concurrency for Beginners
Tinker Programmer
Tinker Programmer
Jul 17, 2026 · Backend Development

How Java 21 Virtual Threads Enable 100 k Threads Without Thread‑Pool Tuning

After weeks of futile thread‑pool tuning for an IO‑bound gateway, the author switched to Java 21 virtual threads, achieving stable 5,000 concurrent requests with dramatically lower P99 latency, reduced memory usage, and higher CPU efficiency, and then explains virtual‑thread internals, Scoped Values, migration steps, and limitations.

ConcurrencyJavaPerformance
0 likes · 18 min read
How Java 21 Virtual Threads Enable 100 k Threads Without Thread‑Pool Tuning
Coder Trainee
Coder Trainee
Jul 16, 2026 · Backend Development

Complete Summary of the Six‑Part Java Interview High‑Frequency Questions Series

This article compiles all 60 high‑frequency Java interview questions from six core backend topics—basics, collections, concurrency, JVM, Spring, and microservices—provides a quick‑reference table, outlines the most common and hardest questions, and shares a five‑layer answering technique for interview success.

BackendConcurrencyInterview
0 likes · 10 min read
Complete Summary of the Six‑Part Java Interview High‑Frequency Questions Series
Programmer XiaoFu
Programmer XiaoFu
Jul 16, 2026 · Backend Development

Can Java 21 Virtual Threads Replace CompletableFuture for Async Programming?

With Java 21’s virtual threads making threads cheap, the article examines whether the traditional CompletableFuture async style can be dropped, showing that simple IO can now be written synchronously, while complex task orchestration, fallback, and timeout still benefit from CompletableFuture’s richer API.

Async ProgrammingCompletableFutureConcurrency
0 likes · 10 min read
Can Java 21 Virtual Threads Replace CompletableFuture for Async Programming?
samdeepthink
samdeepthink
Jul 14, 2026 · Backend Development

Thread‑Pool Outage Postmortem: Four Defense Layers to Prevent Data Loss

A July 13 incident revealed that sharing a single thread pool across order, refund, and status sync services caused queue saturation, task rejection, and data loss, prompting a four‑layer defense—pool isolation, CallerRunsPolicy with structured alerts, minute‑level DingTalk notifications, and a compensation tool—to ensure reliability and quick recovery.

AlertingConcurrencyFault Tolerance
0 likes · 10 min read
Thread‑Pool Outage Postmortem: Four Defense Layers to Prevent Data Loss
TonyBai
TonyBai
Jul 13, 2026 · Fundamentals

Stop Adding Java Patterns to Go: Unpacking spf13’s Idiomatic Go Principles

The article dissects spf13’s go‑skills repository, exposing how Java‑style project layouts, layered packages, heavy frameworks and misuse of generics clash with Go’s philosophy, and presents concrete, Go‑centric guidelines for package organization, interfaces, error handling, concurrency, testing, standard‑library usage, CLI design, and a pre‑code review checklist.

CLIConcurrencyError Handling
0 likes · 27 min read
Stop Adding Java Patterns to Go: Unpacking spf13’s Idiomatic Go Principles
Coder Trainee
Coder Trainee
Jul 12, 2026 · Backend Development

10 Must‑Know Java Concurrency Interview Questions

This article walks through ten essential Java concurrency interview topics—including the Java Memory Model, volatile semantics, synchronized lock upgrades, CAS pitfalls, AQS internals, ReentrantLock versus synchronized, ThreadPoolExecutor parameters, ThreadLocal memory‑leak issues, CountDownLatch vs CyclicBarrier, and deadlock conditions—providing code snippets, tables and detailed explanations to help candidates answer interview questions confidently.

AQSCASConcurrency
0 likes · 12 min read
10 Must‑Know Java Concurrency Interview Questions
Tinker Programmer
Tinker Programmer
Jul 12, 2026 · Backend Development

Go Concurrency Interview: 5 Fatal Close Pitfalls That Crash Programs

The article dissects five common ways misusing the close operation on Go channels can cause runtime panics, explains the underlying reasons, demonstrates correct patterns such as the single‑sender rule and for‑range consumption, and provides interview‑ready takeaways.

ConcurrencyGoInterview
0 likes · 10 min read
Go Concurrency Interview: 5 Fatal Close Pitfalls That Crash Programs
Tinker Programmer
Tinker Programmer
Jul 11, 2026 · Backend Development

Why Does Your Go Worker Pool Leak Goroutines? Common Pitfalls and Fixes

This article dissects the frequent bugs that cause Go worker‑pool implementations to panic, deadlock, or leak goroutines, explains the four core principles for correct channel and WaitGroup usage, showcases five typical error patterns with concrete code, and provides a complete, production‑ready solution.

ConcurrencyGoWorker Pool
0 likes · 14 min read
Why Does Your Go Worker Pool Leak Goroutines? Common Pitfalls and Fixes
Coder Trainee
Coder Trainee
Jul 9, 2026 · Backend Development

Java Concurrency Deep Dive – Part 8: Real‑World Pitfalls and Post‑mortem

This article reviews common Java concurrency pitfalls—including deadlocks, ThreadLocal memory leaks, Integer‑cache loops, unbounded thread‑pool queues, and swallowed exceptions—illustrates each with code samples, analyzes real production incidents, and provides a concise checklist and tool‑selection guide for safe concurrent programming.

Best PracticesConcurrencyConcurrentHashMap
0 likes · 9 min read
Java Concurrency Deep Dive – Part 8: Real‑World Pitfalls and Post‑mortem
Tinker Programmer
Tinker Programmer
Jul 9, 2026 · Backend Development

What Does This Go Channel Code Actually Print? A Step‑by‑Step Interview Guide

The article explains how to reliably predict the output of Go channel interview questions by drawing execution timelines, distinguishing synchronization points from print order, handling buffered vs unbuffered channels, and spotting deadlocks, providing four concrete heuristics backed by code examples and runtime observations.

ConcurrencyDeadlockGo
0 likes · 12 min read
What Does This Go Channel Code Actually Print? A Step‑by‑Step Interview Guide
Coder Trainee
Coder Trainee
Jul 8, 2026 · Backend Development

Deep Dive into Java Concurrency: Analyzing the ConcurrentHashMap Source (Part 7)

This article thoroughly examines Java's ConcurrentHashMap by tracing its evolution from JDK 1.5's segment‑lock design to JDK 8's CAS‑plus‑synchronized implementation, detailing internal structures, put/get algorithms, resizing mechanics, performance trade‑offs, and common interview questions.

ConcurrencyConcurrentHashMapJDK7
0 likes · 12 min read
Deep Dive into Java Concurrency: Analyzing the ConcurrentHashMap Source (Part 7)