BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 7 of 23
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 27, 2024 · Backend Development

Understanding Java ThreadPoolExecutor Rejection Policies and Their Use Cases

Java's ThreadPoolExecutor provides four built‑in RejectedExecutionHandler strategies—AbortPolicy, CallerRunsPolicy, DiscardPolicy, and DiscardOldestPolicy—each suited to different overload scenarios, and this article explains their behavior, trigger conditions, and practical application guidelines for robust backend concurrency management.

JavaPerformanceRejectionPolicy
0 likes · 10 min read
Understanding Java ThreadPoolExecutor Rejection Policies and Their Use Cases
Aikesheng Open Source Community
Aikesheng Open Source Community
Nov 27, 2024 · Databases

Summary of InnoDB Lock Module Articles

This article provides a concise English recap of the 27 previously published InnoDB lock module articles, covering theoretical concepts such as table and row locks, lock waiting, deadlock handling, and practical scenarios like lock behavior during inserts and duplicate key operations.

Database InternalsInnoDBLocks
0 likes · 6 min read
Summary of InnoDB Lock Module Articles
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 26, 2024 · Backend Development

Understanding CountDownLatch and CompletableFuture in Java Concurrency

This article explains the purpose, typical usage scenarios, and provides concrete code demonstrations of Java's CountDownLatch and CompletableFuture, comparing their synchronization versus asynchronous capabilities and guiding developers on selecting the appropriate tool for effective multithreaded programming.

CompletableFutureCountDownLatchJava
0 likes · 6 min read
Understanding CountDownLatch and CompletableFuture in Java Concurrency
Go Programming World
Go Programming World
Nov 25, 2024 · Backend Development

Understanding Go's singleflight: Request Merging, Implementation and Use Cases

singleflight, a Go concurrency primitive from the x/sync package, merges duplicate in‑flight requests to reduce server load, with detailed usage examples, source code analysis, and discussion of its differences from sync.Once and typical application scenarios such as cache‑penetration, remote calls, and task deduplication.

CacheGoconcurrency
0 likes · 26 min read
Understanding Go's singleflight: Request Merging, Implementation and Use Cases
Liangxu Linux
Liangxu Linux
Nov 24, 2024 · Fundamentals

What Is an Operating System? Core Functions, Features, and Architecture Explained

This article provides a comprehensive overview of operating systems, explaining their essence as software, detailing core functions such as process and memory management, device and file system handling, security, user interfaces, and describing key characteristics like concurrency, sharing, asynchrony, virtualization, as well as common OS classifications and architectural designs.

Memory ManagementOS fundamentalsProcess Management
0 likes · 15 min read
What Is an Operating System? Core Functions, Features, and Architecture Explained
FunTester
FunTester
Nov 22, 2024 · Operations

Why Java Is the Ultimate Backbone for Performance Testing

The author recounts a four‑year journey from UI automation to Java‑based performance testing, illustrating how mastering Java’s concurrency utilities and Groovy scripting can replace traditional tools like JMeter, enabling flexible, high‑throughput test scenarios and deeper control over test case design.

GroovyJMeterJava
0 likes · 8 min read
Why Java Is the Ultimate Backbone for Performance Testing
Liangxu Linux
Liangxu Linux
Nov 21, 2024 · Fundamentals

When to Use Spin Locks and How They Work in Multithreaded Code

This article explains the concept of spin locks, compares them with mutexes, shows how to use the pthread API and C++ atomic_flag to implement them, outlines suitable scenarios, highlights CPU‑usage pitfalls, and provides practical code examples.

C++concurrencylinux
0 likes · 10 min read
When to Use Spin Locks and How They Work in Multithreaded Code
Top Architect
Top Architect
Nov 21, 2024 · Backend Development

Best Practices and Common Pitfalls of Using Thread Pools in Java

This article summarizes how to correctly declare, monitor, configure, and name Java thread pools, explains common mistakes such as unbounded queues and ThreadLocal contamination, and introduces dynamic tuning techniques and open‑source solutions for robust backend concurrency management.

JavaSpringBootThreadLocal
0 likes · 18 min read
Best Practices and Common Pitfalls of Using Thread Pools in Java
Top Architecture Tech Stack
Top Architecture Tech Stack
Nov 19, 2024 · Backend Development

Understanding Java ThreadPool Rejection Policies and Their Use Cases

This article explains the conditions that trigger Java thread‑pool rejection policies, describes the four built‑in policies (AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy), provides detailed code examples for each, and discusses suitable application scenarios for backend developers.

JavaRejectionPolicyThreadPool
0 likes · 13 min read
Understanding Java ThreadPool Rejection Policies and Their Use Cases
Java Architecture Stack
Java Architecture Stack
Nov 18, 2024 · Fundamentals

Inside Go’s Runtime: How mcache and mheap Manage Memory

This article provides a detailed technical analysis of Go's runtime memory management, covering the initialization of the mheap structure, small‑object allocation via mcache, large‑object handling, the three‑color mark‑and‑sweep garbage collector, memory release mechanisms, and the optimization techniques that coordinate mcache and mheap for efficient concurrent execution.

Garbage CollectionGoMemory Management
0 likes · 12 min read
Inside Go’s Runtime: How mcache and mheap Manage Memory
Deepin Linux
Deepin Linux
Nov 12, 2024 · Fundamentals

Understanding Linux Memory Barriers: Types, Usage, and Implementation

This article provides a comprehensive overview of Linux memory barriers, explaining why they are needed for correct ordering of memory operations on modern multi‑core CPUs, describing the different barrier types (read, write, full), their implementation in the kernel and Java, and illustrating their use in synchronization primitives and lock‑free data structures with code examples.

CPU architectureLinux kernelconcurrency
0 likes · 71 min read
Understanding Linux Memory Barriers: Types, Usage, and Implementation
php Courses
php Courses
Nov 12, 2024 · Backend Development

Analysis of Process Mutual Exclusion in PHP and Automatic Semaphore Release

This article explains how a PHP script uses a named semaphore for process mutual exclusion, demonstrates why a second concurrent process can acquire the semaphore after the first finishes, and clarifies that PHP automatically releases held semaphores when a process terminates.

PHPSemaphorebackend
0 likes · 3 min read
Analysis of Process Mutual Exclusion in PHP and Automatic Semaphore Release
Taobao Frontend Technology
Taobao Frontend Technology
Nov 8, 2024 · Fundamentals

Exploring New ECMAScript Proposals: Discard Bindings, Iterator Chunking, and More

This article reviews several Stage 2 ECMAScript proposals—including discard bindings using the void operator, iterator chunking for sliding windows and non‑overlapping sequences, phase‑based ESM imports for static worker initialization, extractors for custom destructuring, and structs with shared memory, mutexes, and unsafe blocks.

ECMAScriptJavaScriptconcurrency
0 likes · 13 min read
Exploring New ECMAScript Proposals: Discard Bindings, Iterator Chunking, and More
Python Programming Learning Circle
Python Programming Learning Circle
Nov 6, 2024 · Fundamentals

Comprehensive Python Cheat Sheet and Advanced Topics Summary

This article compiles an extensive Python reference covering Python 2 vs 3 differences, essential and advanced libraries, concurrency models, language internals, testing techniques, design patterns, data structures, algorithms, networking basics, MySQL and Redis insights, Linux I/O models, and performance‑optimization strategies, all illustrated with practical code snippets.

Cheat SheetDesign PatternsRedis
0 likes · 31 min read
Comprehensive Python Cheat Sheet and Advanced Topics Summary
JD Retail Technology
JD Retail Technology
Nov 5, 2024 · Backend Development

Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions

The article examines how frequent inventory adjustments in JD retail supply‑chain can suffer from concurrency issues, explains why traditional locking may fail, analyzes a real‑world case of lock misuse, and presents code‑level, database‑level, and architectural solutions to guarantee data consistency.

DatabaseInventoryconcurrency
0 likes · 7 min read
Ensuring Inventory Consistency Under Concurrent Operations: Locking Pitfalls and Solutions
Su San Talks Tech
Su San Talks Tech
Nov 3, 2024 · Backend Development

Mastering Java Locks: From Optimistic to Biased – A Complete Guide

This article offers a comprehensive overview of Java's lock mechanisms, detailing each lock type, its underlying principle, typical use cases, differences between synchronized and Lock, and practical code examples for implementing read‑write locks and optimizing concurrency.

JavaLocksconcurrency
0 likes · 19 min read
Mastering Java Locks: From Optimistic to Biased – A Complete Guide
Top Architect
Top Architect
Nov 2, 2024 · Backend Development

Optimizing Excel Export with EasyExcel: Performance Improvements and Merged‑Cell Strategies

This article demonstrates how to boost performance when exporting large datasets to Excel using EasyExcel, covering single‑batch, paginated, and concurrent writes, and explains multiple approaches—including annotations and custom WriteHandlers—to efficiently create merged cells in the generated spreadsheets.

Cell MergingEasyExcelExcel export
0 likes · 18 min read
Optimizing Excel Export with EasyExcel: Performance Improvements and Merged‑Cell Strategies
Java Architect Essentials
Java Architect Essentials
Oct 30, 2024 · Backend Development

Optimizing Excel Export with EasyExcel: Performance, Pagination, Concurrency, and Cell‑Merging Strategies

This article demonstrates how to use EasyExcel to efficiently export large volumes of data to Excel by improving performance through pagination, concurrent queries, and custom cell‑merging strategies, including built‑in annotations and WriteHandler implementations, while providing complete Java code examples.

Cell MergingEasyExcelExcel export
0 likes · 16 min read
Optimizing Excel Export with EasyExcel: Performance, Pagination, Concurrency, and Cell‑Merging Strategies
BirdNest Tech Talk
BirdNest Tech Talk
Oct 27, 2024 · Fundamentals

How Go’s Runtime Uses Treap for Efficient Goroutine Scheduling

This article explains the treap data structure—its BST and heap properties, random priority balancing, and implementation details—then dives into Go's runtime semaRoot treap, showing step‑by‑step enqueue and dequeue algorithms with code, rotations, and performance reasoning.

Data StructuresTreapbalanced tree
0 likes · 17 min read
How Go’s Runtime Uses Treap for Efficient Goroutine Scheduling
Test Development Learning Exchange
Test Development Learning Exchange
Oct 27, 2024 · Fundamentals

Fundamental and Advanced Exception Handling in Python

This article presents a comprehensive guide to Python exception handling, covering basic try‑except usage, multiple exception capture, else/finally clauses, custom exceptions, exception chaining, logging, context managers, assertions, traceback, concurrent and asynchronous error handling, and testing techniques.

Loggingasyncioconcurrency
0 likes · 8 min read
Fundamental and Advanced Exception Handling in Python
Programmer1970
Programmer1970
Oct 24, 2024 · Databases

Demystifying MySQL InnoDB’s Thread Model: A Deep Dive

The article explains MySQL InnoDB’s multi‑thread architecture—including the Master, IO, Purge, and Page Cleaner threads—detailing each thread’s responsibilities, configurable parameters, and how they cooperate to achieve high‑performance, concurrent data reads and writes while maintaining consistency and crash recovery.

Database PerformanceInnoDBMySQL
0 likes · 11 min read
Demystifying MySQL InnoDB’s Thread Model: A Deep Dive
macrozheng
macrozheng
Oct 24, 2024 · Backend Development

Master Java Thread Pools: Boost Performance and Avoid Resource Pitfalls

This article explains why creating a thread for each task is inefficient, introduces thread pools as a solution, compares execution times with code examples, details ThreadPoolExecutor's core interfaces, constructors, execution flow, rejection policies, state transitions, and provides practical usage patterns and best‑practice recommendations for Java backend development.

JavaThreadPoolExecutorbackend development
0 likes · 28 min read
Master Java Thread Pools: Boost Performance and Avoid Resource Pitfalls
dbaplus Community
dbaplus Community
Oct 23, 2024 · Backend Development

Mastering Java Thread Pools: Common Pitfalls and Best Practices

This article outlines how to correctly create, monitor, and configure Java ThreadPoolExecutor instances, explains why using the Executors factory can cause OOM, recommends separate named pools per business, provides formulas for sizing CPU‑bound and I/O‑bound workloads, and highlights real‑world pitfalls and dynamic‑configuration solutions.

concurrencymonitoringspring
0 likes · 16 min read
Mastering Java Thread Pools: Common Pitfalls and Best Practices
Su San Talks Tech
Su San Talks Tech
Oct 23, 2024 · Backend Development

Unlocking Java’s AQS: A Deep Dive into AbstractQueuedSynchronizer and Concurrency Primitives

This article explores the origins of Java's JUC package, explains the core concepts of AbstractQueuedSynchronizer—including template methods, exclusive and shared acquisition, CLH queues, CAS, and LockSupport—and demonstrates how locks, conditions, and synchronization mechanisms are implemented and used in real-world Java concurrency.

AQSConditionJava
0 likes · 30 min read
Unlocking Java’s AQS: A Deep Dive into AbstractQueuedSynchronizer and Concurrency Primitives
Programmer1970
Programmer1970
Oct 21, 2024 · Backend Development

Master Google Guava: 40 Practical Examples to Supercharge Your Java Code

This article walks through the most commonly used Google Guava packages, demonstrating how to handle strings, collections, primitives, I/O, and various utility classes with concise code snippets and practical tips to boost Java development productivity.

Google GuavaGuava utilitiesHashing
0 likes · 18 min read
Master Google Guava: 40 Practical Examples to Supercharge Your Java Code
BirdNest Tech Talk
BirdNest Tech Talk
Oct 20, 2024 · Fundamentals

Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler

This article dissects Go's runtime GPM model and the lock‑free runq data structure, detailing its fields, core operations such as runqput, runqget, runqgrab, and their atomic implementations, while also comparing local and global queues and illustrating the code paths with concrete examples.

Data StructuresGoLock-Free
0 likes · 24 min read
Unveiling Go’s runq: Lock‑Free Queues Behind the Scheduler
Top Architect
Top Architect
Oct 17, 2024 · Backend Development

Understanding ForkJoinPool and the Fork/Join Framework in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, analyzes the pool’s design, task submission methods, work‑stealing mechanism, common pool pitfalls, and presents performance evaluation results.

DivideAndConquerForkJoinPoolJava
0 likes · 26 min read
Understanding ForkJoinPool and the Fork/Join Framework in Java
php Courses
php Courses
Oct 15, 2024 · Backend Development

Using curl_multi_select() in PHP to Wait for Active cURL Transfers

The article explains how to use PHP’s curl_multi_select() function to wait for active cURL transfers in a multi‑handle scenario, detailing its definition, parameters, behavior, and providing a complete example that demonstrates efficient concurrent HTTP requests handling.

backendcURL Multiconcurrency
0 likes · 4 min read
Using curl_multi_select() in PHP to Wait for Active cURL Transfers
BirdNest Tech Talk
BirdNest Tech Talk
Oct 14, 2024 · Backend Development

Why Go’s lock‑free PoolDequeue outperforms channels by 10×

This article examines Go’s internal lock‑free single‑producer multi‑consumer queues—PoolDequeue and its dynamic extension PoolChain—detailing their design, atomic operations, and benchmark comparisons that show they can be up to ten times faster than standard channels in a producer‑consumer workload.

GoLock-FreePerformance
0 likes · 13 min read
Why Go’s lock‑free PoolDequeue outperforms channels by 10×
Sanyou's Java Diary
Sanyou's Java Diary
Oct 14, 2024 · Fundamentals

Unlocking Java’s AQS: How AbstractQueuedSynchronizer Powers Locks and Synchronizers

This article explains Java's AbstractQueuedSynchronizer (AQS) framework, detailing its FIFO queue, state handling, entry‑wait queue, exclusive and shared lock acquisition, condition‑variable queues, and how core concurrency utilities like ReentrantLock, ReadWriteLock, CountDownLatch, Semaphore, and ThreadPoolExecutor are built on it.

AQSLocksconcurrency
0 likes · 31 min read
Unlocking Java’s AQS: How AbstractQueuedSynchronizer Powers Locks and Synchronizers
Test Development Learning Exchange
Test Development Learning Exchange
Oct 14, 2024 · Fundamentals

Understanding async and await in Python with Practical Examples

This article introduces Python's async and await keywords, explains how they enable coroutine programming, and provides multiple practical examples including simple coroutine definitions, awaiting tasks, concurrent execution with asyncio.gather, HTTP requests using aiohttp, and resource management with custom coroutine-based managers.

Pythonasyncasyncio
0 likes · 6 min read
Understanding async and await in Python with Practical Examples
macrozheng
macrozheng
Oct 11, 2024 · Backend Development

Does Spring Commit Before Unlock? Unraveling Transaction Timing in High‑Concurrency

This article dissects the exact moment a Spring @Transactional method commits relative to a surrounding lock, explains why committing after unlock can cause overselling, and provides source‑level debugging techniques to verify transaction start, commit, and rollback behavior in MySQL under high concurrency.

DatabaseJavaLock
0 likes · 21 min read
Does Spring Commit Before Unlock? Unraveling Transaction Timing in High‑Concurrency
Java Architect Essentials
Java Architect Essentials
Oct 9, 2024 · Backend Development

Investigating and Resolving a Massive Thread Leak in a Java Backend Application

This article details the discovery, analysis, and fix of a severe thread‑leak issue in a Java Spring MVC service caused by unsafe use of a shared CloseableHttpAsyncClient, showing how multithreaded testing reproduced the problem and how refactoring the client to a local variable eliminated the runaway thread growth.

HttpAsyncClientJavaPerformance
0 likes · 12 min read
Investigating and Resolving a Massive Thread Leak in a Java Backend Application
Architect
Architect
Oct 8, 2024 · Backend Development

How to Supercharge Java Backend Performance with CompletableFuture, Thread Pools, Caching, and Lock Tuning

This article analyzes Java performance bottlenecks and demonstrates how to use CompletableFuture for parallelism, fine‑tune ThreadPoolExecutor parameters, minimize transaction scope, apply cache‑line padding, object pooling, lock‑granularity techniques, copy‑on‑write collections, and reduce network payloads to achieve lower latency and higher throughput.

CompletableFutureJavaPerformanceOptimization
0 likes · 38 min read
How to Supercharge Java Backend Performance with CompletableFuture, Thread Pools, Caching, and Lock Tuning
Java Architecture Stack
Java Architecture Stack
Sep 30, 2024 · Backend Development

Mastering Unbounded and Bounded Queues in Java: When to Use Each

This article explains the concepts, characteristics, and ideal scenarios for unbounded and bounded queues in Java, provides step‑by‑step Maven setup and complete code examples for asynchronous task scheduling, event‑driven processing, and API rate‑limiting, and highlights practical considerations such as resource management and performance.

Bounded QueueJavaQueue
0 likes · 23 min read
Mastering Unbounded and Bounded Queues in Java: When to Use Each
Java Tech Enthusiast
Java Tech Enthusiast
Sep 29, 2024 · Fundamentals

What Is an Operating System? Core Functions, Architecture & Key Concepts

Operating systems are foundational software that manage hardware resources, provide core services like process and memory management, device and file handling, security, and user interfaces, while embodying key properties such as concurrency, sharing, asynchrony, and virtualization, and exist in various architectures from monolithic to microkernels.

Memory ManagementProcess ManagementVirtualization
0 likes · 14 min read
What Is an Operating System? Core Functions, Architecture & Key Concepts
Open Source Tech Hub
Open Source Tech Hub
Sep 29, 2024 · Backend Development

Speed Up PHP Tasks: Swow Coroutines vs Sequential Execution

This article demonstrates how PHP's Swow library executes tasks sequentially versus concurrently using coroutines, compares runtime differences, explains why the main coroutine exits early, and introduces synchronization utilities like waitAll, WaitGroup, and WaitReference with practical code examples.

concurrencysynchronizationwaitgroup
0 likes · 12 min read
Speed Up PHP Tasks: Swow Coroutines vs Sequential Execution
MaGe Linux Operations
MaGe Linux Operations
Sep 28, 2024 · Backend Development

Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization

This comprehensive guide explains the fundamentals of concurrent programming in Go, covering the differences between parallelism and concurrency, process and thread concepts, and detailed usage of goroutines, channels, select statements, timers, mutexes, read‑write locks, wait groups, once, sync.Map, and atomic operations with practical code examples and diagrams.

Parallelismatomicchannel
0 likes · 42 min read
Master Go Concurrency: Goroutines, Channels, Locks, Timers and Synchronization
Bilibili Tech
Bilibili Tech
Sep 27, 2024 · Backend Development

Concurrency Issues and Race Condition Mitigation in Bilibili's Content Production System

Bilibili tackled race‑condition vulnerabilities in its massive video content pipeline by replacing simple timestamp checks with optimistic locking (CAS) and rate‑limiting locks, adding version verification and observation tools that now eliminate missed reviews and improve security, scalability, and real‑time editing reliability.

Bilibiliconcurrencycontent moderation
0 likes · 10 min read
Concurrency Issues and Race Condition Mitigation in Bilibili's Content Production System
Programmer XiaoFu
Programmer XiaoFu
Sep 26, 2024 · Backend Development

Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained

This article explains how Guava's RateLimiter, built on the token‑bucket algorithm, provides smooth burst handling, configurable rates, warm‑up support, and thread safety, and demonstrates its usage through detailed code examples and best‑practice recommendations for API, database, and crawler throttling.

GuavaJavaRateLimiter
0 likes · 9 min read
Boost Coding Efficiency with Guava RateLimiter: Elegant Rate Limiting Explained
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 24, 2024 · Backend Development

How to Properly Configure ThreadPoolExecutor Parameters in Java

This article explains the background, creation, and detailed parameters of Java's ThreadPoolExecutor, walks through its task execution flow, warns against using Executors factory methods, and provides practical formulas for setting core pool sizes based on CPU‑bound or I/O‑bound workloads.

CPUI/OJava
0 likes · 15 min read
How to Properly Configure ThreadPoolExecutor Parameters in Java
IT Architects Alliance
IT Architects Alliance
Sep 24, 2024 · Backend Development

Implementing a FIFO Export Queue for Large Data Exports in Java

The article describes a Java‑based FIFO export queue that limits concurrent MySQL export operations, outlines the related classes (ExportQueue, AbstractExport, ExportImpl, and a test controller), provides full source code, and presents test results showing how the queue manages up to ten simultaneous export requests.

EasyExcelExportQueueFIFO
0 likes · 11 min read
Implementing a FIFO Export Queue for Large Data Exports in Java
G7 EasyFlow Tech Circle
G7 EasyFlow Tech Circle
Sep 24, 2024 · Databases

Why Modern Databases Prefer LSM Trees Over B‑Trees: Hardware, Workloads, and More

Modern databases have largely shifted from B‑tree based storage to LSM‑tree engines due to SSD hardware characteristics, high‑write workloads, concurrency advantages, simpler implementation, and evolving application demands, with additional insights into Paxos/Raft consensus, common database jargon, and performance optimizations.

Database JargonDatabase StorageLSM Tree
0 likes · 11 min read
Why Modern Databases Prefer LSM Trees Over B‑Trees: Hardware, Workloads, and More
Programmer1970
Programmer1970
Sep 22, 2024 · Backend Development

15 Proven Techniques to Optimize API Performance

This article enumerates fifteen practical techniques—including local and distributed caching, parallelism, asynchrony, pooling, sharding, SQL tuning, pre‑computation, transaction trimming, bulk I/O, lock granularity, context propagation, collection sizing, and query optimization—to systematically improve the response time and throughput of service interfaces.

APIAsynchronousSQL
0 likes · 14 min read
15 Proven Techniques to Optimize API Performance
Architecture Development Notes
Architecture Development Notes
Sep 20, 2024 · Fundamentals

Go vs Rust: Which Language Wins for Your Next Project?

An in‑depth guide compares Go and Rust across memory management, learning curve, concurrency, ecosystem, performance, developer experience, and real‑world use cases, helping developers decide which language best fits cloud‑native services, system programming, web development, game development, or DevOps tools.

GoLanguage comparisonRust
0 likes · 18 min read
Go vs Rust: Which Language Wins for Your Next Project?
Java Backend Technology
Java Backend Technology
Sep 18, 2024 · Backend Development

Why Fast‑Retry Beats Spring‑Retry for Massive Asynchronous Retries

Fast‑Retry is a high‑performance, multi‑task asynchronous retry framework for Java that dramatically outperforms traditional synchronous retry libraries like Spring‑Retry and Guava‑Retry, especially when handling millions of tasks, by leveraging non‑blocking execution, customizable strategies, and seamless Spring integration.

AsynchronousJavaRetry
0 likes · 13 min read
Why Fast‑Retry Beats Spring‑Retry for Massive Asynchronous Retries
Alibaba Cloud Developer
Alibaba Cloud Developer
Sep 18, 2024 · Backend Development

Unlock Massive Concurrency with Java Virtual Threads: A Deep Dive

This article explores Java virtual threads introduced in JDK 21, detailing their architecture, implementation, practical usage with Thread and Executors APIs, performance comparisons against platform threads, best‑practice guidelines, and benchmark results demonstrating superior throughput for high‑concurrency server applications.

JDK21JavaVirtual Threads
0 likes · 24 min read
Unlock Massive Concurrency with Java Virtual Threads: A Deep Dive
BirdNest Tech Talk
BirdNest Tech Talk
Sep 17, 2024 · Fundamentals

Why Rust’s Mutex API Looks Different from C’s and What It Means for Safety

The article analyses the design of Rust’s Mutex API, compares it with the classic C/POSIX mutex API, explores alternative Rust designs that mimic C, and demonstrates through concrete code examples why Rust’s guard‑based approach preserves safety while a C‑style API would re‑introduce data‑race hazards.

C++Programming LanguagesRust
0 likes · 27 min read
Why Rust’s Mutex API Looks Different from C’s and What It Means for Safety
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Sep 17, 2024 · Backend Development

In‑Depth Explanation of Java ConcurrentHashMap Core Principles and Source Code

This article provides a comprehensive analysis of Java's ConcurrentHashMap, covering its underlying data structures, key attributes, core components such as Node, ForwardingNode, TreeBin, and TreeNode, and detailed explanations of the put, get, hash, and resizing algorithms with annotated source code examples.

ConcurrentHashMapData StructuresHashMap
0 likes · 17 min read
In‑Depth Explanation of Java ConcurrentHashMap Core Principles and Source Code
Top Architect
Top Architect
Sep 15, 2024 · Backend Development

Understanding ForkJoinPool: Theory, Implementation, and Performance Evaluation

This article introduces the Fork/Join model and ForkJoinPool in Java, explains divide‑and‑conquer principles, provides sample RecursiveTask code for summing ranges, analyzes pool construction, task submission, work‑stealing, monitoring methods, and presents performance experiments highlighting task granularity impact.

DivideAndConquerForkJoinPoolJava
0 likes · 28 min read
Understanding ForkJoinPool: Theory, Implementation, and Performance Evaluation
Code Farming
Code Farming
Sep 14, 2024 · Backend Development

How RocketMQ Handles Concurrency: Deep Dive into Its Design Principles

This article dissects RocketMQ's concurrency mechanisms, explaining why it uses ReentrantReadWriteLock with HashMaps, how Semaphore controls async send rates, the SemaphoreReleaseOnlyOnce wrapper, the CountDownLatch‑based sync‑to‑async pattern, and the CompletableFuture redesign that reduces blocking in message replication.

CompletableFutureDistributed MessagingJava
0 likes · 10 min read
How RocketMQ Handles Concurrency: Deep Dive into Its Design Principles
Tencent Cloud Developer
Tencent Cloud Developer
Sep 10, 2024 · Fundamentals

Why Does This Go Code Block? Uncovering Channel and Select Pitfalls

This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.

DeadlockGoSELECT
0 likes · 20 min read
Why Does This Go Code Block? Uncovering Channel and Select Pitfalls
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 10, 2024 · Fundamentals

Deep Dive into Guava: A Powerful Toolkit for Java Developers

This article provides a comprehensive guide to Google Guava, covering its core modules such as collections, concurrency, string utilities, I/O, caching, event bus, functional programming, reflection, and best‑practice code examples that demonstrate how to simplify and strengthen Java development.

CacheCollectionsEventBus
0 likes · 31 min read
Deep Dive into Guava: A Powerful Toolkit for Java Developers
Python Programming Learning Circle
Python Programming Learning Circle
Sep 9, 2024 · Fundamentals

Advanced Python Techniques: Data Structures, Decorators, Metaprogramming, Concurrency, and Performance Optimization

This article introduces experienced Python developers to advanced techniques and best practices, covering high‑level data structures from the collections module, custom data structures, decorators and context managers, metaclasses, dynamic class creation, concurrent and asynchronous programming, performance tuning, memory management, coding standards, and testing strategies.

Advanced TechniquesPerformanceconcurrency
0 likes · 10 min read
Advanced Python Techniques: Data Structures, Decorators, Metaprogramming, Concurrency, and Performance Optimization
DaTaobao Tech
DaTaobao Tech
Sep 6, 2024 · Backend Development

Go Language Coroutine Principles and GMP Model Implementation

The article examines Go's coroutine architecture and its GMP (Goroutine-Machine-Processor) model, tracing coroutine history, comparing kernel, user, and hybrid thread models, and detailing G, M, and P components, scheduling principles, work-stealing, preemption, and runtime implementation that give Go high concurrency and low latency.

CoroutinesGMP modelGo language
0 likes · 37 min read
Go Language Coroutine Principles and GMP Model Implementation
Architect's Guide
Architect's Guide
Sep 5, 2024 · Databases

Strategies for Fast Import of 1 Billion Records into MySQL

To import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, the article examines data partitioning, B‑tree index limits, batch insertion, storage engine choices, concurrency control, file‑reading methods, task scheduling with Redis, Redisson, and Zookeeper for reliable, ordered, high‑throughput loading.

Batch InsertData PartitioningMySQL
0 likes · 18 min read
Strategies for Fast Import of 1 Billion Records into MySQL
Architects' Tech Alliance
Architects' Tech Alliance
Sep 4, 2024 · Fundamentals

Why Bigger Transformers Win: Scaling Laws and Parallel Computing Essentials

The article explains OpenAI's 2020 Scaling Laws that show larger transformer models, more data, and greater compute consistently improve performance, introduces the concept of emergent abilities at critical size thresholds, and outlines the core principles of parallel computing such as multi‑processor usage, task decomposition, concurrent execution, and inter‑processor communication.

Parallel ComputingScaling Lawscommunication
0 likes · 6 min read
Why Bigger Transformers Win: Scaling Laws and Parallel Computing Essentials
Java Architect Essentials
Java Architect Essentials
Aug 31, 2024 · Backend Development

Java Backend Performance Optimization: Parallel Processing, Transaction Scope, Caching, Thread Pools, and Concurrency

This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.

JavaOptimizationPerformance
0 likes · 33 min read
Java Backend Performance Optimization: Parallel Processing, Transaction Scope, Caching, Thread Pools, and Concurrency
21CTO
21CTO
Aug 30, 2024 · Backend Development

How to Stay Ahead as a Java Developer: Tips for JDK 21, Spring Boot 3.2, and Beyond

This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.

JDK 21JavaSpring Boot
0 likes · 9 min read
How to Stay Ahead as a Java Developer: Tips for JDK 21, Spring Boot 3.2, and Beyond
IT Services Circle
IT Services Circle
Aug 30, 2024 · Backend Development

Technical Interview Q&A: C++ vs Go, Thread Communication, Goroutine, TCP Handshake, SQL, and More

This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.

C++GoOperating Systems
0 likes · 12 min read
Technical Interview Q&A: C++ vs Go, Thread Communication, Goroutine, TCP Handshake, SQL, and More
Su San Talks Tech
Su San Talks Tech
Aug 30, 2024 · Backend Development

Prevent Data Loss in Java Thread Pools When Services Crash

This article explains Java thread pools, their advantages, internal mechanics, common pitfalls such as oversized queues, excessive threads, and data loss on crashes, and presents a persistence‑based solution using database‑stored tasks and scheduled retries to ensure no data is lost when services go down.

JavaOOM preventionbackend development
0 likes · 8 min read
Prevent Data Loss in Java Thread Pools When Services Crash
BirdNest Tech Talk
BirdNest Tech Talk
Aug 28, 2024 · Backend Development

Why Go Channels Slow Down on More CPUs and How to Fix It

A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.

ChannelsGOMAXPROCSGo
0 likes · 10 min read
Why Go Channels Slow Down on More CPUs and How to Fix It
IT Services Circle
IT Services Circle
Aug 28, 2024 · Backend Development

Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization

The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.

Bloom filterDatabaseJava
0 likes · 21 min read
Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization
Code Ape Tech Column
Code Ape Tech Column
Aug 26, 2024 · Backend Development

Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions

This article explains why exceptions thrown by tasks submitted to a Java thread pool behave differently with submit and execute, demonstrates how to capture those exceptions using Future.get, try‑catch, Thread.setDefaultUncaughtExceptionHandler, and by overriding afterExecute, and provides complete code examples for each approach.

ExceptionHandlingJavaThreadPool
0 likes · 13 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions
21CTO
21CTO
Aug 24, 2024 · Backend Development

How PayPal Scaled to Billions of Transactions with Only 8 VMs via Actor Model

PayPal’s rapid growth forced it to process millions of transactions daily, leading the engineering team to expand beyond a thousand virtual machines and confront escalating network, maintenance, and resource challenges, which they solved by adopting the Akka‑based Actor model and implementing a Go‑based actor system for efficient, fault‑tolerant concurrency.

AkkaPayPalactor-model
0 likes · 11 min read
How PayPal Scaled to Billions of Transactions with Only 8 VMs via Actor Model
Eric Tech Circle
Eric Tech Circle
Aug 22, 2024 · Backend Development

Mastering Asynchronous Batch Processing with JDK 21 Virtual Threads

Using JDK 21’s standardized Virtual Threads, this guide explains how to design and implement robust asynchronous batch processing, covering common pitfalls like CPU spikes and OOM, best‑practice concurrency controls, task queue architecture, and practical code illustrations.

AsynchronousProcessingBatchProcessingJDK21
0 likes · 6 min read
Mastering Asynchronous Batch Processing with JDK 21 Virtual Threads
21CTO
21CTO
Aug 22, 2024 · Fundamentals

How Rust Revolutionized Memory Safety and Became the Fastest‑Growing Language

This article traces Rust’s origin from Graydon Hoare’s personal frustration with buggy elevators to its rise as a memory‑safe, high‑performance language adopted by major tech companies, highlighting its design principles, community culture, and impact on modern software development.

concurrencymemory safety
0 likes · 16 min read
How Rust Revolutionized Memory Safety and Became the Fastest‑Growing Language
php Courses
php Courses
Aug 22, 2024 · Backend Development

Understanding PHP 8.1 Fibers: Concepts, Usage, and Practical Examples

This article explains PHP 8.1's Fibers feature, describing how they enable lightweight cooperative multitasking, showing basic and advanced code examples for non‑blocking I/O, parallel API/database calls, and large‑file processing, and discusses benefits, use‑cases, and important limitations.

Fibersconcurrencynon-blocking I/O
0 likes · 12 min read
Understanding PHP 8.1 Fibers: Concepts, Usage, and Practical Examples
dbaplus Community
dbaplus Community
Aug 21, 2024 · Backend Development

How PayPal Handled Billions of Daily Transactions with Only 8 VMs via Actor Model

PayPal’s rapid growth forced a shift from simple hardware upgrades to a sophisticated, actor‑based architecture built on Akka, enabling efficient resource utilization, fault tolerance, and high‑throughput processing, ultimately allowing the company to handle billions of daily transactions using only eight virtual machines.

PayPalactor-modelbackend
0 likes · 11 min read
How PayPal Handled Billions of Daily Transactions with Only 8 VMs via Actor Model
Bin's Tech Cabin
Bin's Tech Cabin
Aug 20, 2024 · Backend Development

How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety

This article examines Netty 4.1.x’s ByteBuf reference‑counting mechanism, explains why reference counting was introduced, traces its original design, shows instruction‑level optimizations, reveals concurrency bugs in version 4.1.17, and details the clever even‑odd redesign that guarantees thread‑safe memory release while preserving high performance.

ByteBufJavaNetty
0 likes · 34 min read
How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety
Liangxu Linux
Liangxu Linux
Aug 18, 2024 · Backend Development

Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes

This article explains the thundering herd phenomenon in multi‑process/thread servers, details its performance costs, demonstrates the issue with accept() and epoll_wait() through C examples, explores thread‑level herd, and presents mitigation techniques such as accept mutexes, SO_REUSEPORT, and Nginx's handling.

Linux kernelSO_REUSEPORTServer Programming
0 likes · 20 min read
Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes
Test Development Learning Exchange
Test Development Learning Exchange
Aug 17, 2024 · Backend Development

Python Decorator Examples for API Testing

This article presents ten practical Python decorator patterns—such as logging, performance measurement, exception handling, retry, status‑code validation, parameter checking, rate limiting, data‑driven testing, environment configuration, and concurrent execution—each illustrated with clear use‑case descriptions and complete code snippets for API testing.

LoggingPerformanceRetry
0 likes · 9 min read
Python Decorator Examples for API Testing
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 14, 2024 · Backend Development

How to Safely Pass ThreadLocal Values Across Thread Pools with TTL

This article explains the limitations of Java's ThreadLocal and InheritableThreadLocal in thread‑pool scenarios, introduces Alibaba's open‑source TransmittableThreadLocal (TTL) library, and provides detailed code examples for safely transmitting thread‑local data across threads, thread pools, and even via Java agents.

TTLThreadPoolTransmittableThreadLocal
0 likes · 10 min read
How to Safely Pass ThreadLocal Values Across Thread Pools with TTL
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 13, 2024 · Backend Development

Understanding Java Atomic Variables and Their Applications in Concurrent Programming

This article provides a comprehensive guide to Java atomic variables, explaining their core concepts, underlying CAS mechanism, key classes such as AtomicInteger, AtomicLong, AtomicReference, and AtomicBoolean, and demonstrating practical code examples, use‑cases, performance benefits, limitations, and comparisons with traditional lock‑based synchronization.

Atomic VariablesCASLock-Free
0 likes · 21 min read
Understanding Java Atomic Variables and Their Applications in Concurrent Programming
FunTester
FunTester
Aug 12, 2024 · Backend Development

Building a High‑Performance LRU Cache in Go from Scratch

This article explains the importance of caching, compares common replacement policies, and walks through a complete Go implementation of a thread‑safe local LRU cache, including interface design, data structures, linked‑list management, and concurrency handling.

Data StructuresGoLRU cache
0 likes · 11 min read
Building a High‑Performance LRU Cache in Go from Scratch
Java Architect Essentials
Java Architect Essentials
Aug 11, 2024 · Backend Development

Why @Transactional Can Invalidate Locks in Spring and How to Fix It

This article explains how using Spring's @Transactional annotation together with explicit locks can cause unexpected concurrency issues, demonstrates the problem with sample code, analyzes why the lock becomes ineffective, and presents solutions such as separating transactional methods, using programmatic transactions, or locking the entire transaction.

JavaLockTransactional
0 likes · 6 min read
Why @Transactional Can Invalidate Locks in Spring and How to Fix It
Nullbody Notes
Nullbody Notes
Aug 10, 2024 · Backend Development

How to Build an Expiring Single-Node Lock in Go

This article explains how to implement a single‑process lock in Go that records an owner, allows only the owner to unlock, and automatically releases the lock after a specified timeout, providing full source code and a walkthrough of the key functions.

GoLockconcurrency
0 likes · 5 min read
How to Build an Expiring Single-Node Lock in Go
Tencent Cloud Developer
Tencent Cloud Developer
Aug 6, 2024 · Backend Development

Nine Common Techniques for Service Performance Optimization

The article outlines nine broadly applicable techniques—caching, parallel and batch processing, data compression, lock‑free design, sharding, eliminating unnecessary requests, and resource pooling—that together can dramatically cut service latency and improve throughput, as demonstrated by an 80% latency reduction in a real‑world project.

Performance OptimizationRediscaching
0 likes · 28 min read
Nine Common Techniques for Service Performance Optimization