BestHub
Sign in
Tagged articles

concurrency

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

PostgreSQLSQLTransaction Isolation
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.

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

Async/AwaitJavaScriptOptimization
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.

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

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

GoMessage QueuePostgreSQL
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.

Test Case DesignValidationconcurrency
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.

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

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

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

ConfigurationI/O optimizationPerformance Tuning
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.

JavaPerformance TuningThreadPoolExecutor
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.

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

InterviewJVMJava
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++Optimizationconcurrency
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.

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

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

JavaResource CleanupThread Management
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.

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

IO Multiplexingbackendconcurrency
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.

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

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

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

Performance OptimizationSpring BootThreadPool
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.

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

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

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

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

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

DeadlockIsolation LevelsMySQL
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.

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

Goactor-modelauto-scaling
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.

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

GoState Managementchannel
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.

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

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

GoKafkaMessage Queue
0 likes · 11 min read
Master High‑Performance Queues in Go: Kafka, RabbitMQ & Redis Compared
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 18, 2025 · Backend Development

Master Java Concurrency: Choose ReentrantLock, ReadWriteLock, StampedLock, or Semaphore

This article explores Java’s advanced lock mechanisms—ReentrantLock, ReentrantReadWriteLock, StampedLock, and Semaphore—detailing their core features, practical code examples, and ideal usage scenarios, helping developers decide which synchronization tool best fits their performance and concurrency requirements.

JavaLocksReadWriteLock
0 likes · 9 min read
Master Java Concurrency: Choose ReentrantLock, ReadWriteLock, StampedLock, or Semaphore
ITPUB
ITPUB
Oct 17, 2025 · Databases

Why Some Companies Switch MySQL from Repeatable Read to Read Committed

The article explains MySQL's default Repeatable Read isolation level, how its lock and binlog mechanisms affect consistency and replication, and why many high‑traffic internet firms change to Read Committed to boost concurrency and reduce deadlocks despite the need to handle phantom reads.

Isolation LevelMySQLRead Committed
0 likes · 8 min read
Why Some Companies Switch MySQL from Repeatable Read to Read Committed
Data STUDIO
Data STUDIO
Oct 17, 2025 · Fundamentals

Python 3.14 (π) Released: Cool New Features You Should Try

Python 3.14, released on October 7 2025, brings a revamped REPL with real‑time syntax highlighting and smarter auto‑completion, new syntax such as t‑strings and optional parentheses in exception handling, lazy‑evaluated type annotations, sub‑interpreter parallelism, free‑threading, an experimental JIT, tail‑call interpreter support, and an incremental garbage collector, all of which improve developer ergonomics and performance.

DebuggingPerformancePython
0 likes · 44 min read
Python 3.14 (π) Released: Cool New Features You Should Try
macrozheng
macrozheng
Oct 15, 2025 · Databases

Why PostgreSQL Beats MySQL in High‑Performance Scenarios

This article examines why PostgreSQL is often a better choice than MySQL for high‑performance workloads, covering architectural differences, indexing capabilities, query optimization, data types, concurrency control, benchmark results, and migration considerations, and provides code examples to illustrate each point.

IndexingMySQLPostgreSQL
0 likes · 13 min read
Why PostgreSQL Beats MySQL in High‑Performance Scenarios
DeWu Technology
DeWu Technology
Oct 13, 2025 · Backend Development

TTL Agent Pitfalls: Memory Leaks & CPU Spikes in Java – Cases & Fixes

This article explains how the Transmittable ThreadLocal (TTL) Java agent works, why improper usage can cause context contamination, memory leaks, and CPU spikes, and provides real production cases, code examples, and practical recommendations to avoid these pitfalls.

Java AgentPerformanceTTL
0 likes · 15 min read
TTL Agent Pitfalls: Memory Leaks & CPU Spikes in Java – Cases & Fixes
Code Wrench
Code Wrench
Oct 11, 2025 · Backend Development

Master Go Concurrency with sync: Mutex, RWMutex, WaitGroup, Once, Cond & Pool

Learn how Go's sync package provides essential concurrency primitives—Mutex, RWMutex, WaitGroup, Once, Cond, and Pool—through clear examples and best‑practice patterns that prevent data races, deadlocks, and performance pitfalls, enabling safe, elegant, and efficient goroutine coordination.

GoOncePool
0 likes · 7 min read
Master Go Concurrency with sync: Mutex, RWMutex, WaitGroup, Once, Cond & Pool
Code Mala Tang
Code Mala Tang
Oct 10, 2025 · Fundamentals

Why async/await Doesn’t Give You Concurrency – And How to Make It Work

Although Python’s async/await syntax lets you pause and resume functions, it alone doesn’t run tasks concurrently; you must explicitly schedule coroutines with tools like asyncio.create_task(), gather(), or TaskGroup, and understand when to use sequential versus concurrent execution to avoid common pitfalls.

Async/Awaitasyncioconcurrency
0 likes · 10 min read
Why async/await Doesn’t Give You Concurrency – And How to Make It Work
BirdNest Tech Talk
BirdNest Tech Talk
Oct 9, 2025 · Fundamentals

What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety

Over the past two years, Go’s sync and sync/atomic packages have introduced new APIs like WaitGroup.Go, enhanced Map methods, modernized atomic types, restructured internal implementations, and added developer‑friendly safeguards such as noCopy, all aimed at improving usability, safety, and performance for concurrent Go programs.

APIGoPerformance
0 likes · 12 min read
What’s New in Go’s sync Package? A Deep Dive into APIs, Performance, and Safety
Su San Talks Tech
Su San Talks Tech
Oct 9, 2025 · Databases

Why PostgreSQL Beats MySQL in High‑Performance Scenarios

This article compares PostgreSQL and MySQL across architecture, indexing, complex query optimization, data‑type support, transaction handling, and real‑world benchmark results, showing why PostgreSQL is generally the better choice for high‑concurrency, data‑intensive applications.

Database PerformanceIndexingMySQL
0 likes · 13 min read
Why PostgreSQL Beats MySQL in High‑Performance Scenarios
Rust High-Frequency Quantitative Trading
Rust High-Frequency Quantitative Trading
Oct 3, 2025 · Backend Development

Uncovering Rust’s Hidden Concurrency Powerhouse: park and unpark

This article explains Rust’s std::thread::park/unpark primitives, demonstrates their lost‑wake‑up pitfall, introduces crossbeam’s Parker/Unparker with a token‑based memory feature that eliminates the issue, and provides multiple code examples and usage guidelines for high‑performance thread synchronization.

CrossbeamParkerRust
0 likes · 17 min read
Uncovering Rust’s Hidden Concurrency Powerhouse: park and unpark
Python Programming Learning Circle
Python Programming Learning Circle
Sep 30, 2025 · Fundamentals

How to Supercharge Your Python Code: Proven Performance Optimization Techniques

This comprehensive guide walks you through Python performance optimization, covering profiling, algorithmic improvements, data‑structure choices, code‑level tricks, concurrency, memory management, third‑party libraries and a practical checklist to ensure your programs run faster and more efficiently.

Memory ManagementPerformance OptimizationPython
0 likes · 18 min read
How to Supercharge Your Python Code: Proven Performance Optimization Techniques
Deepin Linux
Deepin Linux
Sep 27, 2025 · Fundamentals

Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency

Lock‑free queues replace costly mutexes with atomic operations, eliminating lock contention, deadlocks, and scalability limits, and this article explains their principles, classic implementations, C++ code examples, performance testing, and real‑world applications such as game engines and high‑throughput servers.

C++CASLock-Free
0 likes · 38 min read
Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency
Python Crawling & Data Mining
Python Crawling & Data Mining
Sep 27, 2025 · Fundamentals

How to Supercharge Python: Proven Performance Optimization Techniques

Discover a comprehensive guide to dramatically improve Python program speed and memory usage through algorithmic refinements, profiling tools, concurrency models, and advanced techniques like generators, slots, and third‑party libraries, complete with real‑world code examples and performance benchmarks.

OptimizationPerformanceconcurrency
0 likes · 19 min read
How to Supercharge Python: Proven Performance Optimization Techniques
php Courses
php Courses
Sep 23, 2025 · Backend Development

Coroutines vs Fibers in PHP: Which Concurrency Model Wins?

This article explains the fundamental differences between coroutines and fibers in modern PHP, covering their concepts, implementation layers, scheduling, stack management, integration, and practical code examples, helping developers choose the right concurrency approach for high‑performance applications.

AsynchronousFiberPHP
0 likes · 10 min read
Coroutines vs Fibers in PHP: Which Concurrency Model Wins?
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Sep 23, 2025 · Backend Development

Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates

This article explains common problems of concurrent database updates in Spring Boot 3 and demonstrates five practical solutions—including database locks, optimistic and pessimistic locking, transaction isolation levels, and application‑level locks—accompanied by complete code examples and test results.

Spring BootTransaction Managementconcurrency
0 likes · 10 min read
Spring Boot 3 Concurrency: Locks, Optimistic & Pessimistic Updates
Java Architecture Diary
Java Architecture Diary
Sep 22, 2025 · Backend Development

Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps

Java 25 introduces major upgrades to virtual threads, offering dramatically lower memory usage, near‑zero creation cost, and efficient I/O handling, and this guide explains their advantages, compares them with traditional thread pools and @Async, provides Spring Boot 3.5 configuration examples, and highlights pitfalls and best‑practice tips.

Virtual Threadsconcurrencyspring
0 likes · 8 min read
Unlock Massive Concurrency: How Java 25 Virtual Threads Supercharge Spring Apps
Java Architecture Diary
Java Architecture Diary
Sep 19, 2025 · Backend Development

Why ScopedValues Outperform ThreadLocal for Safe Context Management in Java

ScopedValues provide a more efficient, memory‑safe, and virtual‑thread‑friendly alternative to ThreadLocal for managing per‑thread context in Java, eliminating manual cleanup, reducing memory leaks, and simplifying context propagation across threads, as demonstrated by code examples and performance benchmarks.

PerformanceScopedValuesThreadLocal
0 likes · 6 min read
Why ScopedValues Outperform ThreadLocal for Safe Context Management in Java
FunTester
FunTester
Sep 17, 2025 · Backend Development

20 Proven Go Performance Optimization Techniques Every Backend Engineer Should Know

This article presents 20 production‑validated Go performance optimization tips, covering profiling, benchmarking, memory management, concurrency, and build‑time strategies, with clear principles and practical code examples to help engineers systematically improve Go application performance.

MemoryOptimizationconcurrency
0 likes · 24 min read
20 Proven Go Performance Optimization Techniques Every Backend Engineer Should Know
Java Architecture Diary
Java Architecture Diary
Sep 17, 2025 · Fundamentals

What’s New in Java 25? Explore the Game‑Changing Features and Performance Boosts

Java 25, released on September 16 2025 as the next long‑term support version, introduces a suite of language, runtime, and security enhancements—including compact source files, pattern matching for primitive types, scoped values, a new Shenandoah GC, and a powerful vector API—aimed at improving developer productivity, application performance, and sustainability.

JEPSecurityVector API
0 likes · 11 min read
What’s New in Java 25? Explore the Game‑Changing Features and Performance Boosts
php Courses
php Courses
Sep 16, 2025 · Fundamentals

Mastering std::mutex in C++: Prevent Data Races with Simple Examples

Learn why mutexes are essential for safe multithreaded C++ programming, explore the basic std::mutex API, see practical code examples, and discover advanced lock management with std::lock_guard and other mutex types to avoid data races and deadlocks.

C++concurrencylock_guard
0 likes · 9 min read
Mastering std::mutex in C++: Prevent Data Races with Simple Examples
JavaScript
JavaScript
Sep 16, 2025 · Frontend Development

Boost JavaScript Async Performance: Up to 80% Faster Than async/await

This article explains why async/await can cause performance bottlenecks in JavaScript and introduces optimized Promise‑based techniques—such as chain optimization, Promise.all parallelism, batch processing, and pooling—that can improve async execution speed by up to 80% in specific scenarios.

Async/AwaitJavaScriptParallelism
0 likes · 4 min read
Boost JavaScript Async Performance: Up to 80% Faster Than async/await
Python Programming Learning Circle
Python Programming Learning Circle
Sep 15, 2025 · Fundamentals

Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them

This article explains the fundamental concepts of processes and threads, compares their definitions, lifecycles, advantages and disadvantages, and provides practical guidelines for choosing between multi‑processing and multi‑threading based on factors such as resource usage, performance, reliability, and application requirements.

concurrencymultithreadingprocess
0 likes · 19 min read
Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them
php Courses
php Courses
Sep 15, 2025 · Fundamentals

Mastering std::thread: Create, Manage, and Synchronize C++ Threads

This tutorial explains the fundamentals of C++11 std::thread, covering thread creation with functions and lambdas, the use of join() and detach(), argument passing techniques, and essential best practices for safe and portable multithreaded programming.

C++JOINLambda
0 likes · 10 min read
Mastering std::thread: Create, Manage, and Synchronize C++ Threads
Raymond Ops
Raymond Ops
Sep 14, 2025 · Operations

Mastering Concurrency: Optimize Nginx, HAProxy & Keepalived for High‑Performance Servers

This article explains the fundamentals of concurrency, distinguishes connections from requests, shows how to calculate and tune maximum concurrent connections for Nginx and HAProxy, covers system resource limits, demonstrates real‑time monitoring with stub_status, and provides practical load‑testing and Prometheus monitoring guidance.

AB testingHAProxyKeepalived
0 likes · 15 min read
Mastering Concurrency: Optimize Nginx, HAProxy & Keepalived for High‑Performance Servers