BestHub
Sign in
Tagged articles

concurrency

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

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

JavaSoftware Architectureconcurrency
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 ServiceLifecycle Managementaudit 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.

JavaKafkaPrice Aggregation
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.

Server configurationconcurrencynginx
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.

LoggingShell scriptingbash
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.

JPAPerformanceSpring Boot
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.

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

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

JavaKafkaKubernetes
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 OptimizationThroughput
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.

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

CPUInterviewJava
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 CodePrompt Engineeringbackend architecture
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.

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

Language SelectionPerformanceProgramming Languages
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.

AgentOpenClawTracing
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 BootasyncTool
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.

Spring BootTomcatasync
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.

BigIntDatabase MigrationMySQL
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.

Configuration ReloadGoRouting
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.

Garbage CollectionGoHigh‑core performance
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.

DockerGoInterview Questions
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.

GoPerformancebackend development
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.

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

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

GoMemory ManagementRust
0 likes · 14 min read
Can Zig Replace Rust and Go? A Deep Dive into System‑Level Programming
Architect
Architect
Feb 25, 2026 · Backend Development

Why OpenClaw Uses sessionKey as Partition Key and How Its Dual‑Queue Design Guarantees Order and Throughput

The article explains how OpenClaw tackles common multi‑agent messaging problems by treating sessionKey as a partition key, redefining DM scope for multi‑source inputs, employing a dual‑layer queue with per‑session serialization and global lane throttling, and exposing configurable knobs for micro‑batching, backpressure, and observability.

Message QueueOpenClawSession Key
0 likes · 11 min read
Why OpenClaw Uses sessionKey as Partition Key and How Its Dual‑Queue Design Guarantees Order and Throughput
DevOps Coach
DevOps Coach
Feb 22, 2026 · Backend Development

Why Go Beats Java Spring Boot for SaaS: Cost, Deployment, and Concurrency Insights

After years of using Java Spring Boot, the author rewrote a SaaS microservice in Go, discovering a 60 % AWS cost reduction, simpler deployment, and easier concurrency, while also noting scenarios where Java's rich ecosystem remains preferable, offering practical guidance on when to choose Go for SaaS.

GoSpring Bootbackend development
0 likes · 8 min read
Why Go Beats Java Spring Boot for SaaS: Cost, Deployment, and Concurrency Insights
Architect
Architect
Feb 21, 2026 · Artificial Intelligence

How OpenClaw Turns AI Agents into a Reliable, Auditable Infrastructure – 7 Key Takeaways

OpenClaw treats agents as infrastructure by introducing explicit queues, session boundaries, tool permissions, and persistence layers, ensuring that multi‑channel AI assistants run predictably without chaotic side effects, and the article walks through its architecture, concurrency model, session management, context handling, tool sandboxing, and fail‑over strategies.

Agent ArchitectureOpenClawTool Security
0 likes · 27 min read
How OpenClaw Turns AI Agents into a Reliable, Auditable Infrastructure – 7 Key Takeaways
TonyBai
TonyBai
Feb 18, 2026 · Backend Development

Why We Chose Go Over Python for Building an LLM Gateway

The Bifrost team replaced Python with Go for their LLM gateway, achieving roughly 700× lower latency, 68% less memory usage, and three‑fold higher throughput, and the article explains the performance bottlenecks of Python, Go’s concurrency model, deployment advantages, and future AI infrastructure trends.

AI infrastructureGoLLM gateway
0 likes · 14 min read
Why We Chose Go Over Python for Building an LLM Gateway
IT Services Circle
IT Services Circle
Feb 12, 2026 · Backend Development

Du Xiaoman Java Backend Salary & Interview Secrets Revealed

The article details Du Xiaoman's 2023 campus hiring salaries for Java backend roles, explains the significance of signing bonuses, shares a successful intern story, and provides in‑depth interview preparation covering thread pools, locks, AQS, CAS, SQL optimization, sharding, MVCC, and transaction isolation levels.

DatabaseInterviewJava
0 likes · 22 min read
Du Xiaoman Java Backend Salary & Interview Secrets Revealed
Sohu Smart Platform Tech Team
Sohu Smart Platform Tech Team
Feb 11, 2026 · Backend Development

Why TreeSet Throws ConcurrentModificationException and How to Fix It

An in‑depth look at why Java’s TreeSet can trigger ConcurrentModificationException under high concurrency, exploring the red‑black tree’s non‑atomic operations, thread scheduling nuances, and how various concurrent set implementations—synchronized wrappers, read‑write locks, ConcurrentSkipListSet, CopyOnWriteArraySet, and custom designs—compare in performance and suitability.

CollectionsConcurrentModificationExceptionJava
0 likes · 16 min read
Why TreeSet Throws ConcurrentModificationException and How to Fix It
Golang Shines
Golang Shines
Feb 10, 2026 · Backend Development

Python vs Go: A Complete Guide to Choosing the Right Language for Web Crawling

The article compares Python and Go across syntax, libraries, concurrency, memory usage, readability, data processing, and deployment, concluding that Go suits large‑scale, high‑concurrency crawlers while Python excels when rich data‑analysis tools and rapid development are needed.

Data ProcessingLibrariesPython
0 likes · 6 min read
Python vs Go: A Complete Guide to Choosing the Right Language for Web Crawling
Data STUDIO
Data STUDIO
Feb 10, 2026 · Backend Development

Master Python asyncio: Make Your Code Fly with Asynchronous Programming

This article explains why synchronous Python code blocks on I/O, introduces asyncio’s event loop and coroutine model, and walks through creating and managing tasks, using TaskGroup, handling timeouts, avoiding common pitfalls, and applying best‑practice patterns for high‑performance I/O‑bound programs.

Asynchronous ProgrammingPythonasyncio
0 likes · 20 min read
Master Python asyncio: Make Your Code Fly with Asynchronous Programming
TonyBai
TonyBai
Feb 9, 2026 · Fundamentals

Is Go Finally Adding Immutable Types After an 8‑Year Dormant Proposal?

The article revisits the eight‑year‑old Go proposal #27975 for an immutable‑type qualifier, explains the defensive‑copy performance problem it aims to solve, details the technical and community challenges—including const‑contamination and io.Writer compatibility—and explores why generics and safety concerns have revived the discussion in 2026.

GoPerformanceconcurrency
0 likes · 11 min read
Is Go Finally Adding Immutable Types After an 8‑Year Dormant Proposal?
Java Architect Handbook
Java Architect Handbook
Feb 7, 2026 · Backend Development

Master AsyncTask Orchestration in Spring Boot with asyncTool

This guide explains how to integrate the asyncTool library into a Spring Boot project, configure custom thread pools, understand core interfaces like IWorker and ICallback, and use the provided Builder API to define serial, parallel, and mixed task flows with detailed code examples and best‑practice cautions.

JavaSpring BootasyncTool
0 likes · 13 min read
Master AsyncTask Orchestration in Spring Boot with asyncTool
Code Wrench
Code Wrench
Feb 5, 2026 · Backend Development

Why Your Go Code Crashes in Production: 5 Real Memory‑Model Pitfalls and Fixes

This article examines five real‑world Go concurrency bugs—ranging from unprotected flags and double‑checked locks to map races, loop‑variable capture, and slice appends—explains the underlying Go memory‑model and happens‑before concepts, and provides correct synchronization patterns such as channels, sync.Once, mutexes, sync.Map, and atomic.Value to write stable high‑concurrency services.

GoMemory ModelPerformance
0 likes · 23 min read
Why Your Go Code Crashes in Production: 5 Real Memory‑Model Pitfalls and Fixes
LuTiao Programming
LuTiao Programming
Feb 1, 2026 · Backend Development

Why Ticket Sales Fail: A Deep Dive into Concurrency, Locks, and Building a Reliable Ticket‑Booking System

When half a million users simultaneously try to buy 5,000 concert tickets, naive ordering logic leads to race conditions and double bookings, so the article walks through the root causes, compares pessimistic, optimistic, and Redis distributed locks, and presents an industrial‑grade microservice design with a three‑stage state machine to ensure strong consistency and high availability.

Redisconcurrencydistributed lock
0 likes · 8 min read
Why Ticket Sales Fail: A Deep Dive into Concurrency, Locks, and Building a Reliable Ticket‑Booking System
Code Wrench
Code Wrench
Jan 31, 2026 · Backend Development

Build a Fast, Concurrent, Single‑File Lottery System with Go

This article shows how to quickly create a fair, concurrent, single‑binary lottery system for a company event using Go's standard library, sync.RWMutex for thread safety, and the embed package to bundle static assets without any external dependencies.

GoHTTP serverLottery System
0 likes · 9 min read
Build a Fast, Concurrent, Single‑File Lottery System with Go
Xiaohongshu Tech REDtech
Xiaohongshu Tech REDtech
Jan 30, 2026 · Backend Development

How Java Virtual Threads Cut Latency by 31× and Slash CPU Use in Production

This article explains the principles of Java virtual threads, compares them with traditional platform threads, details RedJDK21’s implementation and performance improvements—including up to 31‑fold latency reduction and 24% CPU savings—in large‑scale services at XiaoHongShu, and discusses migration challenges, lock handling, monitoring, and future roadmap.

JVMJavaPerformance Optimization
0 likes · 29 min read
How Java Virtual Threads Cut Latency by 31× and Slash CPU Use in Production
TonyBai
TonyBai
Jan 27, 2026 · Backend Development

How the Go Rewrite of the TypeScript Compiler Achieved a 10× Speedup – Inside Microsoft’s Engineering Details

The Microsoft TypeScript team rebuilt the compiler in Go, setting hard performance goals, choosing Go for its GC and concurrency, prototyping the scanner and parser, redesigning AST structures, and leveraging parallel parsing and independent type‑checkers to cut VS Code compile time from 80 seconds to 7 seconds, a ten‑fold improvement.

ASTGoTypeScript
0 likes · 12 min read
How the Go Rewrite of the TypeScript Compiler Achieved a 10× Speedup – Inside Microsoft’s Engineering Details
IT Services Circle
IT Services Circle
Jan 25, 2026 · Interview Experience

Top 17 Java Backend Interview Questions & Answers (2024) – From Collections to JVM

This article combines a detailed Baidu 2026 campus recruitment salary table with an extensive Java interview guide covering collections, concurrency, thread creation, thread pools, I/O models, Spring bean lifecycle, Redis persistence, MySQL isolation levels, MVCC, storage engines, data structures, TCP/UDP differences, JVM memory layout, garbage collection algorithms, and a quicksort example, providing a comprehensive resource for backend developers preparing for technical interviews.

InterviewJVMJava
0 likes · 30 min read
Top 17 Java Backend Interview Questions & Answers (2024) – From Collections to JVM
AI Code to Success
AI Code to Success
Jan 21, 2026 · Fundamentals

Why ArkTS Bans any/unknown Types and What It Means for Performance

This article explains ArkTS's strict type restrictions, its use of ESObject for unknown JS types, special limits on interfaces, classes, and decorators, as well as its memory model, closure rules, and the differences between Record and Map containers, highlighting how these design choices improve compilation and runtime efficiency.

AOTTypeScriptarkTS
0 likes · 7 min read
Why ArkTS Bans any/unknown Types and What It Means for Performance
TonyBai
TonyBai
Jan 20, 2026 · Artificial Intelligence

Will Go Thrive or Fade in the AI Era? A Deep Dive of GopherCon 2025 Roundtable

In a GopherCon 2025 roundtable, leading engineers discuss how Go’s production‑grade reliability and concurrency make it a strong candidate for AI infrastructure, address career anxieties about AI replacing developers, and outline practical steps for Go developers to stay relevant in the AI‑driven future.

AIGoResponsible AI
0 likes · 11 min read
Will Go Thrive or Fade in the AI Era? A Deep Dive of GopherCon 2025 Roundtable
Subtle Storm
Subtle Storm
Jan 17, 2026 · Backend Development

Deep Dive into Python Concurrency: Asyncio Event Loop, Scheduling, and High‑Performance Web Apps

This article dissects Python's asyncio event loop and coroutine scheduling, compares synchronous threading with asynchronous execution through benchmark tests, examines memory usage across models, presents a full async web service implementation with database and cache pools, and offers a decision matrix for choosing the right concurrency model.

Pythonasync webasyncio
0 likes · 15 min read
Deep Dive into Python Concurrency: Asyncio Event Loop, Scheduling, and High‑Performance Web Apps
IT Services Circle
IT Services Circle
Jan 17, 2026 · Backend Development

Kuaishou Campus Salary Insights & Java Backend Interview Guide

The article reveals that Kuaishou’s 2023 campus hires for backend and frontend roles typically earn 40‑50 wan yuan annually, discusses salary trends compared with previous years, and then provides a comprehensive Java backend interview guide covering JVM memory, garbage collectors, CMS GC process, concurrency primitives, and SQL join differences.

GCInterviewJVM
0 likes · 15 min read
Kuaishou Campus Salary Insights & Java Backend Interview Guide
Code Wrench
Code Wrench
Jan 17, 2026 · Backend Development

Building a Go-Powered Industrial Scheduling System with FSM, Saga, and WAL

This article demonstrates how to design and implement a miniature yet fully functional industrial intelligent scheduling system in Go, leveraging a workflow engine, priority queue, saga‑based transactions with FSM state management, concurrent station execution, and write‑ahead logging for reliable, real‑time factory automation.

FSMGoSAGA
0 likes · 9 min read
Building a Go-Powered Industrial Scheduling System with FSM, Saga, and WAL
Subtle Storm
Subtle Storm
Jan 15, 2026 · Backend Development

Deep Dive into Python Concurrency: Threads, Processes, and Coroutines (Part 1)

This article examines Python's three concurrency models—threading, multiprocessing, and asyncio coroutines—detailing their underlying mechanisms, performance traits, suitable use‑cases, and the impact of the Global Interpreter Lock, followed by a hybrid web‑server implementation example.

GILPythonWeb Development
0 likes · 9 min read
Deep Dive into Python Concurrency: Threads, Processes, and Coroutines (Part 1)
DevOps Coach
DevOps Coach
Jan 14, 2026 · Information Security

What the First Linux Kernel Rust CVE Reveals About Memory Safety

The article explains CVE‑2025‑68260, the first Rust‑based vulnerability in the Linux kernel, detailing the race condition in the rust_binder driver, why the bug proves Rust’s safety promises, and how its limited impact contrasts with countless C‑related kernel CVEs.

CVELinux kernelRust
0 likes · 7 min read
What the First Linux Kernel Rust CVE Reveals About Memory Safety
Code Wrench
Code Wrench
Jan 11, 2026 · Backend Development

Master Viper: Priority Lookup, Multi‑Source Merging & Concurrency Risks

This article delves into Viper’s internal architecture, explaining its layered storage and priority lookup mechanism, how it merges environment variables, config files, and defaults, and highlights concurrency safety concerns, offering practical guidelines and code snippets to avoid common pitfalls when using Viper in Go projects.

Gobest practicesconcurrency
0 likes · 9 min read
Master Viper: Priority Lookup, Multi‑Source Merging & Concurrency Risks
Deepin Linux
Deepin Linux
Jan 11, 2026 · Fundamentals

Mastering Linux Kernel Linked Lists: From Theory to High‑Performance Code

This article explains the design, implementation, and practical use of the Linux kernel's intrusive linked‑list data structure, covering its core concepts, list_head definition, common macros, insertion, deletion, traversal, optimization techniques, concurrency control with RCU and memory barriers, and real‑world examples in device drivers and process scheduling.

Data StructuresLinked ListLinux kernel
0 likes · 37 min read
Mastering Linux Kernel Linked Lists: From Theory to High‑Performance Code
LuTiao Programming
LuTiao Programming
Jan 4, 2026 · Backend Development

Why ‘How Much Concurrency Can Spring Boot 3 Handle?’ Is Misleading – A Deep Dive into Max Connections

The article shows that Spring Boot itself does not limit concurrency; the true ceiling is set by Linux TCP parameters, Tomcat's acceptCount and maxConnections, its thread‑pool strategy, and KeepAlive settings, and it walks through source code, default values, and practical experiments to reveal where requests are blocked.

Spring BootTomcatconcurrency
0 likes · 9 min read
Why ‘How Much Concurrency Can Spring Boot 3 Handle?’ Is Misleading – A Deep Dive into Max Connections
Tech Freedom Circle
Tech Freedom Circle
Jan 4, 2026 · Backend Development

Choosing Between String, StringBuilder, and StringBuffer for Concatenating 100 Million Strings in a JD Interview

The article dissects a JD interview question about concatenating one hundred million strings, comparing String, StringBuilder, and StringBuffer, and explains how immutability leads to object explosion, how StringBuilder’s default capacity causes costly expansions, and why StringBuffer’s synchronized methods become a performance bottleneck in high‑concurrency scenarios.

GCStringBufferStringBuilder
0 likes · 44 min read
Choosing Between String, StringBuilder, and StringBuffer for Concatenating 100 Million Strings in a JD Interview
dbaplus Community
dbaplus Community
Jan 3, 2026 · Databases

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

The article recounts a MySQL production incident where an INT auto‑increment column reached its maximum value, causing insert failures, and walks through analysis, three remediation options, a stored‑procedure cleanup, a conversion to BIGINT, performance monitoring, and lessons on concurrency and schema design.

BigIntDatabase PerformanceINT overflow
0 likes · 9 min read
When MySQL Auto‑Increment Hits INT Limit: Diagnosis and Fixes