BestHub
Sign in
Tagged articles
2075 articles
Page 2 of 21
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 AgentsBackend ArchitectureGo
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.

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

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

Event-drivenIO MultiplexingNon-blocking I/O
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
Open Source Tech Hub
Open Source Tech Hub
Nov 17, 2025 · Backend Development

Mastering High‑Performance PHP with Swoole: Multi‑Process, Coroutine, and Async I/O Guide

Learn how Swoole transforms PHP into a high‑performance, asynchronous server by detailing its multi‑process architecture, reactor‑worker‑task model, coroutine‑enabled I/O, and practical code examples for TCP clients, HTTP servers, and file operations, enabling scalable, non‑blocking applications.

AsynchronousNetwork I/OPHP
0 likes · 7 min read
Mastering High‑Performance PHP with Swoole: Multi‑Process, Coroutine, and Async I/O Guide
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 Levelbinlog
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.

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.

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

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

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

Isolation Levelsconcurrencydeadlock
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 RecruitmentException Handling
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.

Auto ScalingGoPrometheus
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.

ChannelFan-outGo
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.

Optimistic LockRedisconcurrency
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 LevelRead CommittedRepeatable Read
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.

MigrationPostgreSQLconcurrency
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 AgentMemory LeakPerformance
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 PerformanceMigrationPostgreSQL
0 likes · 13 min read
Why PostgreSQL Beats MySQL in High‑Performance Scenarios
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 OptimizationProfiling
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++CASQueue
0 likes · 38 min read
Why Lock‑Free Queues Are the Secret to Scaling C++ Concurrency
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.

Optimistic LockSpring Bootconcurrency
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.

Thread Poolconcurrencyspring
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.

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

JEPconcurrencyjava-25
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.

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

JavaScriptParallelismPerformance Optimization
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.

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

CJoinLambda
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 testingHAProxyMonitoring
0 likes · 15 min read
Mastering Concurrency: Optimize Nginx, HAProxy & Keepalived for High‑Performance Servers
Java Backend Full-Stack
Java Backend Full-Stack
Sep 10, 2025 · Backend Development

How a Misconfigured ThreadPool Caused Data Loss in Production – A Step‑by‑Step Troubleshooting Guide

The article recounts a real production incident where a recent deployment triggered loss of third‑party order data, traces the root cause to an improperly configured ThreadPoolExecutor that used a local memory queue, and walks through the systematic investigation and remediation steps.

BlockingQueueJavaProductionDebugging
0 likes · 6 min read
How a Misconfigured ThreadPool Caused Data Loss in Production – A Step‑by‑Step Troubleshooting Guide
Go Programming World
Go Programming World
Sep 7, 2025 · Backend Development

Mastering Go’s sync.Pool: Deep Dive into Object Pooling and Performance

This article explains how Go's sync.Pool works, shows practical usage examples, walks through its source code, and details the underlying implementation, including Put/Get methods, pinning, and garbage‑collection interaction, helping developers efficiently reuse objects in concurrent programs.

GoObject Poolingconcurrency
0 likes · 20 min read
Mastering Go’s sync.Pool: Deep Dive into Object Pooling and Performance
Code Wrench
Code Wrench
Sep 7, 2025 · Backend Development

Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns

Discover how Go transforms massive concurrency challenges into elegant communication using goroutines, channels, select, and the GMP scheduler, and learn practical patterns such as producer-consumer, pub/sub, worker pools, pipelines, and a prime sieve, complete with runnable code snippets and engineering tips for robust backend systems.

Backend DevelopmentChannelGo
0 likes · 12 min read
Unlock Million-Scale Concurrency in Go: Goroutine, Channel & Real-World Patterns
Go Programming World
Go Programming World
Sep 5, 2025 · Backend Development

How to Test Concurrent Go Code with the New testing/synctest Package

Go’s built‑in concurrency primitives make parallel programming easy, but testing such code is tricky; this article explains the experimental testing/synctest package introduced in Go 1.24/1.25, shows how to rewrite flaky, slow tests into fast, reliable ones, and demonstrates its use with real‑world examples.

GoGoroutineconcurrency
0 likes · 15 min read
How to Test Concurrent Go Code with the New testing/synctest Package
Code Wrench
Code Wrench
Sep 3, 2025 · Backend Development

Master Go: From Beginner Basics to Advanced Concurrency and Runtime

This guide outlines a structured roadmap for learning Go, covering entry‑level syntax, essential concurrency primitives, project‑based practice, engineering best‑practices, and deep runtime and ecosystem exploration, with recommended resources and practical project ideas for each stage.

GoLearning Pathconcurrency
0 likes · 5 min read
Master Go: From Beginner Basics to Advanced Concurrency and Runtime
Tencent Technical Engineering
Tencent Technical Engineering
Sep 1, 2025 · Backend Development

Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance

This article explains Go's memory management mechanisms—including GC fundamentals, stop‑the‑world marking, tri‑color marking with write barriers, hybrid write barriers, and practical optimization techniques such as reducing heap allocations, using caches, concurrency patterns, and profiling tools—to help developers identify and eliminate performance bottlenecks.

Garbage CollectionGoMemory Management
0 likes · 20 min read
Mastering Go Garbage Collection: Tips to Slash Latency and Boost Performance
Zhuanzhuan Tech
Zhuanzhuan Tech
Aug 29, 2025 · Databases

Why MySQL Returns Old Values After Update: Inside InnoDB Snapshot Reads

This article investigates a puzzling MySQL behavior where a row updated within a transaction sometimes returns its previous value, explains the role of InnoDB's snapshot reads and ReadView, reproduces the issue, and offers practical ways to prevent the “update disappearance” scenario.

InnoDBSnapshot ReadUpdate Anomaly
0 likes · 18 min read
Why MySQL Returns Old Values After Update: Inside InnoDB Snapshot Reads
Java Tech Enthusiast
Java Tech Enthusiast
Aug 24, 2025 · Backend Development

Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More

This article compiles a comprehensive Java interview guide covering object‑oriented fundamentals, method overloading vs overriding, core collection implementations, Spring bean lifecycle, composite index usage, process/thread/coroutine distinctions, Linux IPC methods, design‑pattern principles, Redis roles and data types, relational vs NoSQL trade‑offs, QR‑code login design, and a classic 15‑minute brain teaser.

Design PatternsInterviewRedis
0 likes · 17 min read
Master Java Interview Essentials: OOP, Spring Beans, Redis, DB Indexes & More
AndroidPub
AndroidPub
Aug 20, 2025 · Fundamentals

Why Blocking vs Non‑Blocking in Kotlin Coroutines Matters: Live Experiments

This article demystifies the difference between blocking and non‑blocking coroutine work in Kotlin by providing runnable examples, measuring sequential, concurrent, and asynchronous execution, and revealing how thread usage, jobs, and dispatchers affect performance and true parallelism.

AsynchronousBlockingCoroutines
0 likes · 10 min read
Why Blocking vs Non‑Blocking in Kotlin Coroutines Matters: Live Experiments
Tech Freedom Circle
Tech Freedom Circle
Aug 18, 2025 · Interview Experience

How to Hand‑Write a Simple AbstractQueuedSynchronizer (AQS) for High‑Pay Java Interviews

This article walks through the fundamentals of Java's AbstractQueuedSynchronizer, covering lock‑queue relationships, CLH lock internals, dummy head nodes, state management, and step‑by‑step implementations of acquire, addWaiter, acquireQueued, shouldParkAfterFailedAcquire, and release methods, complete with runnable example code.

AQSAbstractQueuedSynchronizerInterview
0 likes · 29 min read
How to Hand‑Write a Simple AbstractQueuedSynchronizer (AQS) for High‑Pay Java Interviews
NetEase LeiHuo Testing Center
NetEase LeiHuo Testing Center
Aug 15, 2025 · Operations

How to Spot Performance Issues Early in Functional Testing

This article explains how integrating concurrency checks into functional testing can uncover performance bottlenecks before load testing, using real game scenarios such as team creation overload, redemption code over‑issuance, and Redis limits, and outlines practical strategies like client behavior analysis, throttling, and early API stress validation to reduce later testing effort.

Game Developmentconcurrencyfunctional testing
0 likes · 15 min read
How to Spot Performance Issues Early in Functional Testing
Tech Freedom Circle
Tech Freedom Circle
Aug 14, 2025 · Backend Development

10 Proven Techniques to Optimize API Latency from 11 s to 170 ms – A Meituan Interview Case

The article presents a step‑by‑step analysis of how to shrink a 11‑second API response to 170 ms by applying batch database writes, Redis pipeline, asynchronous processing, thread‑pool design, local‑memory buffering, MQ integration, and other performance‑tuning patterns, backed by real‑world benchmarks and code samples.

API optimizationAsyncDatabase
0 likes · 48 min read
10 Proven Techniques to Optimize API Latency from 11 s to 170 ms – A Meituan Interview Case