BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 1 of 23
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.

DeadlockGap LockLocks
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.

KafkaMySQLconcurrency
0 likes · 39 min read
Designing a 12‑State Payment System State Machine from Pending to Completed
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.

GatlingJMeterab
0 likes · 3 min read
Comprehensive Guide to Nginx Concurrency Testing Tools
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.

JavaMySQLconcurrency
0 likes · 21 min read
How to Implement Distributed ID Generation with Segment Mode? A Double‑Buffer Issuer in Practice
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.

PHPasyncconcurrency
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.

Memory ManagementRTOSbest practices
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 SizePerformanceProject Migration
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 AgentsClojureElixir
0 likes · 12 min read
Don’t Just Focus on Python – Build Enterprise‑Grade AI Agent Architectures with Elixir and Clojure
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.

GoInterviewconcurrency
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.

Pythonasyncioconcurrency
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.

Database ConnectionsJOINPerformance
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.

DeadlockGochannel
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.

DeadlockOperating SystemsPython
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.

DeadlockParallelismconcurrency
0 likes · 9 min read
Processes and Threads: The Boss with N Clones
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.

APIGraphQLPydantic
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.

GoPipelineWorker Pool
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++CASPerformance
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.

DeadlockGap LockLocks
0 likes · 7 min read
Why Transaction Timeouts and Deadlocks Occur: Master MySQL Row, Table, Gap Locks
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 ProgrammingCompletableFutureJava
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.

AQSAbstractQueuedSynchronizerJava
0 likes · 17 min read
Why Is AQS the Cornerstone of Java Concurrency?
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.

AIONIOasynchrony
0 likes · 5 min read
Why 90% of Developers Misunderstand Sync vs Async vs Blocking vs Non‑Blocking (And How to Fix It)
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.

PerformanceTPSconcurrency
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.

JavaQueueRejectionPolicy
0 likes · 9 min read
Why ThreadPoolExecutor Won’t Expand When the Queue Isn’t Full
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.

Interviewconcurrencyoperating-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.

JavaPerformanceScoped Values
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.

InterviewJVMJava
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 ProgrammingCompletableFutureJava
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.

Javaalertingconcurrency
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.

CLIGoconcurrency
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.

AQSCASDeadlock
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.

GoInterviewchannel
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.

GoWorker Poolchannel
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.

ConcurrentHashMapDeadlockJava
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.

DeadlockGoInterview
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.

ConcurrentHashMapJDK7JDK8
0 likes · 12 min read
Deep Dive into Java Concurrency: Analyzing the ConcurrentHashMap Source (Part 7)
MaGe Linux Operations
MaGe Linux Operations
Jul 8, 2026 · Operations

How I Optimized Nginx to Double My Site’s Concurrency

The article walks through a systematic Nginx performance tuning process that starts with baseline load testing, identifies bottlenecks in worker processes, connection limits, I/O and buffering, and applies targeted configuration changes—such as auto workers, keep‑alive tuning, gzip, and proxy buffers—resulting in a three‑fold increase in concurrent request handling.

OptimizationPerformance TuningWeb Servers
0 likes · 31 min read
How I Optimized Nginx to Double My Site’s Concurrency
Coder Trainee
Coder Trainee
Jul 7, 2026 · Backend Development

Deep Dive into Java ThreadPoolExecutor: Source Code Analysis (Part 6)

This article provides a thorough, source‑level walkthrough of Java's ThreadPoolExecutor, covering its core design, state machine, seven key parameters, task‑submission flow, worker creation, execution loop, rejection policies, common pool variants, and interview‑ready explanations of the execute() process.

BlockingQueueJavaJava concurrency
0 likes · 10 min read
Deep Dive into Java ThreadPoolExecutor: Source Code Analysis (Part 6)
Coder Trainee
Coder Trainee
Jul 6, 2026 · Backend Development

Deep Dive into Java Concurrency: Practical ReentrantLock and Condition Usage

This article thoroughly compares Java's synchronized keyword with ReentrantLock, explains lock implementation details, fairness, interruptibility, timeout, and Condition usage, provides practical code examples and interview tips, and offers guidance on when to choose each synchronization mechanism.

AQSConditionJava
0 likes · 8 min read
Deep Dive into Java Concurrency: Practical ReentrantLock and Condition Usage
Cloud Architecture
Cloud Architecture
Jul 6, 2026 · Backend Development

Designing a High‑Concurrency Coupon Expiration System with Task Tables and Batch Processing

The article explains why coupon expiration cannot be handled by a simple scheduled scan and presents a production‑grade architecture that uses a task‑table, four‑plane design, fine‑grained splitting, lease‑based worker coordination, idempotent updates, and observability to reliably expire billions of coupons under peak load.

Batch ProcessingMySQLconcurrency
0 likes · 37 min read
Designing a High‑Concurrency Coupon Expiration System with Task Tables and Batch Processing
IT Services Circle
IT Services Circle
Jul 6, 2026 · Backend Development

Why Delayed Double Delete Fails to Ensure Cache Consistency Under High Concurrency

The article analyzes the delayed double‑delete cache‑consistency pattern, exposing how its fixed sleep interval, thread blocking, unreliable second delete, and inability to handle concurrent writes make it unsuitable for high‑traffic systems, and it proposes safer cache‑aside alternatives.

Cache AsideCache ConsistencyDelayed Double Delete
0 likes · 7 min read
Why Delayed Double Delete Fails to Ensure Cache Consistency Under High Concurrency
Golang Shines
Golang Shines
Jul 6, 2026 · Backend Development

Why a Simple for‑range Over a Go Channel Can Leak Goroutines

The article explains how using a for‑range loop to read from an unclosed Go channel can cause a goroutine to block forever, demonstrates the issue with a minimal example, compares explicit receives with for‑range, and shows that closing the channel is the only reliable fix, even for buffered channels.

Gochannelclose
0 likes · 7 min read
Why a Simple for‑range Over a Go Channel Can Leak Goroutines
Coder Trainee
Coder Trainee
Jul 5, 2026 · Fundamentals

Deep Dive into Java Concurrency: Inside the AQS Source Code (Part 4)

This article provides a thorough technical walkthrough of Java's AbstractQueuedSynchronizer, covering its core state and CLH queue structures, exclusive and shared lock acquisition/release processes, Condition implementation, and interview-ready explanations of its underlying mechanisms.

AQSAbstractQueuedSynchronizerCondition
0 likes · 8 min read
Deep Dive into Java Concurrency: Inside the AQS Source Code (Part 4)
Coder Trainee
Coder Trainee
Jul 4, 2026 · Backend Development

Deep Dive into Java Concurrency: The Source-Level Mechanics of synchronized

This article thoroughly examines Java's synchronized keyword, covering its three usage forms, the underlying bytecode instructions, how lock information is stored in the object header's Mark Word, the step‑by‑step lock upgrade process from no‑lock to heavyweight, and JVM optimizations such as lock elimination and coarsening, providing interview‑ready explanations.

JVMJavaLock
0 likes · 10 min read
Deep Dive into Java Concurrency: The Source-Level Mechanics of synchronized
Golang Shines
Golang Shines
Jul 3, 2026 · Backend Development

Top Go Interview Questions: defer, GMP Scheduler, Slice Internals, Channels, and Context

This article presents a curated collection of 30 essential Go interview questions covering language characteristics, object‑orientation, inheritance, polymorphism, goroutine basics, channel usage, defer execution order, memory allocation, slice vs array, map safety, error handling, context, Go modules, the GMP scheduler, and practical code examples for testing and middleware.

GoInterview Questionschannel
0 likes · 11 min read
Top Go Interview Questions: defer, GMP Scheduler, Slice Internals, Channels, and Context
Coder Trainee
Coder Trainee
Jul 3, 2026 · Fundamentals

Deep Dive into Java Concurrency Part 1: Understanding the Core via JMM

This article launches a new series on Java concurrency, explaining why concurrent programming is hard due to hardware, OS and compiler effects, detailing the Java Memory Model’s happens‑before rules, memory barriers, volatile semantics, and comparing volatile with synchronized, plus a practical double‑checked locking example.

JavaVolatileconcurrency
0 likes · 8 min read
Deep Dive into Java Concurrency Part 1: Understanding the Core via JMM
macrozheng
macrozheng
Jul 3, 2026 · Artificial Intelligence

Hand‑Craft a Claude‑Style AI Programming Agent from Scratch – A Complete Walkthrough

This article walks you through building a Claude‑style AI programming agent from the ground up, breaking the architecture into twelve incremental versions, explaining the universal agent loop, tool integration, planning, memory compression, concurrency, and multi‑agent collaboration with concrete code examples in Python, Java, Go, and TypeScript.

AI AgentAgent LoopClaude Code
0 likes · 9 min read
Hand‑Craft a Claude‑Style AI Programming Agent from Scratch – A Complete Walkthrough
IT Learning Made Simple
IT Learning Made Simple
Jul 2, 2026 · Operations

Process View: The Heartbeat of System Runtime

The article explains the process view, which reveals how a system operates at runtime, covering processes, threads, inter‑process communication, concurrency models, synchronization mechanisms, performance indicators, and design principles, illustrated with diagrams and a concrete e‑commerce case study.

IPCPerformanceSystem Design
0 likes · 9 min read
Process View: The Heartbeat of System Runtime
Golang Shines
Golang Shines
Jul 2, 2026 · Fundamentals

Why Big Companies Favor Go: Key Advantages of the Language

The article compares Go with C/C++, Java, and JavaScript, highlighting Go’s built‑in runtime, fast cross‑platform compilation, simple syntax, strong concurrency support, rich standard library and comprehensive toolchain, explaining why major tech firms adopt it.

GoLanguage comparisonToolchain
0 likes · 7 min read
Why Big Companies Favor Go: Key Advantages of the Language
Cloud Architecture
Cloud Architecture
Jul 1, 2026 · Backend Development

8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads

The article examines eight practical ways to implement asynchronous programming—thread pools, CompletableFuture, Spring @Async, message queues, event‑driven architecture, reactive streams, the Actor model, and coroutines/virtual threads—explaining their core mechanisms, trade‑offs, production‑grade configurations, and when each should be chosen.

Asynchronous ProgrammingJavaMessage Queue
0 likes · 53 min read
8 Asynchronous Programming Techniques: From Thread Pools and MQ to Virtual Threads
TonyBai
TonyBai
Jun 29, 2026 · Fundamentals

Why I Keep Returning to Go After Trying Every Language

The article argues that Go’s batteries‑included standard library eliminates dependency fatigue, its built‑in diagnostics let engineers locate production issues in hours instead of weeks, its uncolored concurrency model avoids async/await pitfalls, and its minimalism reduces cognitive load and boosts team efficiency.

Goconcurrencydependency fatigue
0 likes · 10 min read
Why I Keep Returning to Go After Trying Every Language
James' Growth Diary
James' Growth Diary
Jun 28, 2026 · Artificial Intelligence

How IterationBudget Stops Child Agents from Running Away

The article explains how Hermes' IterationBudget defines per‑agent autonomy limits, prevents cost, latency, context bloat and error amplification, supports refund and grace‑summary mechanisms, keeps parent and child budgets independent, and separates budget, timeout and concurrency controls for robust multi‑agent governance.

Budget RefundHermesIterationBudget
0 likes · 16 min read
How IterationBudget Stops Child Agents from Running Away
Coder Trainee
Coder Trainee
Jun 27, 2026 · Backend Development

Mastering Java Thread‑Pool Tuning: Practical Performance Tips

This article explains why Java thread pools need tuning, walks through the seven core ThreadPoolExecutor parameters, provides formula‑based sizing, offers configuration templates for different workloads, shows monitoring and dynamic adjustment techniques, and highlights common pitfalls with concrete code examples.

JavaPerformance TuningThreadPoolExecutor
0 likes · 8 min read
Mastering Java Thread‑Pool Tuning: Practical Performance Tips
samdeepthink
samdeepthink
Jun 27, 2026 · Backend Development

Why Interviewers Insist on High‑Concurrency Questions

The article explains that interviewers ask high‑concurrency questions not because the company’s workload is heavy, but to test candidates’ understanding of concurrency concepts, distinguish skill levels, and assess their ability to handle even low‑traffic scenarios that still involve concurrent operations.

InterviewLocksconcurrency
0 likes · 6 min read
Why Interviewers Insist on High‑Concurrency Questions
Tinker Programmer
Tinker Programmer
Jun 25, 2026 · Interview Experience

Singleton Pattern: 6 Implementations, DCL Volatile Pitfall, Spring vs GoF

The article examines the evolution of six singleton implementations in Java, explains why the double‑checked locking pattern requires the volatile keyword to prevent instruction reordering bugs, compares Spring container‑managed singletons with classic GoF singletons, and highlights common pitfalls such as mutable state in singleton beans.

Design PatternJavaVolatile
0 likes · 13 min read
Singleton Pattern: 6 Implementations, DCL Volatile Pitfall, Spring vs GoF
Programmer XiaoFu
Programmer XiaoFu
Jun 25, 2026 · Backend Development

Why Delayed Double Delete Fails to Ensure Cache Consistency Under High Concurrency

The article dissects the delayed double‑delete pattern for Redis‑MySQL consistency, exposing its hidden pitfalls—unreliable delay timing, thread‑blocking sleeps, fragile second‑delete retries, and concurrent‑write anomalies—then recommends cache‑aside and stronger alternatives for production systems.

Cache AsideCache ConsistencyDelayed Double Delete
0 likes · 7 min read
Why Delayed Double Delete Fails to Ensure Cache Consistency Under High Concurrency
Golang Shines
Golang Shines
Jun 22, 2026 · Backend Development

Building a Million‑Scale WebSocket Push Service with Go

This article compares pull and push models, explains WebSocket fundamentals, evaluates Node.js, C/C++ and Go for server implementation, provides complete Go and HTML client code, analyzes kernel, lock and CPU bottlenecks of a ten‑million‑user push system, and presents concrete optimization and clustering strategies.

GoMessage Pushbackend
0 likes · 12 min read
Building a Million‑Scale WebSocket Push Service with Go
Code Farming
Code Farming
Jun 22, 2026 · Backend Development

Why Your Distributed Lock Keeps Failing in Production (And How to Fix It)

This article explains the three fundamental challenges of distributed locks—availability, deadlock, and split‑brain—compares database and Redis implementations, walks through the five evolutionary steps of Redis locking, and provides a structured interview answer framework to demonstrate deep understanding.

MySQLRedisRedlock
0 likes · 8 min read
Why Your Distributed Lock Keeps Failing in Production (And How to Fix It)
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 18, 2026 · Databases

How Much Concurrency Can MySQL Handle? A Practical Breakdown

MySQL’s concurrency capacity isn’t a single number; it’s measured by QPS and TPS and varies with query complexity, indexing, transaction design, and hardware, with simple indexed reads reaching several thousand QPS on a well‑tuned server, while mixed or complex workloads often cap around one to two thousand QPS.

Database PerformanceHardwareMySQL
0 likes · 3 min read
How Much Concurrency Can MySQL Handle? A Practical Breakdown
Cloud Architecture
Cloud Architecture
Jun 18, 2026 · Backend Development

Microservices: Rebuilding Systems, Not Just Splitting Projects – A Production‑Ready Guide

This comprehensive guide explains why microservices are a system‑reconstruction effort rather than a simple code‑splitting exercise, covering when to split, how to define service boundaries, concurrency governance, reliable messaging, observability, deployment, security, and a step‑by‑step production checklist.

architectureconcurrencydeployment
0 likes · 48 min read
Microservices: Rebuilding Systems, Not Just Splitting Projects – A Production‑Ready Guide
Code Mala Tang
Code Mala Tang
Jun 18, 2026 · Artificial Intelligence

From Tool Calls to Real Execution: Inside Claude Code’s 43‑Tool Scheduling System

The article dissects Claude Code’s tool runtime, detailing how a unified TypeScript interface, a feature‑gated registry, a seven‑stage dispatch pipeline, and a concurrency scheduler transform model‑generated tool_use blocks into safe, parallel or serial system operations, including dynamic MCP extensions.

Claude CodeLLM Tool ExecutionMCP
0 likes · 19 min read
From Tool Calls to Real Execution: Inside Claude Code’s 43‑Tool Scheduling System
TonyBai
TonyBai
Jun 18, 2026 · Backend Development

Why Choose Go Over Rust in the AI Coding Era?

Even though AI tools have erased the learning curve for Rust, engineers still favor Go because its simple syntax, preemptive scheduler, rich standard library, and low cognitive load make code easier to read, maintain, and operate at scale.

AI code generationGoRust
0 likes · 10 min read
Why Choose Go Over Rust in the AI Coding Era?
Architect Chen
Architect Chen
Jun 16, 2026 · Backend Development

A Complete Illustrated Guide to Java Concurrency for High‑Performance Architecture

This article provides a thorough, image‑rich overview of Java concurrency, covering the differences between concurrency and parallelism, thread lifecycle states, various ways to create threads, thread‑pool design and workflow, the Java Memory Model, and essential JUC utilities, all illustrated with code snippets and diagrams.

JUCJavaconcurrency
0 likes · 8 min read
A Complete Illustrated Guide to Java Concurrency for High‑Performance Architecture
Java Tech Workshop
Java Tech Workshop
Jun 14, 2026 · Backend Development

Spring Bean Scopes: 5 Types, Common Pitfalls and Concurrency Gotchas

The article explains the five Spring Bean scopes, clarifies that scope only controls instance count and not thread safety, and walks through real‑world concurrency bugs such as mutable singleton fields, prototype beans losing their prototype nature, and request‑scoped beans failing in async threads, offering concrete fixes and usage recommendations.

Bean ScopeJavaPrototype
0 likes · 10 min read
Spring Bean Scopes: 5 Types, Common Pitfalls and Concurrency Gotchas
Golang Shines
Golang Shines
Jun 12, 2026 · Backend Development

Analyzing a Simple Goroutine Resource Pool (tunny)

The article dissects tunny's simple goroutine resource pool, explaining how workWrapper limits goroutine count, how workerWrapper.run processes workRequests via jobChan and retChan, and details the required Worker interface methods, concluding that tunny's core ideas can be adapted for custom pool implementations.

GoWorker interfaceconcurrency
0 likes · 6 min read
Analyzing a Simple Goroutine Resource Pool (tunny)
Architect Chen
Architect Chen
Jun 12, 2026 · Databases

How to Prevent MySQL Deadlocks in High‑Concurrency Apps: 5 Proven Solutions

The article defines MySQL deadlocks, illustrates how circular lock waits between transactions cause them, and presents five practical mitigation techniques—consistent lock ordering, shortening transactions, optimizing indexes, breaking large SQL statements into smaller batches, and implementing application‑level retry logic—to reduce deadlock occurrences in high‑concurrency environments.

DeadlockIndex OptimizationMySQL
0 likes · 5 min read
How to Prevent MySQL Deadlocks in High‑Concurrency Apps: 5 Proven Solutions
Architect Chen
Architect Chen
Jun 11, 2026 · Fundamentals

Understanding Java Thread Deadlocks: 5 Common Scenarios and How to Fix Them

The article defines Java thread deadlock, illustrates five typical deadlock patterns with diagrams, shows how they cause threads to wait indefinitely, and presents five practical solutions—including consistent lock ordering, reducing nested locks, shrinking lock scope, using timed locks, and adopting lock‑free designs.

DeadlockJavaLock
0 likes · 3 min read
Understanding Java Thread Deadlocks: 5 Common Scenarios and How to Fix Them
CodeNotes
CodeNotes
Jun 10, 2026 · Backend Development

After a Decade with Map, Are You Still Using containsKey + get + put?

The article reviews the seven Java 8 Map convenience APIs—getOrDefault, putIfAbsent, computeIfAbsent, computeIfPresent, compute, merge, and forEach—plus replaceAll and Map.of, showing concise code examples, best‑practice recommendations, concurrency considerations, and common pitfalls for modern Java developers.

APICollectionsJava
0 likes · 10 min read
After a Decade with Map, Are You Still Using containsKey + get + put?
ITPUB
ITPUB
Jun 9, 2026 · Backend Development

How to Prevent Server Crashes from Concurrent Excel Exports with a Queue

The article explains why simultaneous Excel exports can overload a server, proposes a fixed‑size FIFO queue to serialize export tasks, and provides a complete Spring‑Boot implementation—including the ExportQueue, abstract export logic with EasyExcel, and a test controller—to demonstrate the queuing mechanism in action.

EasyExcelExcel exportJava
0 likes · 11 min read
How to Prevent Server Crashes from Concurrent Excel Exports with a Queue
Java Architect Essentials
Java Architect Essentials
Jun 8, 2026 · Backend Development

How to Configure a ThreadPool to Send 10 Million SMS in One Hour (Java)

The article walks through calculating the required QPS for 10 million SMS in an hour, derives a precise ThreadPoolExecutor configuration (core 200, max 500, queue 5000, 60 s keep‑alive, CallerRunsPolicy), and provides complete Spring Boot code with production tips such as pagination, retry, idempotency and rate‑limiting.

JavaPerformanceSpring Boot
0 likes · 7 min read
How to Configure a ThreadPool to Send 10 Million SMS in One Hour (Java)
Golang Shines
Golang Shines
Jun 5, 2026 · Backend Development

Using Go’s unique Package for Efficient String Interning

The article explains string interning as a memory‑saving technique, shows how to implement it manually in Go, compares the go4.org/intern library with the standard‑library unique package, and presents benchmark results that reveal memory savings but a modest speed trade‑off.

Performancebenchmarkconcurrency
0 likes · 15 min read
Using Go’s unique Package for Efficient String Interning
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 5, 2026 · Backend Development

5 Advanced Java Concurrency Tricks That Can Triple Your Throughput

This article walks through five proven Java 21 concurrency tuning techniques—including non‑blocking CompletableFuture pipelines, StampedLock for read‑heavy workloads, bounded queues with CallerRunsPolicy, atomic computeIfAbsent usage in ConcurrentHashMap, and correct virtual‑thread patterns—showing how each can dramatically improve throughput and stability in high‑load systems.

CompletableFutureConcurrentHashMapJava
0 likes · 9 min read
5 Advanced Java Concurrency Tricks That Can Triple Your Throughput
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 3, 2026 · Backend Development

15 Golden Rules for High‑Performance, Maintainable Java Code

This article presents fifteen concrete Java performance‑optimization rules—from readable code and proper data structures to efficient string handling, database access, caching, multithreading, reflection, JVM tuning, and memory management—each illustrated with before/after code examples and practical advice.

JVMJavaMemory Management
0 likes · 14 min read
15 Golden Rules for High‑Performance, Maintainable Java Code
IT Services Circle
IT Services Circle
Jun 1, 2026 · Fundamentals

Why Does ThreadPoolExecutor Queue Tasks When Max Threads Are Still Idle?

The article explains why Java's ThreadPoolExecutor places tasks into its work queue before creating non‑core threads, describes the underlying JDK execution steps, shows how Tomcat customizes the queue to prioritize thread creation, and warns about misconfiguring unbounded queues that can cripple performance.

JavaLinkedBlockingQueueTaskQueue
0 likes · 8 min read
Why Does ThreadPoolExecutor Queue Tasks When Max Threads Are Still Idle?
samdeepthink
samdeepthink
Jun 1, 2026 · Backend Development

Why One ThreadLocal Instance Suffices for an Entire Business Scenario

The article explains that a single ThreadLocal object can be shared across dozens of threads because the actual data lives in each thread's own ThreadLocalMap, outlines how set/get work, highlights thread‑pool pitfalls such as stale data and memory leaks, and provides best‑practice guidelines for static declaration, proper removal, and using TransmittableThreadLocal for cross‑thread propagation.

JavaStatic FinalThreadLocal
0 likes · 10 min read
Why One ThreadLocal Instance Suffices for an Entire Business Scenario
Su San Talks Tech
Su San Talks Tech
Jun 1, 2026 · Backend Development

Can Java 21’s Virtual Threads Make Thread Pools Obsolete?

The article examines whether Java 21’s cheap virtual threads can replace traditional thread pools, explaining the original purpose of pools, their role as natural throttlers, scenarios where virtual threads excel or fail, and practical guidelines to avoid pitfalls like pinning.

JavaJava 21Virtual Threads
0 likes · 7 min read
Can Java 21’s Virtual Threads Make Thread Pools Obsolete?
Programmer1970
Programmer1970
May 31, 2026 · Fundamentals

Why synchronized is slower – tracing its roots from MESI cache coherence

The article demystifies why Java's synchronized keyword can be slower by tracing the full path from CPU cache‑coherence (MESI) through bus and cache locks, volatile, biased and lightweight locks, up to the heavyweight monitor implementation, revealing each layer’s impact on visibility, ordering and atomicity.

JVMJavaVolatile
0 likes · 15 min read
Why synchronized is slower – tracing its roots from MESI cache coherence
James' Growth Diary
James' Growth Diary
May 28, 2026 · Artificial Intelligence

How Agents Determine Which Skills Are Useful and Which to Retire

The article explains Hermes' skill provenance and usage‑tracking system, showing why file timestamps are insufficient, how three skill categories and two defense lines isolate agent‑created skills, how sidecar .usage.json records detailed counters, and how atomic writes and file locks ensure safe concurrent updates for accurate Curator decisions.

AgentHermesatomic write
0 likes · 16 min read
How Agents Determine Which Skills Are Useful and Which to Retire
Java Tech Workshop
Java Tech Workshop
May 27, 2026 · Backend Development

SpringBoot Consumer Concurrency: Tuning Thread Pools to Prevent MQ Backlog

In distributed systems, MQ message pile‑up, consumption delays, and service stalls are often caused by poorly configured consumer thread pools, and this article explains the underlying concurrency model, core parameters, custom pool setup, tuning formulas, common pitfalls, and best‑practice configurations for SpringBoot RabbitMQ consumers.

PrefetchSpringBootconcurrency
0 likes · 13 min read
SpringBoot Consumer Concurrency: Tuning Thread Pools to Prevent MQ Backlog
James' Growth Diary
James' Growth Diary
May 25, 2026 · Artificial Intelligence

Practical Agent Performance Tuning: Slash Latency 75%, Cut Token Costs 71%, Boost Throughput 217%

The article walks through a systematic performance map of LangChain agents and demonstrates concrete latency, token‑usage, and concurrency optimizations—streaming responses, Redis caching, model routing, prompt trimming, context summarisation, dynamic tool selection, parallel graph nodes and batch processing—showing real‑world gains of up to 75% lower latency, 71% fewer tokens and a 217% throughput increase.

Agent OptimizationLangChainLangGraph
0 likes · 30 min read
Practical Agent Performance Tuning: Slash Latency 75%, Cut Token Costs 71%, Boost Throughput 217%
Golang Shines
Golang Shines
May 25, 2026 · Backend Development

Why Go Is the Go-To Language for High-Concurrency Backend Services

The article explains why backend engineers are switching from PHP to Go for high‑concurrency workloads, demonstrates how Go’s goroutine model reduces request latency compared with serial PHP calls, provides concrete WaitGroup and errgroup implementations, and warns about closure capture pitfalls in loops.

ErrGroupGobackend
0 likes · 10 min read
Why Go Is the Go-To Language for High-Concurrency Backend Services
Subtle Storm
Subtle Storm
May 17, 2026 · Backend Development

Why Distributed Locks Matter and How to Implement Them with DB, Redis, and ZooKeeper

The article explains why a simple JVM lock fails in multi‑instance services, illustrates the overselling problem with an e‑commerce example, and then compares three practical distributed‑lock solutions—database‑based, Redis‑based, and ZooKeeper‑based—detailing their mechanisms, strengths, weaknesses, and suitable scenarios.

DatabaseJavaZookeeper
0 likes · 8 min read
Why Distributed Locks Matter and How to Implement Them with DB, Redis, and ZooKeeper
Deepin Linux
Deepin Linux
May 16, 2026 · Fundamentals

Mastering SMP Multi-Core Out-of-Order Execution to Grasp Linux Concurrency

This article deeply dissects the hardware origins of SMP multi‑core out‑of‑order execution, explains four classic memory‑reordering scenarios, and shows how Linux kernel memory barriers constrain the chaos, enabling developers to reliably reason about and fix complex multi‑core concurrency bugs.

CPUSMPconcurrency
0 likes · 34 min read
Mastering SMP Multi-Core Out-of-Order Execution to Grasp Linux Concurrency
DeepHub IMBA
DeepHub IMBA
May 13, 2026 · Artificial Intelligence

5 Python Decorators to Stabilize Your Machine Learning Pipeline

The article presents five practical Python decorators—Concurrency Limiter, Structured Logger, Feature Injector, Deterministic Seed Setter, and Dev‑Mode Fallback—explaining their implementation, why they matter for AI workloads, and how they keep ML pipelines maintainable, reproducible, and resilient under load.

AI PipelineLoggingMachine Learning
0 likes · 9 min read
5 Python Decorators to Stabilize Your Machine Learning Pipeline
21CTO
21CTO
May 12, 2026 · Backend Development

Why Go Is the Most Direct Language for Backend Development

The article argues that Go’s fast compilation, single‑binary output, minimal dependencies, rich standard library, lightweight concurrency model, and built‑in tooling make it a straightforward, production‑ready choice for backend services, contrasting it with the complexity of typical Node, Rails, or JavaScript stacks.

Gobackend developmentconcurrency
0 likes · 12 min read
Why Go Is the Most Direct Language for Backend Development
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 12, 2026 · Backend Development

Reproducing Three Classic Spring Boot Concurrency Deadlocks in Just 10 Lines

The article explains three typical deadlock scenarios in Spring Boot 3.5—circular‑wait, connection‑pool starvation, and implicit DML deadlocks—shows minimal 10‑line code reproductions, demonstrates the resulting errors, and provides concrete fixes such as ordered locking, removing REQUIRES_NEW propagation, and using asynchronous events.

DeadlockJavaSpring Boot
0 likes · 9 min read
Reproducing Three Classic Spring Boot Concurrency Deadlocks in Just 10 Lines
IT Services Circle
IT Services Circle
May 11, 2026 · Fundamentals

Why a Single await Can Turn Half Your Project Red

The article explains how introducing a single async/await call can propagate through an entire codebase, turning many functions "red" and creating hidden performance and maintenance problems, while tracing the historical evolution of async programming, its pitfalls, and emerging alternatives like Java Loom and Zig.

Async/AwaitJava LoomRust
0 likes · 13 min read
Why a Single await Can Turn Half Your Project Red
Programmer XiaoFu
Programmer XiaoFu
May 8, 2026 · Backend Development

Can Java 21 Virtual Threads Render Thread Pools Obsolete?

The article examines how Java 21’s cheap virtual threads change the role of traditional thread pools, explaining why pooling virtual threads is a bad idea, how thread pools still act as natural throttlers, and which scenarios—especially CPU‑bound work and synchronized blocks—remain unsuitable for virtual threads.

JDK 21JavaPinning
0 likes · 8 min read
Can Java 21 Virtual Threads Render Thread Pools Obsolete?
TonyBai
TonyBai
May 7, 2026 · Backend Development

Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model

The article revisits the heated debate sparked by AWS evangelist James Ward, who argues that Go’s concurrency primitives are inferior to the JVM’s virtual threads, structured concurrency, and effect systems, using a demanding connection‑pool challenge to illustrate the trade‑offs and guide architects in choosing the right model for their workloads.

Effect SystemsGoJVM
0 likes · 11 min read
Why an AWS Evangelist Calls Go’s Concurrency a Joke Compared to JVM’s Superior Model