BestHub
Sign in
Tagged articles

concurrency

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

OpenClawSession Keyconcurrency
0 likes · 11 min read
Why OpenClaw Uses sessionKey as Partition Key and How Its Dual‑Queue Design Guarantees Order and Throughput
51CTO HarmonyOS Developer Community
51CTO HarmonyOS Developer Community
Feb 25, 2026 · Mobile Development

Mastering HarmonyOS Concurrency: TaskPool, Worker & TaskGroup in AI Photo App

Through an AI ID photo tool case study, this article demonstrates HarmonyOS concurrency patterns: TaskPool for short preprocessing, Worker for long AI inference, TaskGroup for parallel batch generation, SequenceRunner for dependent tasks, SharedArrayBuffer for zero-copy sharing, Sendable for thread-safe singletons, and producer-consumer queues for real-time previews, with before/after performance metrics.

HarmonyOSSendableSequenceRunner
0 likes · 29 min read
Mastering HarmonyOS Concurrency: TaskPool, Worker & TaskGroup in AI Photo App
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.

Backend DevelopmentGoSaaS
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 ArchitectureContext ManagementOpenClaw
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.

BackendJavaconcurrency
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 ProgrammingPythonTaskGroup
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.

GoLanguage DesignPerformance
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.

Backend DevelopmentJavaSpring Boot
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.

GoPerformanceRace Detector
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.

Optimistic LockPessimistic LockRedis
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.

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

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

AICloud NativeGo
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.

BackendPythonasync web
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.

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

GILPythonasyncio
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 StructuresLinux kernelconcurrency
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.

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

BIGINTINT overflowMySQL
0 likes · 9 min read
When MySQL Auto‑Increment Hits INT Limit: Diagnosis and Fixes
Ray's Galactic Tech
Ray's Galactic Tech
Jan 2, 2026 · Databases

How to Choose the Right PostgreSQL Isolation Level and Avoid Concurrency Bugs

PostgreSQL offers four transaction isolation levels—READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, and SERIALIZABLE—each preventing specific concurrency anomalies like dirty reads, non‑repeatable reads, and phantom reads, and the article explains their behavior, configuration commands, practical usage, performance trade‑offs, and production best practices.

PostgreSQLSQLconcurrency
0 likes · 9 min read
How to Choose the Right PostgreSQL Isolation Level and Avoid Concurrency Bugs
Xiao Liu Lab
Xiao Liu Lab
Dec 28, 2025 · Operations

When to Use Async vs Multithreading: A Practical Guide for Ops Teams

This article explains the fundamental differences between asynchronous programming and multithreading, illustrates each with real‑world operations scenarios, outlines their key advantages and pitfalls, compares them in a concise table, and provides step‑by‑step guidance for communication, deployment, and troubleshooting.

Performanceasynchronousconcurrency
0 likes · 12 min read
When to Use Async vs Multithreading: A Practical Guide for Ops Teams
JavaScript
JavaScript
Dec 25, 2025 · Frontend Development

Boost JavaScript Async Performance by Up to 80% with Advanced Promise Techniques

This article explains why async/await can introduce performance overhead, then presents four optimized Promise‑based patterns—including chain optimization, Promise.all parallelism, batch processing, and pooling—that can improve JavaScript asynchronous code speed by up to 80% in high‑frequency or large‑scale scenarios.

JavaScriptOptimizationPerformance
0 likes · 5 min read
Boost JavaScript Async Performance by Up to 80% with Advanced Promise Techniques
Architect Chen
Architect Chen
Dec 22, 2025 · Backend Development

Boost Nginx Throughput 10×: Key Settings for High‑Concurrency

This guide explains how to achieve up to ten‑fold performance gains in Nginx by aligning worker processes with CPU cores, raising file‑descriptor limits, extending keep‑alive settings, and enabling zero‑copy transmission features such as sendfile, tcp_nopush, and tcp_nodelay.

NginxServer configurationconcurrency
0 likes · 5 min read
Boost Nginx Throughput 10×: Key Settings for High‑Concurrency
macrozheng
macrozheng
Dec 22, 2025 · Backend Development

Why Your Java ThreadPool Threads Aren’t Releasing and How Shutdown Fixes It

The article investigates a Java application that accumulated nearly a thousand waiting threads without high CPU or memory usage, identifies a custom FixedThreadPool as the cause, explains how thread pools become GC roots, and demonstrates that calling shutdown or shutdownNow properly releases both threads and the pool.

ExecutorServiceGarbageCollectionJVM
0 likes · 13 min read
Why Your Java ThreadPool Threads Aren’t Releasing and How Shutdown Fixes It
FunTester
FunTester
Dec 21, 2025 · Backend Development

Why River Is the Go‑Friendly Queue That Guarantees Transactional Consistency

This article explains how the River library leverages PostgreSQL to provide a Go‑native job queue with true transactional guarantees, high concurrency via goroutines, and efficient scheduling using SKIP LOCKED, while offering step‑by‑step setup and code examples for rapid adoption.

@TransactionalGoPostgreSQL
0 likes · 15 min read
Why River Is the Go‑Friendly Queue That Guarantees Transactional Consistency
Woodpecker Software Testing
Woodpecker Software Testing
Dec 20, 2025 · Fundamentals

Comprehensive AI-Generated Test Cases for User Registration Forms

The article presents a thorough AI‑driven test‑case suite for a user registration interface, detailing strategies such as equivalence partitioning, boundary‑value analysis, decision‑tree modeling, and error‑guessing, and covering fields like account, password, confirm password, mobile and email with functional, security, concurrency, and usability scenarios.

Security TestingTest Case DesignValidation
0 likes · 25 min read
Comprehensive AI-Generated Test Cases for User Registration Forms
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Dec 17, 2025 · Backend Development

When to Share or Isolate Thread Pools? A Deep Dive for Java Backend Architects

This article explains the trade‑offs between using a shared thread pool and creating dedicated pools in Java backend services, outlines scenario‑based decision rules, provides concrete Spring‑Boot configuration examples, and offers advanced dynamic tuning and interview‑style Q&A for reliable concurrency management.

JavaPerformanceSpring Boot
0 likes · 14 min read
When to Share or Isolate Thread Pools? A Deep Dive for Java Backend Architects
DevOps Coach
DevOps Coach
Dec 14, 2025 · Backend Development

10 Proven Strategies to Slash System Latency for Faster User Experience

This article outlines ten practical techniques—ranging from reducing network hops and caching hot data to optimizing database queries, batching requests, trimming payloads, focusing on critical paths, and proactive scaling—to dramatically lower response times and make applications feel instantly responsive for users.

BackendPerformancecaching
0 likes · 8 min read
10 Proven Strategies to Slash System Latency for Faster User Experience
Tech Freedom Circle
Tech Freedom Circle
Dec 12, 2025 · Backend Development

Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement

The article explains how Redisson implements a re‑entrant distributed lock using Redis hash structures and the atomic HINCRBY command to manage client identity, re‑entry counting, concurrency safety, and graceful release, providing a complete technical analysis with code, Lua scripts, and best‑practice guidelines.

HINCRBYJavaLua script
0 likes · 34 min read
Why Redisson’s Reentrant Distributed Lock Relies on HINCRBY Increment and Decrement
Code Wrench
Code Wrench
Dec 12, 2025 · Backend Development

Master CGO: Deep Dive into Go‑C Interoperability, Performance & Interview Secrets

This article provides a comprehensive, low‑level explanation of Go’s CGO bridge, covering its purpose, performance overhead, scheduler interaction, pointer safety rules, memory‑management guidelines, common use‑cases, scenarios to avoid, optimization techniques, and a collection of high‑frequency interview questions with model answers.

GoInteroperabilityPerformance
0 likes · 8 min read
Master CGO: Deep Dive into Go‑C Interoperability, Performance & Interview Secrets
Architect Chen
Architect Chen
Dec 11, 2025 · Operations

How to Boost Nginx Concurrency from 5K to 50K: Key Config Tweaks

This guide explains how to dramatically increase Nginx's concurrent handling capacity by tuning worker processes, connections, keep‑alive settings, and high‑performance I/O options, providing concrete configuration examples and practical advice for high‑traffic deployments.

ConfigurationNginxOperations
0 likes · 4 min read
How to Boost Nginx Concurrency from 5K to 50K: Key Config Tweaks
Open Source Tech Hub
Open Source Tech Hub
Dec 11, 2025 · Fundamentals

Why ‘Share Nothing’ Should Be the Default Concurrency Model for Modern Servers

Exploring the historical shift from memory‑constrained SMP systems and POSIX threads to today’s powerful hardware, this article argues that the ‘share‑nothing’ concurrency principle—embodied in Go’s CSP model and PHP’s parallel extension—should replace legacy lock‑based paradigms as the default approach.

GoPHP parallelPOSIX threads
0 likes · 11 min read
Why ‘Share Nothing’ Should Be the Default Concurrency Model for Modern Servers
Code Wrench
Code Wrench
Dec 10, 2025 · Fundamentals

Master Go Interview Essentials: Concurrency, Interfaces, GC, and More

This comprehensive guide covers the core Go concepts most frequently asked in interviews—including goroutine scheduling, channel communication, interface internals, garbage‑collection mechanics, toolchain utilities, error handling patterns, and struct memory layout—providing clear explanations, code examples, and practical tips to help candidates transition from writing Go code to truly understanding the language.

Goconcurrencyerror handling
0 likes · 12 min read
Master Go Interview Essentials: Concurrency, Interfaces, GC, and More
Architect Chen
Architect Chen
Dec 8, 2025 · Backend Development

Boost Nginx Concurrency: Master the 4 Key Performance Parameters

This guide explains how to maximize Nginx concurrency by configuring four key parameters—worker_processes, worker_connections, keepalive_timeout, and keepalive_requests—plus three I/O optimizations (sendfile, tcp_nopush, tcp_nodelay), and discusses related OS tuning for real‑world performance in production.

BackendConfigurationI/O optimization
0 likes · 4 min read
Boost Nginx Concurrency: Master the 4 Key Performance Parameters
Su San Talks Tech
Su San Talks Tech
Dec 5, 2025 · Backend Development

Unlocking Java ThreadPoolExecutor: Deep Dive, Best Practices, and Real‑World Tuning

This article provides a comprehensive exploration of Java's ThreadPoolExecutor, covering why thread pools are essential, how the executor framework is designed, detailed source‑code analysis of core classes, parameter tuning, rejection policies, monitoring techniques, and practical best‑practice recommendations for production systems.

Backend DevelopmentJavaThread Pool
0 likes · 32 min read
Unlocking Java ThreadPoolExecutor: Deep Dive, Best Practices, and Real‑World Tuning
dbaplus Community
dbaplus Community
Dec 3, 2025 · Databases

Why SQLite Beats PostgreSQL in Embedded Environments – Version Guide & Concurrency Insights

This article compares SQLite and PostgreSQL, presents detailed SQLite version timelines and OS compatibility tables, explains the differences between rollback‑journal and WAL concurrency models, shows a simple multi‑process lock test, and concludes that SQLite 3.45 is the most suitable choice for modern Linux, macOS, Android and iOS deployments.

PostgreSQLSQLiteconcurrency
0 likes · 14 min read
Why SQLite Beats PostgreSQL in Embedded Environments – Version Guide & Concurrency Insights
JavaGuide
JavaGuide
Dec 2, 2025 · Interview Experience

Tuhu Auto’s 2023 Java Backend Salary & Interview Guide: 30k‑33k Packages and Key Technical Topics

The article details Tuhu Auto’s Shanghai Java backend compensation (30k‑33k monthly with 14.4‑month salary and 2‑3w signing bonus), outlines the company’s market position, and provides a comprehensive list of technical and HR interview questions covering JVM, concurrency, MySQL, Spring, DDD, distributed locking, rate limiting, and more.

BackendJVMJava
0 likes · 7 min read
Tuhu Auto’s 2023 Java Backend Salary & Interview Guide: 30k‑33k Packages and Key Technical Topics
BirdNest Tech Talk
BirdNest Tech Talk
Dec 1, 2025 · Artificial Intelligence

Why Choose Go for AI Agents? Inside agent-web’s Zero‑Dependency Architecture

This article explains how the agent-web framework builds a powerful AI agent orchestration system in Go without external libraries, detailing the reasons for choosing Go, the use of go:embed for single‑binary deployment, core data structures, planning and execution logic, and the interaction handling that enables both CLI and web interfaces.

AI AgentsGoagent-web
0 likes · 13 min read
Why Choose Go for AI Agents? Inside agent-web’s Zero‑Dependency Architecture
Deepin Linux
Deepin Linux
Nov 28, 2025 · Backend Development

Boosting C++ Thread Pool Performance: Queue and Memory Optimizations

This article explains why C++ thread pools often hit bottlenecks in high‑concurrency scenarios and provides practical techniques—such as lock‑granularity tuning, lock‑free queues, object‑pool reuse, and pre‑allocation—to improve task scheduling and memory management without relying on external frameworks.

C++OptimizationThread Pool
1 likes · 44 min read
Boosting C++ Thread Pool Performance: Queue and Memory Optimizations
Qunar Tech Salon
Qunar Tech Salon
Nov 27, 2025 · Backend Development

How a Visual Canvas Transforms High‑Performance Marketing Workflow Engineering

This article details the design and implementation of a visual canvas‑based marketing configuration system that replaces Apollo, introduces a custom Reactor‑powered workflow engine, outlines component ecosystems, solves concurrency challenges, and demonstrates significant efficiency, scalability, and reliability gains after deployment.

CanvasReactorconcurrency
0 likes · 15 min read
How a Visual Canvas Transforms High‑Performance Marketing Workflow Engineering
Senior Tony
Senior Tony
Nov 24, 2025 · Backend Development

9 Powerful Ways to Control Thread Execution Order in Java

This article presents nine practical techniques—including Thread.join, CompletableFuture, CountDownLatch, CyclicBarrier, Semaphore, single‑thread executor, ReentrantLock with Condition, Phaser, and BlockingQueue—to reliably enforce a specific execution sequence among Java threads, a frequent interview challenge.

BackendJavaThread Ordering
0 likes · 5 min read
9 Powerful Ways to Control Thread Execution Order in Java
Ray's Galactic Tech
Ray's Galactic Tech
Nov 22, 2025 · Backend Development

How to Safely Stop Java Threads: Best Practices and Code Samples

This guide explains why Thread.stop() is unsafe, compares flag‑based, interruption‑based, and ExecutorService approaches, provides complete Java examples, usage steps, precautions, and advanced techniques for reliably stopping threads while releasing resources correctly.

ExecutorServiceJavaResource Cleanup
0 likes · 8 min read
How to Safely Stop Java Threads: Best Practices and Code Samples
macrozheng
macrozheng
Nov 21, 2025 · Backend Development

Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More

This article provides a comprehensive guide to Java concurrency and related concepts, covering synchronized lock upgrades, object vs class locks, lazy and double‑checked singleton implementations, ThreadLocal mechanics, reflection usage, annotation scopes, JVM class loading, and Redis cluster threading behavior.

JVMJavaRedis
0 likes · 22 min read
Master Java Concurrency: Locks, Singleton Patterns, ThreadLocal, Reflection and More
Code Wrench
Code Wrench
Nov 19, 2025 · Cloud Native

Unveiling Kubelet: How Kubernetes Brings Pods to Life with Go Concurrency

This article dissects the Kubelet component of Kubernetes, detailing its Go‑based architecture, core responsibilities, event‑driven syncLoop, PodWorkers concurrency model, syncPod creation flow, PLEG health monitoring, and provides practical debugging commands for production environments.

Cloud NativeGoKubernetes
0 likes · 14 min read
Unveiling Kubelet: How Kubernetes Brings Pods to Life with Go Concurrency
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 18, 2025 · Backend Development

Understanding Nginx’s Core Concurrency Model: Multi‑Process, Event‑Driven, and Non‑Blocking I/O

This article explains Nginx’s core concurrency mechanisms—including its multi‑process architecture, event‑driven model, I/O multiplexing techniques like epoll, and non‑blocking I/O—highlighting how they provide high stability, low resource consumption, and excellent performance for high‑traffic network services.

BackendIO Multiplexingconcurrency
0 likes · 5 min read
Understanding Nginx’s Core Concurrency Model: Multi‑Process, Event‑Driven, and Non‑Blocking I/O
Senior Tony
Senior Tony
Nov 18, 2025 · Backend Development

Mastering Java Thread Pools: 7 Critical Pitfalls Every Engineer Should Know

This article breaks down seven common thread‑pool pitfalls frequently asked in Java interviews, explains core‑thread reclamation, warm‑up, pool states, task‑completion checks, the risks of the default ForkJoinPool, and when to use single, fixed, or cached thread‑pool executors.

JavaJavaInterviewThreadPool
0 likes · 6 min read
Mastering Java Thread Pools: 7 Critical Pitfalls Every Engineer Should Know
IT Services Circle
IT Services Circle
Nov 13, 2025 · Fundamentals

Unlock Java Mastery: From Compilation to Collections, Concurrency and Career Insights

This article combines practical salary insights for Java developers at Transsion with a deep dive into Java fundamentals—including the compilation pipeline, JVM benefits, differences from C++, exception handling, core collection frameworks, concurrency concepts, interview preparation tips, and essential AI knowledge for developers.

AICollectionsJVM
0 likes · 14 min read
Unlock Java Mastery: From Compilation to Collections, Concurrency and Career Insights
ITPUB
ITPUB
Nov 11, 2025 · Databases

Why Big Tech Switches MySQL Isolation from RR to RC – Benefits & Risks

This article explains the differences between MySQL's RR and RC isolation levels, details master‑slave replication and binlog formats, shows why RR is the default, and why many internet companies now prefer RC for higher concurrency despite its phantom‑read trade‑offs.

BinlogIsolation LevelMySQL
0 likes · 10 min read
Why Big Tech Switches MySQL Isolation from RR to RC – Benefits & Risks
Tech Freedom Circle
Tech Freedom Circle
Nov 11, 2025 · Backend Development

ThreadLocal Interview Deep Dive: 20‑Minute Analysis, Manual vs Framework Solutions, and a Winning Methodology

This article explains the inner workings of Java's ThreadLocal, why it fails to propagate context in asynchronous scenarios, compares manual passing and decorator‑based approaches, introduces the TransmittableThreadLocal (TTL) library with its CRER workflow, and provides a structured interview answer that showcases deep architectural insight.

ContextPropagationJavaThreadLocal
0 likes · 26 min read
ThreadLocal Interview Deep Dive: 20‑Minute Analysis, Manual vs Framework Solutions, and a Winning Methodology
Top Architect
Top Architect
Nov 8, 2025 · Backend Development

Mastering High‑Throughput Thread Pools: Strategies for 100k QPS in Java

This article analyzes a high‑traffic scenario where 100,000 QPS requests each require 100 ms processing, explains why a naïve fixed thread pool would exhaust resources, and presents practical optimization goals, strategies, and Spring‑Boot code examples—including custom pool parameters, rejection handling, batch processing, and advanced techniques like Disruptor and rate‑limiting—to build a stable, high‑performance task execution system.

Circuit BreakerPerformance OptimizationSpring Boot
0 likes · 8 min read
Mastering High‑Throughput Thread Pools: Strategies for 100k QPS in Java
Tech Freedom Circle
Tech Freedom Circle
Nov 8, 2025 · Interview Experience

What’s the Secret Behind Python’s Multi‑Process, Multi‑Thread & Coroutine Tricks That Top Tech Interviews Demand?

This article breaks down Python’s Global Interpreter Lock, explains when to use multiprocessing, multithreading or asyncio, provides concrete performance benchmarks and a hybrid process‑coroutine pattern, and guides you on choosing the right concurrency model for interview questions.

PerformancePythonasyncio
0 likes · 57 min read
What’s the Secret Behind Python’s Multi‑Process, Multi‑Thread & Coroutine Tricks That Top Tech Interviews Demand?
JavaGuide
JavaGuide
Nov 6, 2025 · Fundamentals

Why Transsion’s Java Jobs Offer 30‑40k Salaries and How to Ace Their Easy Interview

Transsion’s Java positions in Shanghai and Shenzhen pay 300k‑400k RMB, the interview is surprisingly simple, and the article walks through Java’s compilation pipeline, JVM benefits, Java‑C++ differences, exception handling, collections, concurrency, multithreading, project‑prep tips, and essential AI concepts for interviewers.

CollectionsJVMJava
0 likes · 14 min read
Why Transsion’s Java Jobs Offer 30‑40k Salaries and How to Ace Their Easy Interview
Java Architecture Diary
Java Architecture Diary
Nov 5, 2025 · Fundamentals

Why Scala Has Been Ahead of Java for Over a Decade – A Feature‑by‑Feature Comparison

The article examines the recent push for modern features in Java, contrasts them with Scala implementations that have existed for years, and walks through functional programming, pattern matching, immutable collections, type inference, string interpolation, sealed classes, and concurrency with side‑by‑side code examples in both languages.

Functional ProgrammingImmutable CollectionsPattern Matching
0 likes · 17 min read
Why Scala Has Been Ahead of Java for Over a Decade – A Feature‑by‑Feature Comparison
Architecture Digest
Architecture Digest
Nov 3, 2025 · Backend Development

Ensuring Transaction Rollback in Multithreaded Spring MyBatis Operations

This article explains why @Transactional fails in multithreaded MySQL insert scenarios, demonstrates how to split large data sets, configure a thread pool, and use SqlSession with manual commit to guarantee atomicity across parallel threads, complete with runnable code examples and test results.

JavaMyBatisSpring
0 likes · 8 min read
Ensuring Transaction Rollback in Multithreaded Spring MyBatis Operations
Code Wrench
Code Wrench
Nov 3, 2025 · Backend Development

Why a 348‑Line Go CLI Outperforms Python for Image Scaling and Watermarking

Processing 1,000 images in Python can take 30 minutes, but the 348‑line Go CLI 'go-image-cli' completes the task in under 4 minutes by leveraging Go's concurrency, the disintegration/imaging library, intelligent Fit scaling, adaptive watermark positioning, and safe JPEG handling, with detailed code examples and performance tips.

CLIGoPerformance
0 likes · 11 min read
Why a 348‑Line Go CLI Outperforms Python for Image Scaling and Watermarking
IT Services Circle
IT Services Circle
Nov 2, 2025 · Backend Development

Why ScopedValue Is the Future Replacement for ThreadLocal in Java

This article explores the limitations of ThreadLocal—memory leaks, data contamination, inheritance issues, and performance overhead—and introduces Java's ScopedValue as a safer, more efficient alternative, covering its core design, basic and advanced usage, performance benchmarks, migration strategies, and real‑world web application examples.

JavaScopedValueThreadLocal
0 likes · 28 min read
Why ScopedValue Is the Future Replacement for ThreadLocal in Java
Su San Talks Tech
Su San Talks Tech
Nov 1, 2025 · Backend Development

Why ScopedValue Is the Future of Thread-Local Data in Java

This article explores the limitations of ThreadLocal, introduces Java's new ScopedValue feature, provides detailed usage examples, performance benchmarks, migration strategies, and compares both approaches to help developers decide when and how to adopt ScopedValue in modern backend applications.

JavaScopedValueThreadLocal
0 likes · 34 min read
Why ScopedValue Is the Future of Thread-Local Data in Java
Java Web Project
Java Web Project
Oct 31, 2025 · Fundamentals

What’s New in Java 25? 15 Features That Redefine Simplicity, Safety, and Performance

Java 25, the latest LTS release, introduces fifteen language and runtime enhancements—including pattern matching for primitive types, module‑wide imports, a compact main method, enriched records, structured concurrency, scoped and stable values, a vector API, and AOT optimizations—each illustrated with concrete code examples and explained for their impact on readability, safety, and performance.

JDK 25JavaLanguage Enhancements
0 likes · 11 min read
What’s New in Java 25? 15 Features That Redefine Simplicity, Safety, and Performance
IT Services Circle
IT Services Circle
Oct 31, 2025 · Backend Development

Master Java Concurrency, Singleton, ThreadLocal, and Reflection for Interviews

This guide covers essential Java interview topics—including synchronized lock upgrades, object vs class locking, lazy and double‑checked singleton patterns, ThreadLocal mechanics, reflection usage, annotation scopes, Redis cluster behavior, and a linear‑time algorithm challenge—providing clear explanations, code examples, and practical insights for developers preparing for technical interviews.

JavaReflectionThreadLocal
0 likes · 20 min read
Master Java Concurrency, Singleton, ThreadLocal, and Reflection for Interviews
Architect
Architect
Oct 30, 2025 · Databases

When MySQL Auto‑Increment IDs Hit Their Limit: Diagnosis and Fixes

A massive MySQL table ran out of INT auto‑increment IDs due to high concurrency, leading to insert failures; the article analyzes the root cause, evaluates three remediation strategies, and details the eventual migration to BIGINT with performance monitoring and code snippets.

BIGINTMySQLauto-increment
0 likes · 9 min read
When MySQL Auto‑Increment IDs Hit Their Limit: Diagnosis and Fixes
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Oct 30, 2025 · Databases

Master MySQL Locks: From Basics to Advanced Optimizations

This article provides a comprehensive overview of MySQL's lock mechanisms, covering lock granularity, lock types, intention locks, record/gap/next‑key locks, their interaction with transaction isolation levels, two‑phase locking, deadlock handling, and practical optimization techniques for high‑concurrency applications.

MySQLconcurrencydeadlock
0 likes · 20 min read
Master MySQL Locks: From Basics to Advanced Optimizations
JavaGuide
JavaGuide
Oct 27, 2025 · Backend Development

OPPO 2026 Campus Hiring: Salary Insights and In‑Depth Java Exception & Concurrency Guide

The article reviews OPPO’s 2026 campus hiring salaries for backend and algorithm roles, outlines the interview stages, and provides a comprehensive Java guide covering exceptions, checked vs unchecked, reference types, HashMap concurrency issues, ConcurrentHashMap internals, and the differences between synchronized and volatile.

Backend DevelopmentCampus RecruitmentHashMap
0 likes · 17 min read
OPPO 2026 Campus Hiring: Salary Insights and In‑Depth Java Exception & Concurrency Guide
Code Wrench
Code Wrench
Oct 26, 2025 · Backend Development

Build a Scalable Go Actor Framework with Auto‑Scaling and Graceful Shutdown

Explore the Go Actor model’s core concepts, compare popular Actor libraries, and follow a step‑by‑step implementation that introduces a mailbox, supervisor restart strategy, dynamic ActorPool with auto‑scaler, graceful shutdown via context, and Prometheus metrics, culminating in a complete, production‑ready concurrent framework.

Actor modelGoPrometheus
0 likes · 15 min read
Build a Scalable Go Actor Framework with Auto‑Scaling and Graceful Shutdown
Data Party THU
Data Party THU
Oct 24, 2025 · Industry Insights

Python 3.14 Removes GIL: What It Means for Concurrency and AI

Python 3.14 introduces optional no‑GIL support, free‑threading, a concurrent interpreter and performance gains, while Guido van Rossum cautions about over‑hyped expectations, discussing the trade‑offs, impact on AI workloads, and the language’s future in an in‑depth interview.

AIGILLanguage Design
0 likes · 12 min read
Python 3.14 Removes GIL: What It Means for Concurrency and AI
Code Wrench
Code Wrench
Oct 24, 2025 · Backend Development

Transforming a Simple Factorial into a Concurrent Go Engine

This article explores how a basic factorial calculation can be turned into a sophisticated concurrent system in Go, covering deadlock pitfalls, fan‑out/fan‑in pipelines, Redux‑style state management, and a controllable streaming factorial engine with pause and resume capabilities.

Gochannelconcurrency
0 likes · 9 min read
Transforming a Simple Factorial into a Concurrent Go Engine
Open Source Tech Hub
Open Source Tech Hub
Oct 22, 2025 · Backend Development

Boost PHP Concurrency with Pokio: Async API Guide and Code Samples

Pokio is a lightweight PHP asynchronous API that enables concurrent task execution using PCNTL and FFI, automatically falling back to sequential mode when unavailable; the guide explains installation via Composer, core functions async, await, then, catch, finally, and provides detailed code examples for promises, chaining, and error handling.

Promisesasynchronousconcurrency
0 likes · 5 min read
Boost PHP Concurrency with Pokio: Async API Guide and Code Samples
Ray's Galactic Tech
Ray's Galactic Tech
Oct 20, 2025 · Backend Development

Pessimistic, Optimistic & Distributed Locks: Core Concepts, Scenarios & Tips

This article explains the fundamental ideas behind pessimistic, optimistic, and distributed locking, compares their strengths and weaknesses, outlines typical application scenarios such as inventory deduction, banking transfers, and cache protection, and provides concrete implementation examples using SQL row locks, version fields, CAS, Redis WATCH, and Lua scripts.

Optimistic LockPessimistic LockRedis
0 likes · 8 min read
Pessimistic, Optimistic & Distributed Locks: Core Concepts, Scenarios & Tips
Code Wrench
Code Wrench
Oct 18, 2025 · Backend Development

Master High‑Performance Queues in Go: Kafka, RabbitMQ & Redis Compared

This article explains how to build a high‑throughput, low‑latency, and scalable queue system in Go by leveraging Kafka, RabbitMQ, and Redis, covering core concepts, practical code examples, performance optimizations, and guidance on choosing the right solution for different workloads.

GoKafkaRabbitMQ
0 likes · 11 min read
Master High‑Performance Queues in Go: Kafka, RabbitMQ & Redis Compared