BestHub
Sign in
Tagged articles

Concurrency

2155 articles · Page 6 of 22
Selected Java Interview Questions
Selected Java Interview Questions
Jan 1, 2025 · Backend Development

Understanding Distributed Locks and Robust Implementations with Redis

This article explains the challenges of thread synchronization in distributed systems, introduces the concept of distributed locks, compares common implementations such as Redis, Zookeeper, and databases, and provides robust Java and Lua solutions to ensure atomicity, avoid deadlocks, and support lock renewal.

AtomicityConcurrencyDistributed Lock
0 likes · 14 min read
Understanding Distributed Locks and Robust Implementations with Redis
BirdNest Tech Talk
BirdNest Tech Talk
Jan 1, 2025 · Fundamentals

Master Rust: From Basics to Advanced Concepts in One Comprehensive Guide

This article outlines a Rust programming book that starts with fundamental syntax, variables, and memory management, then progressively explores ownership, lifetimes, error handling, concurrency, async programming, traits, macros, and practical examples, providing code snippets and core concepts for each topic.

Advanced ConceptsConcurrencyFundamentals
0 likes · 16 min read
Master Rust: From Basics to Advanced Concepts in One Comprehensive Guide
FunTester
FunTester
Dec 31, 2024 · Backend Development

Mastering Java ReentrantLock: Blocking, Interruptible, and Timeout Locks Explained

This article explains the Java java.util.concurrent.locks.Lock interface and its ReentrantLock implementation, detailing the advantages of reentrancy, interruptibility, and timeout features, and provides practical code examples for blocking, interruptible, and timed lock acquisition along with best‑practice recommendations.

ConcurrencyLockMultithreading
0 likes · 12 min read
Mastering Java ReentrantLock: Blocking, Interruptible, and Timeout Locks Explained
Go Programming World
Go Programming World
Dec 30, 2024 · Backend Development

Understanding and Using sync.Cond in Go: Source Code Analysis and Practical Examples

This article explains the purpose, internal implementation, and correct usage patterns of Go's sync.Cond concurrency primitive, walks through its source code, demonstrates simple and advanced examples—including a custom concurrent waiting queue—and provides test cases to illustrate its behavior in real-world scenarios.

ConcurrencyQueuecondition variable
0 likes · 20 min read
Understanding and Using sync.Cond in Go: Source Code Analysis and Practical Examples
Architecture Digest
Architecture Digest
Dec 26, 2024 · Backend Development

Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison

This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.

ConcurrencyJavaJava 21
0 likes · 7 min read
Understanding Java 21 Virtual Threads: Basics, Spring Boot Integration, and Performance Comparison
FunTester
FunTester
Dec 26, 2024 · Fundamentals

Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword

This chapter introduces advanced Java multithreading concepts, explaining thread safety, the synchronized keyword, various synchronization techniques, and practical code examples such as object‑level, class‑level, method‑level synchronization and double‑checked locking to help solve concurrency problems in performance testing.

ConcurrencyJavaSynchronization
0 likes · 15 min read
Chapter 2 – Common Java Multithreading Utilities and the synchronized Keyword
Tencent Cloud Developer
Tencent Cloud Developer
Dec 24, 2024 · Backend Development

From Java to Go: Key Differences Every Developer Must Know

This article compares Java and Go across syntax simplicity, type systems, object‑oriented features, pointers, error handling, concurrency, reflection, and community culture, providing concrete code examples and practical insights to help Java developers transition smoothly to Go.

Backend DevelopmentConcurrencyError handling
0 likes · 14 min read
From Java to Go: Key Differences Every Developer Must Know
Radish, Keep Going!
Radish, Keep Going!
Dec 23, 2024 · Backend Development

Speed Up Go Cache Expiration Tests with testing/synctest

This article explains how Go's testing/synctest experiment speeds up cache expiration tests by using a virtual clock and bubble isolation, providing code examples that reduce a five‑second wait to milliseconds while ensuring reliable concurrent test execution.

ConcurrencyTestingUnit Testing
0 likes · 7 min read
Speed Up Go Cache Expiration Tests with testing/synctest
JD Cloud Developers
JD Cloud Developers
Dec 23, 2024 · Backend Development

How to Add Asynchronous Timeout to CompletableFuture in JDK 8

This article explains why JDK 8's CompletableFuture lacks built‑in timeout interruption, analyzes common usage patterns and their limitations, and presents a custom asynchronous timeout solution that works in both JDK 8 and JDK 9 environments, complete with reusable utility code.

Async TimeoutBackend DevelopmentCompletableFuture
0 likes · 13 min read
How to Add Asynchronous Timeout to CompletableFuture in JDK 8
Alibaba Cloud Developer
Alibaba Cloud Developer
Dec 23, 2024 · Backend Development

Unlocking High‑Performance C++ Concurrency: Memory Model, Atomics, and Lock‑Free Techniques

This article explains C++11’s memory model and atomic types, demonstrating how lock‑free concurrency, memory ordering, and synchronization primitives such as fences can be used to achieve high‑performance, race‑free multithreaded code for demanding backend systems like game servers.

C++ConcurrencyLock-Free Programming
0 likes · 26 min read
Unlocking High‑Performance C++ Concurrency: Memory Model, Atomics, and Lock‑Free Techniques
Java Tech Enthusiast
Java Tech Enthusiast
Dec 22, 2024 · Backend Development

Common Java ThreadPool Pitfalls and How to Avoid Them

Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.

Best PracticesConcurrencyJava
0 likes · 8 min read
Common Java ThreadPool Pitfalls and How to Avoid Them
macrozheng
macrozheng
Dec 20, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common mistakes when using Java thread pools—such as unbounded queues, wrong thread counts, missing shutdown, and ignored exceptions—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

Best PracticesConcurrencyJava
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
FunTester
FunTester
Dec 19, 2024 · Backend Development

Mastering Custom Thread Pools: Choosing the Right Queue in Java

This article walks through Java thread‑pool queue options—LinkedBlockingQueue, SynchronousQueue, LinkedBlockingDeque, and PriorityBlockingQueue—explaining their characteristics, demonstrating code examples, and showing how to build multi‑priority executors with concrete output analysis.

BlockingQueueConcurrencyJava
0 likes · 12 min read
Mastering Custom Thread Pools: Choosing the Right Queue in Java
JD Tech Talk
JD Tech Talk
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article experimentally compares how a Java ExecutorService thread pool reacts to uncaught exceptions when tasks are submitted via execute versus submit, showing that execute removes the faulty thread and creates a new one while submit retains the thread and stores the exception in a Future.

ConcurrencyExecutorServiceJava
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
JD Cloud Developers
JD Cloud Developers
Dec 17, 2024 · Backend Development

What Happens When a Thread in a Java ThreadPool Throws an Exception?

This article examines how Java's ExecutorService thread pool reacts when a task throws an uncaught exception, comparing the behaviors of execute and submit methods, analyzing source code, and summarizing the impact on thread removal, creation, and exception retrieval.

ConcurrencyExceptionHandlingExecutorService
0 likes · 7 min read
What Happens When a Thread in a Java ThreadPool Throws an Exception?
FunTester
FunTester
Dec 17, 2024 · Backend Development

Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques

This article examines why uncaught exceptions in Java thread pools cause runaway thread creation, then walks through five concrete strategies—try‑catch wrappers, Callable, afterExecute overrides, custom ThreadFactory, and a global default handler—each illustrated with runnable code and detailed analysis.

Backend DevelopmentConcurrencyJava
0 likes · 13 min read
Mastering ThreadPool Exception Handling in Java: 5 Proven Techniques
BirdNest Tech Talk
BirdNest Tech Talk
Dec 16, 2024 · Backend Development

Five Ways to Build a Broadcast Notifier in Go

This article examines five Go implementations of a broadcast notifier—using sync.Cond, channels, context, sync.WaitGroup, and sync.RWMutex—detailing their code, execution flow, and trade‑offs so readers can understand how each primitive achieves notification broadcasting.

ConcurrencyContextbroadcast
0 likes · 9 min read
Five Ways to Build a Broadcast Notifier in Go
Su San Talks Tech
Su San Talks Tech
Dec 14, 2024 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

This article explains the limitations of Java's Future, introduces CompletableFuture with its rich API for non‑blocking asynchronous programming, demonstrates practical usage including task creation, result retrieval, chaining, exception handling, and shows how RocketMQ leverages CompletableFuture to coordinate disk flush and replica sync tasks efficiently.

CompletableFutureConcurrencyFuture
0 likes · 16 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
macrozheng
macrozheng
Dec 13, 2024 · Backend Development

How to Implement a FIFO Export Queue in Spring Boot to Prevent Performance Bottlenecks

To avoid performance degradation caused by simultaneous large‑scale data exports, this guide demonstrates building a fixed‑size FIFO export queue in Spring Boot, integrating EasyExcel for million‑row exports, handling asynchronous processing, and providing sample code for the queue, export service, and controller.

ConcurrencyEasyExcelExport Queue
0 likes · 12 min read
How to Implement a FIFO Export Queue in Spring Boot to Prevent Performance Bottlenecks
Su San Talks Tech
Su San Talks Tech
Dec 13, 2024 · Backend Development

Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance

This article explains ten common Java thread‑pool pitfalls—such as using Executors shortcuts, misconfiguring thread counts, ignoring queue choices, and neglecting shutdown or monitoring—and provides concrete code examples and best‑practice solutions to help developers write safer, more efficient concurrent code.

Best PracticesConcurrencyJava
0 likes · 10 min read
Avoid the Top 10 Java ThreadPool Pitfalls and Boost Performance
Java Tech Enthusiast
Java Tech Enthusiast
Dec 12, 2024 · Backend Development

Java CompletableFuture: Asynchronous Programming Guide

Java's CompletableFuture, introduced in Java 8, replaces the blocking Future with a rich, non‑blocking API that supports asynchronous task creation, result retrieval via get/join, chaining callbacks, exception handling, task combination (AND/OR, allOf/anyOf), and recommends custom executors, timeouts, and proper saturation policies.

Best PracticesCompletableFutureConcurrency
0 likes · 16 min read
Java CompletableFuture: Asynchronous Programming Guide
Programmer XiaoFu
Programmer XiaoFu
Dec 12, 2024 · Backend Development

4 Elegant Ways to Transfer Data Between Async Threads in Spring Boot

The article compares four techniques—manual ThreadLocal copying, TaskDecorator, InheritableThreadLocal, and Alibaba's TransmittableThreadLocal—for passing user context and other data from parent to child threads in Spring Boot async execution, recommending the TaskDecorator and TransmittableThreadLocal approaches for production use.

ConcurrencyJavaSpring Boot
0 likes · 13 min read
4 Elegant Ways to Transfer Data Between Async Threads in Spring Boot
php Courses
php Courses
Dec 11, 2024 · Backend Development

Debunking Common Misconceptions About PHP

This article systematically dispels ten widespread myths about PHP—covering threading, project scale, security, modern relevance, usage scope, code quality, performance, object‑oriented support, learning depth, and scalability—showing that modern PHP remains a powerful, secure, and versatile backend technology.

ConcurrencyPHPPerformance
0 likes · 8 min read
Debunking Common Misconceptions About PHP
Architecture Digest
Architecture Digest
Dec 10, 2024 · Backend Development

Understanding Java Virtual Threads and Their Use in Spring Boot

This article explains Java 21's virtual threads, their lightweight and high‑concurrency advantages, demonstrates basic creation and Spring Boot integration, compares performance against traditional threads, and offers additional Java performance optimization techniques.

ConcurrencyJavaJava 21
0 likes · 7 min read
Understanding Java Virtual Threads and Their Use in Spring Boot
Java Tech Enthusiast
Java Tech Enthusiast
Dec 10, 2024 · Backend Development

Implementing a FIFO Export Queue in Spring Boot for Large Data Exports

The article demonstrates how to implement a bounded FIFO export queue in a Spring Boot application, using synchronized wait/notify methods to limit concurrent large‑data exports to ten threads, integrating with an abstract EasyExcel exporter and a controller that spawns export tasks, while noting future enhancements such as persistent storage and Redis‑based queues.

ConcurrencyEasyExcelExport Queue
0 likes · 11 min read
Implementing a FIFO Export Queue in Spring Boot for Large Data Exports
Go Programming World
Go Programming World
Dec 10, 2024 · Backend Development

Deep Dive into Go's Context Package: Design, Implementation, and Usage

This article thoroughly explains the design and implementation of Go's context package, covering its core interfaces, various concrete types, cancellation propagation, deadline handling, value storage, and the internal mechanisms that enable concurrent-safe control flow and data passing across context trees.

ConcurrencyContextcancellation
0 likes · 30 min read
Deep Dive into Go's Context Package: Design, Implementation, and Usage
FunTester
FunTester
Dec 4, 2024 · Backend Development

Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools

This article explains why the standard Executors factory methods may be insufficient, details each ThreadPoolExecutor constructor parameter, demonstrates how to configure a custom pool for performance testing, and walks through multiple code examples that illustrate thread creation, queue behavior, and rejection policies.

ConcurrencyJavaJava concurrency
0 likes · 14 min read
Mastering Custom ThreadPoolExecutor: Build Flexible Java Thread Pools
Zhuanzhuan Tech
Zhuanzhuan Tech
Dec 2, 2024 · Fundamentals

Understanding Fair and Unfair Locks in Java's ReentrantLock

This article explains the concepts, creation methods, usage examples, and internal implementation details of fair and unfair locks in Java's ReentrantLock, comparing their performance characteristics and providing guidance on when to choose each type in multithreaded applications.

ConcurrencyFairLockJava
0 likes · 23 min read
Understanding Fair and Unfair Locks in Java's ReentrantLock
php Courses
php Courses
Dec 2, 2024 · Backend Development

Understanding PHP 8.1 Fibers: How They Work and Their Limitations

This article explains PHP 8.1 Fibers, describing their cooperative multitasking mechanism, how suspension and resumption affect the main script, why they do not provide true asynchronous execution, and how they can be combined with event loops for more efficient non‑blocking code in backend development.

ConcurrencyFibersPHP
0 likes · 7 min read
Understanding PHP 8.1 Fibers: How They Work and Their Limitations
FunTester
FunTester
Dec 2, 2024 · Fundamentals

Mastering Java Thread Pools: Fixed vs. Cached Executors Explained

This article explains Java thread pools, their performance benefits, and how to create and use FixedThreadPool and CachedThreadPool via the Executors utility, providing code examples, execution results, and guidance on selecting the appropriate pool for different concurrency scenarios.

CachedThreadPoolConcurrencyExecutorService
0 likes · 12 min read
Mastering Java Thread Pools: Fixed vs. Cached Executors Explained
JD Cloud Developers
JD Cloud Developers
Nov 29, 2024 · Mobile Development

Cangjie for HarmonyOS: Fast Setup, Key Features, and ArkTS Interop

This article introduces Cangjie, a lightweight, high‑performance programming language for HarmonyOS, detailing its core advantages, rapid environment configuration, distinctive language features such as flow expressions, lightweight threads, extensions, synchronization primitives, and demonstrates seamless interoperation with ArkTS, concluding with future development outlook.

CangjieConcurrencyHarmonyOS
0 likes · 13 min read
Cangjie for HarmonyOS: Fast Setup, Key Features, and ArkTS Interop
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.

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

ConcurrencyDatabase InternalsInnoDB
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.

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

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

ConcurrencyMemory managementOS fundamentals
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.

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

Best PracticesConcurrencyJava
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.

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

ConcurrencyGarbage CollectionMemory 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 architectureConcurrencyLinux kernel
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.

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

ConcurrencyECMAScriptJavaScript
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 SheetConcurrencyDesign Patterns
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.

ConcurrencyDatabaseDistributed Lock
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.

ConcurrencyJavaLocks
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 MergingConcurrencyEasyExcel
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 MergingConcurrencyEasyExcel
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.

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

ConcurrencyLoggingasyncio
0 likes · 8 min read
Fundamental and Advanced Exception Handling in Python
Senior Tony
Senior Tony
Oct 24, 2024 · Backend Development

Why Java Still Needs Lock: Beyond synchronized with Non‑Blocking, Fair, and Read‑Write Features

This article explains why Java’s Lock interface is still needed despite synchronized, covering non‑blocking tryLock, timed lock acquisition, interruptible locking, fair versus non‑fair locks, read‑write locks, and Condition objects, with code samples and execution logs illustrating each feature.

Backend DevelopmentConcurrencyJava
0 likes · 14 min read
Why Java Still Needs Lock: Beyond synchronized with Non‑Blocking, Fair, and Read‑Write Features
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 StructuresScheduler
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.

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

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

ConcurrencyMemory managementkernel architecture
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.

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

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

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

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

ConcurrencyRustcloud-native
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.

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

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

ConcurrencyDivideAndConquerForkJoinPool
0 likes · 28 min read
Understanding ForkJoinPool: Theory, Implementation, and Performance Evaluation