BestHub
Sign in
Tagged articles
2077 articles
Page 6 of 21
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.

Backend DevelopmentConcurrencyExecutorService
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.

AQSConcurrencyCondition
0 likes · 30 min read
Unlocking Java’s AQS: A Deep Dive into AbstractQueuedSynchronizer and Concurrency Primitives
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.

ConcurrencyData StructuresGo
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.

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

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

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

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

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

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

Backend DevelopmentConcurrencyHttpAsyncClient
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.

CachingCompletableFutureConcurrency
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 QueueConcurrencyJava
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.

ConcurrencyKernel ArchitectureMemory Management
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.

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

BilibiliConcurrencyOptimistic Lock
0 likes · 10 min read
Concurrency Issues and Race Condition Mitigation in Bilibili's Content Production System
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.

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

ConcurrencyDatabase JargonDatabase Storage
0 likes · 11 min read
Why Modern Databases Prefer LSM Trees Over B‑Trees: Hardware, Workloads, and More
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.

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

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

ConcurrencyJDK21Java
0 likes · 24 min read
Unlock Massive Concurrency with Java Virtual Threads: A Deep Dive
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.

ConcurrencyConcurrentHashMapData Structures
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.

ConcurrencyDivideAndConquerForkJoinPool
0 likes · 28 min read
Understanding ForkJoinPool: Theory, Implementation, and Performance Evaluation
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.

ChannelConcurrencyGo
0 likes · 20 min read
Why Does This Go Code Block? Uncovering Channel and Select Pitfalls
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 TechniquesConcurrencyperformance
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.

ConcurrencyCoroutinesGMP model
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 InsertConcurrencyData Partitioning
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.

Concurrencycommunicationemergent abilities
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.

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

Backend DevelopmentConcurrencyJDK 21
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.

Backend DevelopmentC++Concurrency
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.

Backend DevelopmentConcurrencyData Persistence
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.

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

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

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

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

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

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

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

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

ConcurrencyLinux kernelSO_REUSEPORT
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.

ConcurrencyDecoratorError Handling
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.

ConcurrencyTTLThreadPool
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 VariablesCASConcurrency
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.

Backend DevelopmentCachingConcurrency
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.

ConcurrencyJavaLock
0 likes · 6 min read
Why @Transactional Can Invalidate Locks in Spring and How to Fix It
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.

CachingConcurrencyDistributed Systems
0 likes · 28 min read
Nine Common Techniques for Service Performance Optimization
Java High-Performance Architecture
Java High-Performance Architecture
Aug 4, 2024 · Backend Development

Unlock Java Distributed Locks with Lock4j: Guide & Advanced Tips

This article introduces Lock4j, a Java distributed lock library supporting RedisTemplate, Redisson, and Zookeeper, walks through its key features, dependency setup, configuration, annotation attributes, simple and advanced usage examples, and demonstrates custom executors, key builders, and failure strategies for robust concurrency control.

ConcurrencyJavaLock4j
0 likes · 6 min read
Unlock Java Distributed Locks with Lock4j: Guide & Advanced Tips
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jul 29, 2024 · Frontend Development

Ensuring a Single Token Request Across Multiple API Calls with a repeatOnce Function

This article explains how to prevent multiple simultaneous token requests in a web application by using a custom repeatOnce function that caches the token in localStorage and coordinates pending calls through an event emitter, ensuring only the first request fetches the token while others wait for its result.

ConcurrencyFrontendJavaScript
0 likes · 5 min read
Ensuring a Single Token Request Across Multiple API Calls with a repeatOnce Function
BirdNest Tech Talk
BirdNest Tech Talk
Jul 26, 2024 · Fundamentals

How to Choose Between Rust’s LazyLock, LazyCell, OnceLock, and OnceCell

Rust 1.80 introduces LazyCell and LazyLock, synchronized lazy-initialization primitives that differ from OnceCell and OnceLock in thread safety and built‑in initialization, and this article explains their characteristics, trade‑offs, and provides concrete code examples to help developers select the appropriate type for their use case.

ConcurrencyRustStandard Library
0 likes · 8 min read
How to Choose Between Rust’s LazyLock, LazyCell, OnceLock, and OnceCell
MaGe Linux Operations
MaGe Linux Operations
Jul 25, 2024 · Fundamentals

Unlock Python Multithreading: A Complete Guide to Threads, Locks, and Queues

This article provides a comprehensive overview of Python multithreading, covering basic concepts, the _thread and threading modules, thread creation methods, synchronization primitives like Lock and RLock, thread-local storage, thread pools, and the differences between multithreading and multiprocessing for both CPU‑bound and I/O‑bound workloads.

ConcurrencyLockPython
0 likes · 24 min read
Unlock Python Multithreading: A Complete Guide to Threads, Locks, and Queues
FunTester
FunTester
Jul 24, 2024 · Backend Development

Managing Request Scope, Cancellation, and Timeouts with Go's context Package

This article explains how to use Go's context package for managing request-scoped data, cancellation, deadlines, and timeouts, compares it with Java's ThreadLocal approach, and provides practical code examples for creating contexts, handling goroutine lifecycles, and applying context in network programming.

ConcurrencyGoTimeout
0 likes · 12 min read
Managing Request Scope, Cancellation, and Timeouts with Go's context Package
Su San Talks Tech
Su San Talks Tech
Jul 21, 2024 · Backend Development

8 Effective Retry Strategies for Java APIs

This article presents eight practical retry mechanisms for Java applications—including loop, recursion, HttpClient configuration, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries—along with code examples, configuration snippets, and best‑practice guidelines to help developers handle transient network failures reliably.

Best PracticesConcurrencyHttpClient
0 likes · 17 min read
8 Effective Retry Strategies for Java APIs
Top Architect
Top Architect
Jul 20, 2024 · Backend Development

Understanding ForkJoinPool: Theory, Implementation, and Performance in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool in Java, demonstrates how to implement custom RecursiveTask and RecursiveAction classes with code examples, discusses pool construction, task submission, work‑stealing, monitoring methods, performance testing, and cautions about using the common pool.

ConcurrencyForkJoinPoolJava
0 likes · 29 min read
Understanding ForkJoinPool: Theory, Implementation, and Performance in Java
Architect's Guide
Architect's Guide
Jul 20, 2024 · Backend Development

Spring Controller Scope: Singleton vs Prototype and Concurrency Safety

The article explains that Spring MVC controllers are singleton by default, which makes mutable instance fields unsafe for concurrent requests, demonstrates the issue with sample code, and shows how applying @Scope("prototype") or using ThreadLocal resolves the thread‑safety problem.

ConcurrencyJavaSingleton
0 likes · 4 min read
Spring Controller Scope: Singleton vs Prototype and Concurrency Safety
Code Ape Tech Column
Code Ape Tech Column
Jul 19, 2024 · Backend Development

Common Pitfalls and Best Practices for Using Java Thread Pools

This article summarizes the common pitfalls, monitoring techniques, configuration guidelines, naming conventions, and practical code examples for safely using Java ThreadPoolExecutor, helping developers avoid OOM, deadlocks, and performance issues while optimizing thread‑pool usage.

BestPracticesConcurrencyJava
0 likes · 17 min read
Common Pitfalls and Best Practices for Using Java Thread Pools
Architecture & Thinking
Architecture & Thinking
Jul 19, 2024 · Backend Development

Why Modern Internet Architecture Gets Complex and How to Master Flash‑Sale Systems

The article examines why internet architectures have become increasingly complex, explains the unique challenges of flash‑sale (秒杀) business scenarios, and presents practical backend optimization techniques such as request filtering, Redis caching with atomic operations, ordered queues, data‑layer safeguards, and unit‑based isolation for global deployments.

CachingConcurrencyRedis
0 likes · 9 min read
Why Modern Internet Architecture Gets Complex and How to Master Flash‑Sale Systems
Sohu Tech Products
Sohu Tech Products
Jul 17, 2024 · Backend Development

Java Thread Pool: Working Mechanism, States, and Rejection Policies

Java thread pools efficiently manage and reuse threads by applying a producer‑consumer model, transitioning through RUNNING, SHUTDOWN, STOP, and TERMINATED states, handling task queues, and employing configurable rejection policies such as Abort, CallerRuns, Discard, and DiscardOldest, while improving performance, resource utilization, and stability across web servers, asynchronous processing, and other concurrent workloads, distinct from connection pools which manage database connections.

ConcurrencyJavaJava concurrency
0 likes · 12 min read
Java Thread Pool: Working Mechanism, States, and Rejection Policies
Architect
Architect
Jul 16, 2024 · Backend Development

Design and Implementation of a FIFO Export Queue for Large Data Exports in Java

This article explains how to handle massive MySQL export operations by introducing a fixed‑size FIFO queue, detailing the Java classes ExportQueue, AbstractExport, and ExportImpl, and showing a test controller that demonstrates queue limits, concurrency handling, and future considerations.

ConcurrencyExport QueueFIFO
0 likes · 11 min read
Design and Implementation of a FIFO Export Queue for Large Data Exports in Java
Architect
Architect
Jul 9, 2024 · Backend Development

Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson

This article explains how to implement distributed locks using Redis, starting with a basic SETNX approach, identifying its shortcomings, and then presenting robust solutions such as identifier‑based unlocking, Lua scripts for atomicity, the RedLock algorithm, and Redisson’s advanced features including a watchdog mechanism.

ConcurrencyJavaRedis
0 likes · 19 min read
Mastering Distributed Locks with Redis: From Simple SETNX to RedLock and Redisson
IT Architects Alliance
IT Architects Alliance
Jul 7, 2024 · Backend Development

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

This article presents a comprehensive guide to improving Java backend performance by using parallel processing with CompletableFuture, minimizing transaction scope, applying effective caching strategies, configuring thread pools, reducing object creation, and employing various concurrency controls such as volatile, CAS, and read‑write locks.

ConcurrencyJavaOptimization
0 likes · 34 min read
Java Backend Performance Optimization: Parallel Processing, Thread Pools, Caching, and Concurrency Techniques
JD Tech
JD Tech
Jul 6, 2024 · Backend Development

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

This article details a step‑by‑step investigation of a JSF thread‑pool exhaustion error that occurred when upgrading the Redis version of JD's internal R2M distributed cache, analyzing stack traces, lock contention, ForkJoinPool behavior, and the eventual remediation steps.

ConcurrencyJSFJava
0 likes · 7 min read
Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade
Go Programming World
Go Programming World
Jul 4, 2024 · Fundamentals

Understanding False Sharing and Cache Padding in Go

This article explains the concept of false sharing caused by CPU cache line interactions, demonstrates how cache padding can mitigate the performance penalty, and provides Go benchmark code and results to illustrate the impact on multi‑core concurrency.

ConcurrencyGolangcache padding
0 likes · 8 min read
Understanding False Sharing and Cache Padding in Go
Architect
Architect
Jul 3, 2024 · Backend Development

How to Supercharge Java Backend Performance: Parallelism, Thread Pools, Caching, and More

This article walks through practical Java backend performance techniques—including parallel processing with CompletableFuture, fine‑tuned thread‑pool configuration, transaction scope minimization, cache‑line awareness, object‑pool usage, lock granularity, copy‑on‑write collections, and network payload reduction—backed by concrete code samples, benchmark results, and step‑by‑step analysis of trade‑offs and best practices.

CachingConcurrencyJava
0 likes · 36 min read
How to Supercharge Java Backend Performance: Parallelism, Thread Pools, Caching, and More
Su San Talks Tech
Su San Talks Tech
Jul 2, 2024 · Backend Development

11 Ways to Implement Delayed Tasks in Java – From DelayQueue to Quartz

This article explores eleven practical approaches for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, thread‑pool executors, popular message‑queue solutions such as RocketMQ and RabbitMQ, as well as Redis‑based techniques, Redisson, Netty, Hutool, Quartz, and simple polling implementations.

ConcurrencyDelayed TasksJava
0 likes · 25 min read
11 Ways to Implement Delayed Tasks in Java – From DelayQueue to Quartz
Sanyou's Java Diary
Sanyou's Java Diary
Jul 1, 2024 · Backend Development

11 Ways to Implement Delayed Tasks in Java: From DelayQueue to Quartz

This article explores eleven practical methods for implementing delayed tasks in Java, covering native APIs like DelayQueue and Timer, advanced executors such as ScheduledThreadPoolExecutor, and popular messaging solutions including RocketMQ, RabbitMQ, Redis, Redisson, Netty, Hutool, and Quartz, with code demos and implementation details.

ConcurrencyDelayed TasksMessage Queue
0 likes · 27 min read
11 Ways to Implement Delayed Tasks in Java: From DelayQueue to Quartz
IT Architects Alliance
IT Architects Alliance
Jun 27, 2024 · Backend Development

Understanding ForkJoinPool: Divide‑and‑Conquer, Implementation, and Performance Evaluation

This article explains the Fork/Join model and Java's ForkJoinPool, covering the divide‑and‑conquer algorithm, custom RecursiveTask examples, core source‑code analysis, common pool pitfalls, and performance testing to help developers decide when and how to use ForkJoinPool effectively.

ConcurrencyDivideAndConquerForkJoinPool
0 likes · 27 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Implementation, and Performance Evaluation
21CTO
21CTO
Jun 27, 2024 · Fundamentals

Is Gleam the Friendly Functional Language You’ve Been Waiting For?

This article introduces Gleam, a type‑safe functional language that compiles to Erlang and JavaScript, walks through installation, a hello‑world program, package management, pattern matching with algebraic data types, and demonstrates its concurrency‑friendly, null‑free design.

ConcurrencyErlangFunctional Programming
0 likes · 8 min read
Is Gleam the Friendly Functional Language You’ve Been Waiting For?
Architect
Architect
Jun 26, 2024 · Backend Development

Understanding the Fork/Join Framework and ForkJoinPool 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, provides performance benchmarks, and discusses design details, task submission methods, work‑stealing, and cautions about using the common pool.

ConcurrencyDivideAndConquerForkJoinPool
0 likes · 23 min read
Understanding the Fork/Join Framework and ForkJoinPool in Java
Cognitive Technology Team
Cognitive Technology Team
Jun 23, 2024 · Fundamentals

Understanding Fail-Fast Iterators and ConcurrentModificationException in Java Collections

The article explains why fail‑fast iterators throw ConcurrentModificationException when a collection is modified during iteration, outlines two common scenarios that trigger the exception, and presents both incorrect and correct Java code examples along with strategies such as avoiding modifications, using synchronization, iterator.remove(), or switching to fail‑safe concurrent collections.

CollectionsConcurrencyConcurrentModificationException
0 likes · 5 min read
Understanding Fail-Fast Iterators and ConcurrentModificationException in Java Collections