BestHub
Sign in
Tagged articles

concurrency

2269 articles · Page 2 of 23
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.

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

JUCJavaJava Memory Model
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 ScopeJavaSpring
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.

Index OptimizationMySQLconcurrency
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.

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

BackendEasyExcelExcel Export
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.

Memory OptimizationPerformancebenchmark
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.

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

JavaMemory LeakStatic Final
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 21Thread Pool
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.

JVMJavacache-coherence
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.

RabbitMQSpringBootThread Pool
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.

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

JavaZooKeeperconcurrency
0 likes · 8 min read
Why Distributed Locks Matter and How to Implement Them with DB, Redis, and ZooKeeper
dbaplus Community
dbaplus Community
May 17, 2026 · Databases

Is Raising work_mem from 4 MB to 64 MB Really Optimizing Sorts? The 2 TB PostgreSQL OOM Time Bomb

The article explains why increasing PostgreSQL's work_mem does not guarantee per‑query memory limits, how multiple sort/hash nodes, parallel workers and long‑lived memory contexts can cause OOM even on a 2 TB server, and offers concrete diagnostics and mitigation strategies for DBAs and developers.

OOMPostgreSQLQuery Optimization
0 likes · 12 min read
Is Raising work_mem from 4 MB to 64 MB Really Optimizing Sorts? The 2 TB PostgreSQL OOM Time Bomb
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.

CPUKernelLinux
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 PipelineDecoratorPython
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.

Backend DevelopmentGoconcurrency
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.

@TransactionalJavaSpring 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.

Java LoomLanguage DesignRust
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 21JavaSemaphore
0 likes · 8 min read
Can Java 21 Virtual Threads Render Thread Pools Obsolete?
CodeSmart Hoops
CodeSmart Hoops
May 7, 2026 · Interview Experience

E‑commerce Concurrency Case Study: 12 Interview Questions with Answers

This article provides a self‑test for interview preparation, presenting twelve common interview questions and detailed answers on an e‑commerce concurrency case, covering serial vs async performance, CompletableFuture.allOf, ConcurrentHashMap.compute atomicity, layered cache design, Semaphore rate limiting, ReentrantLock fairness, AtomicInteger CAS, exceptional fallback, double‑layer protection, concurrency safety testing, thread‑pool configuration, and precise cache invalidation.

CompletableFutureJavaReentrantLock
0 likes · 21 min read
E‑commerce Concurrency Case Study: 12 Interview Questions with Answers
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
James' Growth Diary
James' Growth Diary
May 6, 2026 · Backend Development

How Claude Code’s Task System Uses 7 TaskTypes and 9‑Char IDs for Clear Debugging

The article dissects Claude Code’s task architecture, explaining the 7‑type TaskType union, the 9‑character prefixed ID scheme, the TaskStatus state machine, guard functions, incremental output handling, a minimal kill‑only interface, and a stall‑watchdog that together make concurrent Agent debugging both readable and secure.

TaskTypebackend designconcurrency
0 likes · 18 min read
How Claude Code’s Task System Uses 7 TaskTypes and 9‑Char IDs for Clear Debugging
LuTiao Programming
LuTiao Programming
May 6, 2026 · Fundamentals

HashMap Deep Dive: How Hash Collisions Are Resolved and When Lists Turn into Red‑Black Trees

HashMap is not a simple key‑value store but an array‑based scheduling system that uses a three‑step put process, hash perturbation, bit‑wise indexing, and conditional conversion of long bucket lists into red‑black trees, with resize mechanics that can become performance bottlenecks in high‑concurrency Java applications.

Data StructuresHashMapJava
0 likes · 8 min read
HashMap Deep Dive: How Hash Collisions Are Resolved and When Lists Turn into Red‑Black Trees
CodeNotes
CodeNotes
May 4, 2026 · Backend Development

Mastering ThreadLocal in Java: Core Principles, Real‑World Scenarios & Best Practices

This article explains how ThreadLocal provides per‑thread variable copies in Java web applications, details its internal storage in Thread objects, showcases ten practical scenarios—from request tracing to async tasks—and highlights common pitfalls such as memory leaks and thread‑pool data contamination, offering concrete best‑practice recommendations.

JavaMemoryLeakSpring
0 likes · 23 min read
Mastering ThreadLocal in Java: Core Principles, Real‑World Scenarios & Best Practices
Deepin Linux
Deepin Linux
May 3, 2026 · Backend Development

Master Lock‑Free Queues: Unlock the Core of High‑Concurrency Programming

This article demystifies lock‑free queues by explaining their low‑level implementation, atomic operations, memory barriers, and the four SPSC/MPMC models, while also covering ABA problems, false sharing avoidance, and practical C++ code examples to help developers truly understand high‑concurrency fundamentals.

C++CASMPMC
0 likes · 44 min read
Master Lock‑Free Queues: Unlock the Core of High‑Concurrency Programming
Golang Shines
Golang Shines
May 1, 2026 · Backend Development

Mastering Go Concurrency: From Basics to Advanced Patterns

The article walks readers through Go's concurrency model, explaining lightweight goroutines and channel communication, demonstrates common patterns such as worker pools and fan‑in/fan‑out with concrete code, highlights typical pitfalls like race conditions, deadlocks and memory leaks, and offers practical best‑practice recommendations for safe concurrent programming.

GoWorker Poolchannel
0 likes · 10 min read
Mastering Go Concurrency: From Basics to Advanced Patterns
Architect's Guide
Architect's Guide
May 1, 2026 · Backend Development

Senior Architects Reveal a Comprehensive Learning Roadmap for Aspiring System Designers

The article outlines a step‑by‑step learning system compiled by senior architects, covering skill foundations, source‑code analysis, distributed and microservice architectures, concurrency, performance tuning, essential Java tools, and a hands‑on e‑commerce project to help developers become well‑rounded architects.

JavaMicroservicesconcurrency
0 likes · 7 min read
Senior Architects Reveal a Comprehensive Learning Roadmap for Aspiring System Designers
Java Architect Handbook
Java Architect Handbook
Apr 30, 2026 · Fundamentals

What Is a Daemon Thread and How Does It Differ From a Normal Thread?

The article explains that a daemon (background) thread in Java supports user threads but does not prevent JVM shutdown; when all non‑daemon threads finish, the JVM exits regardless of daemon threads, covering definitions, usage scenarios, creation methods, pitfalls, detailed comparisons, and typical interview questions.

DaemonThreadJVMJava
0 likes · 10 min read
What Is a Daemon Thread and How Does It Differ From a Normal Thread?
Architect-Kip
Architect-Kip
Apr 29, 2026 · Backend Development

A Generic State Machine Solution for Managing Business Entity Lifecycles

This article presents a comprehensive state‑machine‑based approach for managing the lifecycle of business entities such as orders and work orders, detailing core pain points, essential questions a state machine must answer, a comparative analysis of four implementation options, and a recommended solution that combines a database transition table, domain services, and optimistic‑lock concurrency control, along with architecture diagrams, code snippets, and operational guidelines.

Domain ServiceOptimistic Lockaudit log
0 likes · 15 min read
A Generic State Machine Solution for Managing Business Entity Lifecycles
Java Architect Handbook
Java Architect Handbook
Apr 29, 2026 · Backend Development

How Many Ways Can You Create a ThreadPool in Java? Interview Essentials

The article explains the four ways to create a thread pool in Java, why the Executors factory methods are unsafe for production, how to manually configure ThreadPoolExecutor with its seven parameters, and compares scheduled and ForkJoin pools while providing interview‑focused Q&A and practical configuration formulas.

ExecutorsForkJoinPoolJava
0 likes · 14 min read
How Many Ways Can You Create a ThreadPool in Java? Interview Essentials
Architecture & Thinking
Architecture & Thinking
Apr 29, 2026 · Backend Development

Must‑Know CompletableFuture: Usage, Best Practices, and Real‑World Scenarios

This article explains why CompletableFuture replaces traditional Future in high‑concurrency Java applications, demonstrates core APIs such as runAsync, supplyAsync, thenApply, allOf, anyOf, thenCombine, and exception handling, and provides detailed code examples—including serial, parallel, aggregation, and an e‑commerce order‑processing case—to guide robust asynchronous programming.

Asynchronous ProgrammingCompletableFutureJava
0 likes · 26 min read
Must‑Know CompletableFuture: Usage, Best Practices, and Real‑World Scenarios
LuTiao Programming
LuTiao Programming
Apr 28, 2026 · Backend Development

How I Built a High‑Performance Java Price‑Comparison Engine from Scratch

Starting from a simple sequential Java price‑aggregator, the article walks through successive architectural upgrades—concurrent calls with CompletableFuture, timeout and fallback handling, Spring Boot service exposure, caching, bulkhead isolation, microservice split, and Kafka‑driven event processing—showing how latency drops from 1500 ms to under 20 ms.

JavaKafkaMicroservices
0 likes · 9 min read
How I Built a High‑Performance Java Price‑Comparison Engine from Scratch
Architect Chen
Architect Chen
Apr 26, 2026 · Backend Development

What Is Nginx’s Maximum Concurrent Connections? A Complete Guide

The article explains that Nginx’s maximum concurrent connections are not a fixed number but are calculated from the worker_processes and worker_connections settings and are ultimately limited by the operating system’s file‑descriptor (ulimit) limits, providing formulas, an example configuration, and commands to verify the limits.

NginxServer configurationconcurrency
0 likes · 3 min read
What Is Nginx’s Maximum Concurrent Connections? A Complete Guide
Ops Community
Ops Community
Apr 26, 2026 · Operations

8 Common Shell Script Mistakes Junior Ops Engineers Make (Are You Guilty?)

This article examines the eight most frequent errors junior and mid‑level Linux operations engineers make when writing Bash scripts—such as missing quotes, wrong comparison operators, incomplete file checks, ignoring return codes, mishandling spaces, concurrency issues, lack of error handling, and absent logging—and provides concrete examples, detailed analysis, and corrected code snippets to improve script reliability and maintainability.

bashconcurrencyerror handling
0 likes · 26 min read
8 Common Shell Script Mistakes Junior Ops Engineers Make (Are You Guilty?)
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 26, 2026 · Backend Development

Why Misusing JPA findById Hurts Performance and Causes Critical Pitfalls

The article dissects how the default JpaRepository findById method can trigger unnecessary SELECT queries, create foreign‑key violations under concurrency, and degrade performance, then demonstrates three concrete workarounds—including getReferenceById, manual entity construction, and pessimistic read locking—to eliminate these issues.

JPAPerformancePessimistic Lock
0 likes · 8 min read
Why Misusing JPA findById Hurts Performance and Causes Critical Pitfalls
James' Growth Diary
James' Growth Diary
Apr 25, 2026 · Artificial Intelligence

Deep Dive into LangGraph State Management: How Reducer, Annotation, and Channel Relate

LangGraph’s state management hinges on three core concepts—Channel as the storage unit, Annotation as the declarative API for Channels, and Reducer as the pure function that merges updates—understanding their interactions resolves common bugs, enables custom state schemas, and ensures correct concurrent node updates.

LangGraphReducerTypeScript
0 likes · 14 min read
Deep Dive into LangGraph State Management: How Reducer, Annotation, and Channel Relate
Tech Freedom Circle
Tech Freedom Circle
Apr 25, 2026 · Fundamentals

Why a Simple Singleton Answer Failed an Alibaba Interview: The Real Role of volatile, Memory Barriers, and Happens‑Before

The article dissects an Alibaba interview question about the volatile modifier, showing why answering only with a lazy‑loaded singleton is insufficient, and explains how volatile prevents instruction reordering, establishes memory barriers, and creates happens‑before relationships to make double‑checked locking safe.

Happens-BeforeJavaconcurrency
0 likes · 20 min read
Why a Simple Singleton Answer Failed an Alibaba Interview: The Real Role of volatile, Memory Barriers, and Happens‑Before
Java Architect Handbook
Java Architect Handbook
Apr 24, 2026 · Interview Experience

Why Use Coroutines When Threads Already Exist? Java Interview Deep Dive

An interview‑focused analysis explains how processes allocate resources, threads handle CPU scheduling, and coroutines act as lightweight user‑mode threads, comparing their creation costs, switching overhead, and memory usage, and highlights Java 19/21 virtual threads as the Java implementation of coroutines.

JavaVirtual Threadsconcurrency
0 likes · 13 min read
Why Use Coroutines When Threads Already Exist? Java Interview Deep Dive
Cloud Architecture
Cloud Architecture
Apr 23, 2026 · Backend Development

Gracefully Stopping Java Threads: Kernel Mechanics to Cloud‑Native Guide

This article explains why Java threads cannot be force‑killed, how Thread.interrupt works, and provides a step‑by‑step framework—including cooperative cancellation, two‑phase termination, thread‑pool shutdown, Kafka consumer handling, Spring Boot lifecycle integration, and Kubernetes termination orchestration—to achieve safe, observable shutdown of production‑grade Java services.

Graceful ShutdownJavaKafka
0 likes · 31 min read
Gracefully Stopping Java Threads: Kernel Mechanics to Cloud‑Native Guide
Deepin Linux
Deepin Linux
Apr 23, 2026 · Fundamentals

Master Spinlock: Understand Linux Kernel Synchronization and Avoid Deadlocks

This article explains Linux kernel spinlocks—from basic concepts and atomic operations to memory barriers, busy‑waiting, and proper usage—illustrating common pitfalls like deadlocks, priority inversion, and recursion, and provides practical guidelines, code examples, and debugging tools to help developers implement safe, efficient synchronization.

C++ atomicLinux kernelLockdep
0 likes · 36 min read
Master Spinlock: Understand Linux Kernel Synchronization and Avoid Deadlocks
Java Architect Handbook
Java Architect Handbook
Apr 22, 2026 · Backend Development

How Changing Five Lines of Code Boosted API Throughput Over 10×

A low‑traffic B2B service struggled to meet a 500 req/s demand, achieving only 50 req/s with high CPU usage; through systematic profiling, lock analysis, async refactoring, thread‑pool tuning, and eliminating costly Spring bean creation, the team dramatically improved response times and throughput, revealing deeper CPU‑usage mysteries.

JavaPerformance OptimizationProfiling
0 likes · 16 min read
How Changing Five Lines of Code Boosted API Throughput Over 10×
Tinker Programmer
Tinker Programmer
Apr 21, 2026 · Backend Development

Master Go Interview: From Project Engineering to Low‑Level Internals in One Guide

This comprehensive guide covers the most frequent Go interview topics for 2026, including project engineering, slice and map internals, interface mechanics, the GMP scheduler, channel implementation, context usage, memory‑leak pitfalls, pprof profiling, garbage‑collection details, escape analysis, memory alignment, defer traps, sync.Pool, and reflection, all illustrated with concrete code examples and step‑by‑step explanations.

GCGoMemory
0 likes · 35 min read
Master Go Interview: From Project Engineering to Low‑Level Internals in One Guide
Java Backend Full-Stack
Java Backend Full-Stack
Apr 20, 2026 · Backend Development

What Skills Should a 3‑Year Java Backend Developer Master?

The article outlines a comprehensive skill matrix for a three‑year Java backend engineer, covering core Java and JVM knowledge, mainstream frameworks, storage, messaging, containerization, architecture, engineering practices, soft skills, and emerging trends such as AI integration and reactive programming.

DockerJVMJava
0 likes · 9 min read
What Skills Should a 3‑Year Java Backend Developer Master?
Java Architect Handbook
Java Architect Handbook
Apr 20, 2026 · Backend Development

Concurrency vs Parallelism in Java: Definitions, CPU Mechanics, and Interview Tips

The article explains how concurrency differs from parallelism by defining logical versus physical simultaneity, illustrates the concepts with everyday analogies and CPU scheduling details, provides Java code examples, lists common interview follow‑up questions, and offers a concise mnemonic for remembering the distinction.

Backend DevelopmentCPUJava
0 likes · 10 min read
Concurrency vs Parallelism in Java: Definitions, CPU Mechanics, and Interview Tips
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 20, 2026 · Backend Development

Avoid Hidden Thread‑Safety Bugs in Spring Boot 3: 6 Common Pitfalls and Fixes

This article examines six typical concurrency mistakes in Spring Boot 3—misusing volatile, unsafe ConcurrentHashMap patterns, exposing mutable collections, removing synchronized, abusing parallel streams, and invisible shutdown flags—showing why they occur and providing concrete, thread‑safe code replacements.

ConcurrentHashMapJavaSpring Boot
0 likes · 9 min read
Avoid Hidden Thread‑Safety Bugs in Spring Boot 3: 6 Common Pitfalls and Fixes
Java Tech Workshop
Java Tech Workshop
Apr 19, 2026 · Backend Development

Mastering SpringBoot Concurrency: Pessimistic vs Optimistic Locks Explained

SpringBoot’s @Transactional ensures single‑transaction atomicity, but under high concurrency multiple transactions can still corrupt data; this article dissects why, demonstrates overselling scenarios, and provides detailed implementations of pessimistic (row/table locks) and optimistic (version/timestamp) locking with code, performance tests, and a comprehensive comparison guide.

MySQLOptimisticLockPessimisticLock
0 likes · 24 min read
Mastering SpringBoot Concurrency: Pessimistic vs Optimistic Locks Explained
Wu Shixiong's Large Model Academy
Wu Shixiong's Large Model Academy
Apr 17, 2026 · Backend Development

How Claude Code’s Memory System Works: From SHA‑256 Storage to Coalescing Extraction

This article dissects Claude Code’s Memory subsystem, explaining the distinction between Session logs and persistent Memory, the SHA‑256‑based storage layout, file indexing, four memory types, prompt injection steps, two write pathways, the ExtractionCoordinator’s coalescing strategy, and how to explain the design in interviews.

Claude Codebackend architectureconcurrency
0 likes · 19 min read
How Claude Code’s Memory System Works: From SHA‑256 Storage to Coalescing Extraction
java1234
java1234
Apr 16, 2026 · Backend Development

Why Java Virtual Threads? Deep Dive into Loom’s Principles and Production Pitfalls

The article explains why traditional platform threads are costly, defines Java virtual threads as lightweight JVM‑managed threads that unmount on blocking, compares their performance and limits to platform threads, outlines suitable and unsuitable use cases, provides starter code and best‑practice patterns, and offers a detailed production‑ready checklist to avoid common pitfalls such as pinning, ThreadLocal misuse, and blocking I/O.

JavaPerformanceProject Loom
0 likes · 16 min read
Why Java Virtual Threads? Deep Dive into Loom’s Principles and Production Pitfalls
Open Source Tech Hub
Open Source Tech Hub
Apr 16, 2026 · Backend Development

Run Parallel PHP Code with Spatie Fork: A Practical Guide

This guide explains how to install the Spatie Fork package, meet its requirements, and use its run, before, after, and concurrent methods to execute multiple PHP closures in parallel within CLI environments, including handling return values and database connections.

CLIPHPSpatie Fork
0 likes · 7 min read
Run Parallel PHP Code with Spatie Fork: A Practical Guide
TonyBai
TonyBai
Apr 16, 2026 · Backend Development

Why Go’s ‘go’ Statement Is the New Goto and How Four Rules Tame Runaway Goroutines

The article analyzes how Go’s cheap ‘go’ keyword, while democratizing concurrency, creates fire‑and‑forget pitfalls that lead to resource leaks, deadlocks, and testing headaches, and presents a research‑backed structured‑concurrency discipline defined by four concrete principles, code patterns, and a community library.

ErrGroupGoStructured Concurrency
0 likes · 16 min read
Why Go’s ‘go’ Statement Is the New Goto and How Four Rules Tame Runaway Goroutines
macrozheng
macrozheng
Apr 12, 2026 · Backend Development

Why a Simple HashMap Bug Crashed Our High‑Concurrency Service and How to Fix It

A senior architect introduced a high‑concurrency monitoring feature that used ConcurrentHashMap, but missing equals/hashCode and non‑atomic updates caused massive memory leaks and race conditions, leading to a post‑mortem that highlights proper key implementation, atomic map operations, and cautious synchronization.

ConcurrentHashMapJavaMemoryLeak
0 likes · 7 min read
Why a Simple HashMap Bug Crashed Our High‑Concurrency Service and How to Fix It
JakartaEE China Community
JakartaEE China Community
Apr 8, 2026 · Backend Development

From Reactive Streams to Virtual Threads: A Deep Dive

The article examines Project Loom's virtual threads, compares them with reactive streams, explores their underlying mechanisms, presents a direct‑style flow library (Jox) that combines both paradigms, and evaluates performance, backpressure, and error handling in Java concurrency.

JavaJoxProject Loom
0 likes · 22 min read
From Reactive Streams to Virtual Threads: A Deep Dive
Data STUDIO
Data STUDIO
Apr 8, 2026 · Backend Development

11 Backend Languages Shaping 2026: Pros, Cons, and Ideal Use Cases

The article analyzes the top 11 backend programming languages for 2026, detailing each language's strengths, drawbacks, typical users, and provides a four‑question framework to help teams choose the most suitable language for their projects.

BackendLanguage SelectionPerformance
0 likes · 12 min read
11 Backend Languages Shaping 2026: Pros, Cons, and Ideal Use Cases
James' Growth Diary
James' Growth Diary
Apr 6, 2026 · Artificial Intelligence

10 Practical LangChain Performance Hacks to Speed Up and Cut Costs

This article presents ten concrete techniques—including in‑memory and Redis caching, semantic caching, parallel execution, batch processing, prompt compression, model routing, streaming output, and connection‑pool reuse—to dramatically reduce latency and token costs in production LangChain applications.

LangChainNode.jsPerformance Optimization
0 likes · 14 min read
10 Practical LangChain Performance Hacks to Speed Up and Cut Costs
Alibaba Cloud Native
Alibaba Cloud Native
Apr 5, 2026 · Operations

How OpenClaw CMS Plugin v0.1.2 Turns Agent Tracing into Precise, Cost‑Effective Observability

The OpenClaw CMS observability plugin v0.1.2 solves the hidden‑trace problem by fully restoring multi‑round LLM execution, stabilizing concurrent chains, and introducing granular agent metrics, enabling developers, testers, and operators to debug faster, assess costs accurately, and improve cross‑team collaboration.

AgentCloud NativeOpenClaw
0 likes · 8 min read
How OpenClaw CMS Plugin v0.1.2 Turns Agent Tracing into Precise, Cost‑Effective Observability
Architect's Guide
Architect's Guide
Apr 1, 2026 · Backend Development

Master AsyncTask Orchestration in Spring Boot with asyncTool

This guide explains how to integrate asyncTool into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and implement serial, parallel, and mixed task flows with detailed code examples and best‑practice considerations.

JavaSpring BootTask Orchestration
0 likes · 11 min read
Master AsyncTask Orchestration in Spring Boot with asyncTool
java1234
java1234
Mar 31, 2026 · Backend Development

How Many Concurrent Requests Can Spring Boot Handle?

This article explains how Spring Boot processes concurrent HTTP requests using its embedded Tomcat thread pool, details the default limits (200 max threads, 10 min threads, queue size 10,000), shows how to tune these settings via configuration files, demonstrates async controllers, and suggests performance testing tools to measure real‑world capacity.

@AsyncSpring BootThread Pool
0 likes · 7 min read
How Many Concurrent Requests Can Spring Boot Handle?
Java Architect Essentials
Java Architect Essentials
Mar 23, 2026 · Databases

When MySQL Auto‑Increment Hits Its Limit: Diagnosis and Fixes

A backend engineer discovers that a massive MySQL table’s auto‑increment INT primary key reached its maximum value, causing insert failures, and walks through detailed analysis, three remediation options—including switching to BIGINT, redesigning IDs, and sharding—plus practical scripts, performance measurements, and lessons learned about concurrency and schema design.

BIGINTMySQLPerformance
0 likes · 10 min read
When MySQL Auto‑Increment Hits Its Limit: Diagnosis and Fixes
TonyBai
TonyBai
Mar 22, 2026 · R&D Management

Why 100 Hours of Tutorials Still Leave You Writing Bad Code? Uncover the Engineer’s Growth Loop

The article explains why countless programmers who binge‑watch tutorials remain stuck in a comfort zone, introduces the three‑ring model of Comfort‑Stretch‑Difficulty, and provides concrete Go and AI Agent projects that let engineers move into the narrow but powerful Stretch Zone to achieve real, measurable improvement.

AIGoStretch Zone
0 likes · 16 min read
Why 100 Hours of Tutorials Still Leave You Writing Bad Code? Uncover the Engineer’s Growth Loop
Code Wrench
Code Wrench
Mar 20, 2026 · Cloud Native

Inside Traefik v3: How Its Configuration Watcher, Router, and Concurrency Model Work

This article provides a senior Go engineer’s deep dive into Traefik’s source code, explaining the configuration hot‑reload engine, routing dispatch mechanism, and graceful concurrency model, and shows how to tune the proxy, build custom plugins, and apply the concepts to production‑grade Go services.

Cloud NativeConfiguration ReloadGo
0 likes · 13 min read
Inside Traefik v3: How Its Configuration Watcher, Router, and Concurrency Model Work
TonyBai
TonyBai
Mar 16, 2026 · Fundamentals

Does Go Really Eliminate Undefined Behavior? An In‑Depth Investigation

The article examines Go’s claim of eradicating undefined behavior, showing that while the language defines many formerly UB cases such as integer overflow and out‑of‑bounds access, it still harbors UB in concurrent data races, interface type confusion, and certain unspecified behaviors.

Data RaceGoSPEC
0 likes · 18 min read
Does Go Really Eliminate Undefined Behavior? An In‑Depth Investigation
LuTiao Programming
LuTiao Programming
Mar 15, 2026 · Backend Development

How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests

The article explains why traditional OS‑based thread pools choke under 100,000 concurrent Java requests, introduces Java 21's Virtual Threads from Project Loom, shows their low‑memory, high‑throughput characteristics, provides Spring Boot configuration and code samples, and warns about synchronization, ThreadLocal and CPU‑bound pitfalls.

I/OJavaPerformance
0 likes · 10 min read
How Java Virtual Threads Eliminate Thread‑Pool Bottlenecks and Enable a Single Machine to Handle 100k Requests
TonyBai
TonyBai
Mar 12, 2026 · Backend Development

Why My Go Service Slowed Down on a 128‑Core Server

A 128‑core, 256‑thread server should boost Go microservice performance, but the author explains how NUMA architecture, Go's scheduler affinity loss during GC pauses, and non‑NUMA‑aware memory allocation cause cache misses, remote memory penalties, and higher latency, preventing linear scaling.

GoHigh‑core performanceNUMA
0 likes · 9 min read
Why My Go Service Slowed Down on a 128‑Core Server
Golang Shines
Golang Shines
Mar 8, 2026 · Backend Development

240 Go Interview Questions with Answers – Master Them in 3 Passes to Land the Job

This article compiles a comprehensive set of 240 Go interview questions—including fundamentals, concurrency, runtime, and related topics such as containers, Redis, and MySQL—each paired with answers, offering candidates a structured study guide to repeatedly practice and improve their chances of securing a Go development position.

Backend DevelopmentDockerGo
0 likes · 15 min read
240 Go Interview Questions with Answers – Master Them in 3 Passes to Land the Job
Code Wrench
Code Wrench
Mar 6, 2026 · Backend Development

Why WebRTC Latency Isn’t About the API: Go, ICE, DTLS, and Scaling

This article breaks down the true bottlenecks of low‑latency WebRTC systems—network models, congestion control, memory layout, and concurrency scheduling—by examining the protocol stack, Go runtime, ICE state machine, DTLS/SRTP security, RTP/RTCP feedback, and practical high‑concurrency tuning strategies.

GoReal-time MediaWebRTC
0 likes · 10 min read
Why WebRTC Latency Isn’t About the API: Go, ICE, DTLS, and Scaling
Code Wrench
Code Wrench
Mar 5, 2026 · Backend Development

Unlock High‑Performance Go Concurrency with the Ants Goroutine Pool

This article examines the design and implementation of the high‑performance Ants Goroutine Pool for Go, detailing its core structures, worker lifecycle, scheduling strategies, and practical optimization tips, while providing concrete code examples and best‑practice guidelines for efficient concurrent programming.

ANTSGoPerformance
0 likes · 16 min read
Unlock High‑Performance Go Concurrency with the Ants Goroutine Pool
Code Wrench
Code Wrench
Mar 4, 2026 · Backend Development

How to Build a 50‑Player Real‑Time Battle Server in Go: Architecture & Performance

This article explains how to design a Go‑based backend for a 50‑player real‑time battle game, covering concurrency models, GC tuning, matching algorithms, fixed‑frame loops, AOI optimization, KCP networking, and performance‑boosting techniques such as object pooling and command batching.

Game BackendGoPerformance Optimization
0 likes · 8 min read
How to Build a 50‑Player Real‑Time Battle Server in Go: Architecture & Performance
Code Wrench
Code Wrench
Mar 1, 2026 · Backend Development

Building a High‑Performance Go Distributed Cache: GoMemcache from Scratch

This article walks through designing and implementing GoMemcache, a lightweight Go‑based distributed cache, covering use‑case selection, concurrency lock optimization, consistent hashing, production‑grade code, and practical deployment best practices for ultra‑low latency services.

Backend DevelopmentGoPerformance
0 likes · 12 min read
Building a High‑Performance Go Distributed Cache: GoMemcache from Scratch
dbaplus Community
dbaplus Community
Feb 27, 2026 · Databases

Understanding MySQL Locks: From Global to Row‑Level and Deadlock Prevention

The article explains why concurrent transactions cause data inconsistencies, describes MySQL’s lock hierarchy—including global, table, and row locks—covers AUTO_INCREMENT locking, illustrates lock compatibility tables, details common deadlock scenarios, and offers practical strategies such as fixed access order, optimistic locking, short transactions, proper indexing, and isolation‑level tuning to prevent deadlocks.

InnoDBLocksMySQL
0 likes · 18 min read
Understanding MySQL Locks: From Global to Row‑Level and Deadlock Prevention
LuTiao Programming
LuTiao Programming
Feb 27, 2026 · Backend Development

Why Java Records Are the Perfect Model for High‑Concurrency Systems

The article explains how Java records, with their built‑in immutability and auto‑generated methods, eliminate mutable state, reduce lock contention, and improve throughput in high‑concurrency architectures, providing concrete code examples and comparisons with traditional mutable beans.

Actor modelConcurrentHashMapImmutability
0 likes · 9 min read
Why Java Records Are the Perfect Model for High‑Concurrency Systems
Code Wrench
Code Wrench
Feb 26, 2026 · Backend Development

10 Common Go Programming Pitfalls and How to Avoid Them

Discover the ten most frequent Go language traps—from variable shadowing and inefficient string concatenation to misuse of defer, slice pointers, and goroutine pitfalls—complete with clear bad examples, best‑practice solutions, and performance considerations to write cleaner, faster, and more maintainable Go code.

GoPerformancebest practices
0 likes · 9 min read
10 Common Go Programming Pitfalls and How to Avoid Them
FunTester
FunTester
Feb 26, 2026 · Backend Development

Master Go Concurrency: 5 Essential Patterns and a Practical Worker Pool Example

This article explains Go's powerful concurrency model, introduces five common patterns—worker pool, fan‑in/fan‑out, error handling, timeout control, and context management—detailing their use cases, core API components, and provides a complete worker‑pool implementation with optimization tips.

GoWorker Poolconcurrency
0 likes · 15 min read
Master Go Concurrency: 5 Essential Patterns and a Practical Worker Pool Example
TonyBai
TonyBai
Feb 26, 2026 · Backend Development

Can Zig Replace Rust and Go? A Deep Dive into System‑Level Programming

The article follows a senior Go developer who migrated a mutex‑based key/value store from Go to Zig 0.16, comparing language ergonomics, memory management, concurrency models, code size, and ecosystem maturity, and concludes whether Zig can become the ultimate system‑programming choice.

GoLanguage MigrationRust
0 likes · 14 min read
Can Zig Replace Rust and Go? A Deep Dive into System‑Level Programming