BestHub
Sign in
Tagged articles

concurrency

2156 articles · Page 8 of 22
Ops Development & AI Practice
Ops Development & AI Practice
May 10, 2024 · Backend Development

How Go’s Snowflake Library Generates Distributed Unique IDs

This article explains the Snowflake distributed ID algorithm, breaks down the Go implementation in the bwmarrin/snowflake package, and details how initialization, node validation, timestamp handling, and bit‑wise composition work together to produce unique, time‑ordered 64‑bit identifiers in high‑concurrency environments.

Distributed IDSnowflakeconcurrency
0 likes · 10 min read
How Go’s Snowflake Library Generates Distributed Unique IDs
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 10, 2024 · Backend Development

Master Spring Boot 3 Virtual Threads: Prevent Daemon Issues & Keep Apps Alive

This guide explains how Spring Boot 3.2+ leverages JDK 21 virtual threads, demonstrates common pitfalls in non‑web applications—especially daemon thread termination—and shows how to enable keep‑alive configuration to ensure your tasks keep running, complete with code examples and performance insights.

Spring Bootconcurrencykeepalive
0 likes · 9 min read
Master Spring Boot 3 Virtual Threads: Prevent Daemon Issues & Keep Apps Alive
Shepherd Advanced Notes
Shepherd Advanced Notes
May 9, 2024 · Backend Development

How Many Simultaneous Requests Can SpringBoot Handle?

The article explains that SpringBoot’s request capacity is governed by Tomcat’s thread pool and connection settings, derives the formula max‑connections + accept‑count, demonstrates it with a small‑scale experiment, and discusses related concurrency pitfalls in singleton beans.

SpringBootconcurrencyrequest-limiting
0 likes · 8 min read
How Many Simultaneous Requests Can SpringBoot Handle?
Python Programming Learning Circle
Python Programming Learning Circle
May 6, 2024 · Fundamentals

Comprehensive Guide to Python Multiprocessing and Advanced Concurrency Techniques

This article provides an in‑depth overview of Python's multiprocessing module, covering process creation, inter‑process communication, synchronization primitives, error handling, debugging tools, and real‑world project examples to help developers efficiently leverage multi‑core CPUs for CPU‑bound tasks.

Async IOInterprocess CommunicationMultiprocessing
0 likes · 25 min read
Comprehensive Guide to Python Multiprocessing and Advanced Concurrency Techniques
FunTester
FunTester
May 6, 2024 · Backend Development

Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue

This article explains how to solve Java thread‑pool priority problems by leveraging java.util.concurrent.PriorityBlockingQueue, details its thread‑safe and unbounded features, and provides a complete multi‑priority thread‑pool implementation with sample code and a test demonstrating correct task ordering.

Priority SchedulingPriorityBlockingQueueconcurrency
0 likes · 6 min read
Building a Multi‑Priority Thread Pool with Java's PriorityBlockingQueue
Java Captain
Java Captain
May 4, 2024 · Backend Development

Implementing a FIFO Export Queue for Large Data Exports in Java

This article explains how to design and implement a fixed‑size FIFO export queue in a Java Spring application to control concurrent MySQL data exports, detailing the related entities, code implementation with EasyExcel, a test controller, and observed results.

EasyExcelExport Queuebackend
0 likes · 10 min read
Implementing a FIFO Export Queue for Large Data Exports in Java
Architect
Architect
Apr 30, 2024 · Backend Development

Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices

This article explains why asynchronous programming improves performance, compares serial and parallel implementations of a login flow, and demonstrates how to use Java's CompletableFuture API—including supplyAsync, runAsync, callbacks, composition, and error handling—to write efficient backend code.

CompletableFutureasynchronousbackend
0 likes · 22 min read
Using CompletableFuture for Asynchronous Programming in Java: Examples and Best Practices
Su San Talks Tech
Su San Talks Tech
Apr 30, 2024 · Backend Development

Mastering Context Propagation in Thread Pools with TransmittableThreadLocal

This article explains why standard ThreadLocal mechanisms fail with thread pools, introduces the design of a custom solution using YesThreadLocal and YesRunnable, and then details how Alibaba's TransmittableThreadLocal (TTL) implements context capture, replay, and restoration for seamless asynchronous execution.

ContextPropagationThreadLocalTransmittableThreadLocal
0 likes · 12 min read
Mastering Context Propagation in Thread Pools with TransmittableThreadLocal
Architecture Digest
Architecture Digest
Apr 29, 2024 · Backend Development

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

This article explains how to design and implement a fixed-size FIFO export queue in a Spring Boot backend, using synchronized methods, EasyExcel for large data exports, and a test controller to simulate concurrent export requests, while discussing performance considerations and future enhancements.

EasyExcelExport QueueSpring Boot
0 likes · 10 min read
Implementing a FIFO Export Queue in Spring Boot for Large Data Exports
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 28, 2024 · Fundamentals

Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns

This comprehensive guide covers Java's core concepts—including object‑oriented principles, differences from C++, polymorphism, static/final modifiers, abstract classes versus interfaces, generics, reflection, exception hierarchy, key data structures like ArrayList, LinkedList, HashMap, ConcurrentHashMap, serialization, String handling, and essential design patterns such as Singleton, Factory, and Abstract Factory—providing interview‑ready knowledge for developers.

Design PatternsReflectionconcurrency
0 likes · 19 min read
Master Java Fundamentals: OOP, Collections, Concurrency, and Design Patterns
Cognitive Technology Team
Cognitive Technology Team
Apr 25, 2024 · Backend Development

Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?

In Spring Boot, using @Transactional and @Async on the same service method does not invalidate the transaction, but the asynchronous execution runs in a separate thread with its own transaction, isolated from the original thread's transaction due to AOP interceptor ordering.

@TransactionalAOPSpring Boot
0 likes · 1 min read
Alibaba Java Interview: Does annotating the same Spring Boot service method with @Transactional and @Async cause transaction failure?
IT Services Circle
IT Services Circle
Apr 25, 2024 · Backend Development

How Redisson Implements Distributed Locks Using Redis

This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.

DistributedLockLuaRedis
0 likes · 19 min read
How Redisson Implements Distributed Locks Using Redis
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 25, 2024 · Backend Development

Design and Implementation of a Generic Connection Pool in Go (Conecta)

This article explains the motivation, design principles, and implementation details of Conecta, a lightweight, configurable Go library that provides a universal connection pool for various services such as databases, TCP/UDP, and custom connections, complete with extensible callbacks and background health checks.

Backend DevelopmentConnection PoolGo
0 likes · 19 min read
Design and Implementation of a Generic Connection Pool in Go (Conecta)
php Courses
php Courses
Apr 23, 2024 · Backend Development

Using curl_multi_exec() in PHP to Execute Multiple cURL Requests Concurrently

This article introduces PHP’s curl_multi_exec() function, explains its prototype, parameters, return values, provides a complete example for concurrently sending multiple HTTP requests, and outlines important usage considerations for efficient backend network communication.

PHPbackendconcurrency
0 likes · 4 min read
Using curl_multi_exec() in PHP to Execute Multiple cURL Requests Concurrently
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Apr 16, 2024 · Backend Development

Speed Up Spring Startup with Parallel Bean Initialization

This article introduces Spring 6.2’s Parallel Bean Initialization feature, explains its benefits for reducing startup time, provides step‑by‑step code examples for configuring background bean initialization and a bootstrap executor, compares traditional and concurrent initialization timings, and details the underlying implementation in the Spring container.

Backend DevelopmentParallel Bean Initializationconcurrency
0 likes · 7 min read
Speed Up Spring Startup with Parallel Bean Initialization
Ops Development & AI Practice
Ops Development & AI Practice
Apr 15, 2024 · Fundamentals

Mastering Go Concurrency: When to Use WaitGroup vs Mutex

This article examines Go's sync package, detailing how WaitGroup coordinates the completion of multiple goroutines while Mutex protects shared resources, compares their purposes and use cases, and provides practical code examples to help developers choose the right tool for concurrent programming.

GoSynchronizationWaitGroup
0 likes · 5 min read
Mastering Go Concurrency: When to Use WaitGroup vs Mutex
JD Tech
JD Tech
Apr 15, 2024 · Backend Development

How Java Thread Pools Handle Exceptions: execute vs submit

This article investigates how Java's java.util.concurrent.ExecutorService thread pools react to exceptions when tasks are submitted via execute versus submit, providing source‑code experiments, observed outcomes, and a detailed analysis of the underlying JDK implementation.

ExceptionHandlingconcurrencyexecutorservice
0 likes · 8 min read
How Java Thread Pools Handle Exceptions: execute vs submit
Alibaba Cloud Developer
Alibaba Cloud Developer
Apr 15, 2024 · Backend Development

Mastering Java Pitfalls: NPE, Thread Safety, and Performance Best Practices

This article compiles common Java bugs such as NullPointerException, thread‑safety issues, improper exception handling, and performance traps, and provides practical solutions including annotations, Optional, MapStruct, concurrent utilities, immutable objects, proper resource management, and Spring transaction safeguards.

Best PracticesNullPointerExceptionconcurrency
0 likes · 23 min read
Mastering Java Pitfalls: NPE, Thread Safety, and Performance Best Practices
JavaEdge
JavaEdge
Apr 13, 2024 · Backend Development

Mastering System Performance: Metrics, Strategies, and Real‑World Implementation

This article explains why performance optimization is essential for growing systems, introduces key metrics such as response time and concurrency, outlines systematic thinking and concrete techniques—including caching, parallelism, and async processing—and demonstrates a live‑streaming case study with actionable solutions.

CachingMonitoringOptimization
0 likes · 15 min read
Mastering System Performance: Metrics, Strategies, and Real‑World Implementation
IT Services Circle
IT Services Circle
Apr 13, 2024 · Fundamentals

Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis

This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.

HashMapRedisconcurrency
0 likes · 21 min read
Java Interview Questions: Collections, HashMap, Concurrency, JVM Memory, GC, References, and Redis
Python Programming Learning Circle
Python Programming Learning Circle
Apr 11, 2024 · Backend Development

Comprehensive Guide to Downloading Files with Python Using requests, wget, urllib, urllib3, Boto3, asyncio and More

This tutorial explains how to download regular files, web pages, Amazon S3 objects, and other resources in Python by covering multiple modules such as requests, wget, urllib, urllib3, Boto3, and asyncio, and demonstrates handling redirects, large files, parallel downloads, progress bars, proxies, and asynchronous execution.

Boto3File Downloadasyncio
0 likes · 8 min read
Comprehensive Guide to Downloading Files with Python Using requests, wget, urllib, urllib3, Boto3, asyncio and More
Architect's Guide
Architect's Guide
Apr 8, 2024 · Backend Development

Why HikariCP Is So Fast: A Deep Dive into Its Implementation

This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.

Connection PoolHikariCPPerformance
0 likes · 14 min read
Why HikariCP Is So Fast: A Deep Dive into Its Implementation
Deepin Linux
Deepin Linux
Apr 7, 2024 · Backend Development

High‑Performance Development: Core Techniques from I/O Optimization to Distributed Systems

This comprehensive guide covers high‑performance development techniques—including I/O optimization, zero‑copy, multiplexing, concurrency, thread‑pool design, lock‑free programming, inter‑process communication, RPC, serialization, database indexing, caching strategies, Bloom filters, full‑text search, and load balancing—to help developers build fast, scalable, and reliable systems.

CachingI/O optimizationPerformance
0 likes · 62 min read
High‑Performance Development: Core Techniques from I/O Optimization to Distributed Systems
Java Tech Enthusiast
Java Tech Enthusiast
Apr 6, 2024 · Backend Development

Inventory Deduction and Concurrency Control in Backend Systems

The article outlines the three‑step inventory deduction workflow—select, verify, update—and explains how concurrent requests can cause overselling, then compares mitigation strategies such as pessimistic SELECT FOR UPDATE locks, optimistic CAS version retries, atomic decrement SQL statements, and Redis transactions, highlighting their trade‑offs in consistency and throughput.

Inventoryconcurrencyoptimistic lock
0 likes · 5 min read
Inventory Deduction and Concurrency Control in Backend Systems
Ops Development & AI Practice
Ops Development & AI Practice
Apr 5, 2024 · Fundamentals

Mastering Go’s Context: Design Principles, Features, and Real‑World Usage

Go’s Context package provides a simple, standardized way to control goroutine lifecycles, enforce timeouts, cancel operations, and pass request-scoped values, embodying Go’s philosophy of clarity and efficiency; this article outlines its key characteristics, design philosophy, and demonstrates practical HTTP cancellation with code.

ContextGocancellation
0 likes · 6 min read
Mastering Go’s Context: Design Principles, Features, and Real‑World Usage
Java Architect Essentials
Java Architect Essentials
Apr 2, 2024 · Backend Development

Understanding ForkJoinPool: Divide‑and‑Conquer, Implementation Details, and Performance Evaluation in Java

This article explains the Fork/Join model and Java's ForkJoinPool, covering the divide‑and‑conquer algorithm, custom RecursiveTask implementation, core pool design, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing with code examples and practical guidelines.

DivideAndConquerForkJoinPoolPerformance
0 likes · 25 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Implementation Details, and Performance Evaluation in Java
Architect
Architect
Mar 31, 2024 · Backend Development

Common Lock Types in Distributed Systems and Their Java Implementations

This article explains the main lock mechanisms used in concurrent and distributed Java applications—including pessimistic, optimistic, distributed, reentrant, spin, shared, read/write, fair, non‑fair, interruptible, segment, and lock‑upgrade techniques—along with their characteristics, usage scenarios, and sample SQL or Java code snippets.

LocksSynchronizationconcurrency
0 likes · 16 min read
Common Lock Types in Distributed Systems and Their Java Implementations
FunTester
FunTester
Mar 26, 2024 · Backend Development

Building a Simple Java Object Pool with LinkedBlockingQueue and Factory Interface

This article describes how to build a lightweight custom object pool in Java using a LinkedBlockingQueue and a factory interface, detailing its design, implementation, code examples, and a test script that demonstrates borrowing, returning, and size control of pooled objects.

Factory PatternLinkedBlockingQueueObject Pool
0 likes · 7 min read
Building a Simple Java Object Pool with LinkedBlockingQueue and Factory Interface
Java Captain
Java Captain
Mar 25, 2024 · Fundamentals

Understanding Java ThreadLocal: Mechanism, Use Cases, and Best Practices

ThreadLocal in Java provides thread‑local variables by maintaining a per‑thread map, enabling data isolation, simplifying inter‑thread data transfer, and storing context information, while requiring careful handling to avoid memory leaks, thread‑pool contamination, and overuse.

Best PracticesThreadLocalconcurrency
0 likes · 5 min read
Understanding Java ThreadLocal: Mechanism, Use Cases, and Best Practices
Java Captain
Java Captain
Mar 25, 2024 · Fundamentals

Understanding the Underlying Implementation of Java String Immutability

This article explains why Java's String class is immutable, detailing the benefits such as thread safety, cached hash codes, and string pooling, and describes the internal mechanisms—including a private final char array, creation of new objects on concatenation, and the intern method—that enforce this immutability.

Memory managementPerformanceString
0 likes · 5 min read
Understanding the Underlying Implementation of Java String Immutability
IT Services Circle
IT Services Circle
Mar 23, 2024 · Backend Development

Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts

This article compiles a comprehensive Java backend interview guide covering Redis fundamentals, thread creation methods, thread‑pool pitfalls, Spring ecosystem relationships, IoC/AOP principles, shallow vs deep copying, collection cloning, differences between interfaces and abstract classes, and string handling classes, providing concise explanations and code examples for each topic.

Redisbackendconcurrency
0 likes · 19 min read
Java Backend Interview Guide: Redis, Thread Pools, Spring, Concurrency, and Core Java Concepts
Architect's Guide
Architect's Guide
Mar 22, 2024 · Backend Development

Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java

This article explains the Fork/Join model and Java's ForkJoinPool, covering divide‑and‑conquer theory, custom RecursiveTask examples, pool construction options, task submission methods, work‑stealing mechanics, commonPool pitfalls, and performance testing results to help developers decide when to use it.

DivideAndConquerForkJoinPoolPerformance
0 likes · 22 min read
Understanding ForkJoinPool: Principles, Implementation, and Performance Evaluation in Java
Huolala Tech
Huolala Tech
Mar 21, 2024 · Backend Development

How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It

A production incident where a poorly implemented lazy‑loading mechanism for KMSClient caused repeated initialization, blocking threads, exhausting the shared thread pool, and triggering RejectedExecutionException alerts, was investigated step‑by‑step, leading to a concrete code fix, improved monitoring, and better thread‑pool isolation.

KMS clientPerformancebackend debugging
0 likes · 16 min read
How a Faulty Lazy-Loading Design Caused Thread‑Pool Exhaustion and How to Fix It
dbaplus Community
dbaplus Community
Mar 17, 2024 · Backend Development

Designing a Scalable Online Movie Ticket Reservation System

This article presents a comprehensive backend design for an online movie ticketing platform, covering functional and non‑functional requirements, capacity planning, API definitions, database schema, service architecture, concurrency control, fault tolerance, and data partitioning to ensure high availability and scalability.

backendconcurrencyscalability
0 likes · 16 min read
Designing a Scalable Online Movie Ticket Reservation System
Go Development Architecture Practice
Go Development Architecture Practice
Mar 14, 2024 · Backend Development

How to Process One Billion CSV Rows in Go: 9 Optimized Solutions

This article walks through nine progressively faster Go implementations for the One Billion Row Challenge, detailing baseline measurements, map optimizations, custom parsing, integer arithmetic, scanner removal, custom hash tables, and parallel processing that ultimately reduce processing time from 1 minute 45 seconds to under 4 seconds.

1BRCOptimizationPerformance
0 likes · 20 min read
How to Process One Billion CSV Rows in Go: 9 Optimized Solutions
21CTO
21CTO
Mar 14, 2024 · Fundamentals

Will Python Finally Ditch the GIL? Inside the Upcoming 3.13 Changes

The article explains how Python's CPython interpreter is set to make the Global Interpreter Lock optional through PEP 703, detailing the recent merge that adds PYTHON_GIL=0 support, the expected Python 3.13 release date, and the potential impact on concurrency and AI workloads.

GILPEP703Python
0 likes · 5 min read
Will Python Finally Ditch the GIL? Inside the Upcoming 3.13 Changes
Architecture Digest
Architecture Digest
Mar 13, 2024 · Backend Development

Using LMAX Disruptor as a High‑Performance In‑Memory Message Queue in Java

This article introduces the LMAX Disruptor library, explains its core concepts such as RingBuffer, Sequencer and WaitStrategy, and provides a step‑by‑step Java demo—including Maven dependency, model, event factory, handler, manager, service and test code—to build a fast, lock‑free producer‑consumer queue.

Backend DevelopmentDisruptorMessage Queue
0 likes · 10 min read
Using LMAX Disruptor as a High‑Performance In‑Memory Message Queue in Java
Java Architect Essentials
Java Architect Essentials
Mar 11, 2024 · Backend Development

Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring

To prevent performance degradation during large MySQL data exports, this article presents a Java Spring implementation of a bounded FIFO export queue, detailing the ExportQueue class, abstract export handling with EasyExcel, concrete service and controller code, and test results demonstrating queue limits and concurrency considerations.

EasyExcelExportQueue
0 likes · 11 min read
Designing a Bounded FIFO Export Queue for Large MySQL Data Exports in Java Spring
Architect
Architect
Mar 10, 2024 · Backend Development

Build a Redis Distributed Lock in Go from Scratch

This article walks through the problem of implementing a reliable Redis distributed lock in Go, explains the pitfalls of naive SetNx usage, introduces timeout handling and GetSet replacement, provides step‑by‑step Go code, and demonstrates its correctness with a multithreaded test.

Backend DevelopmentDistributed LockGo
0 likes · 11 min read
Build a Redis Distributed Lock in Go from Scratch
Java Captain
Java Captain
Mar 7, 2024 · Backend Development

Applying Java Annotations in Concurrent Programming

This article explores how Java's annotation mechanism, introduced in JDK 5.0, can be leveraged to address concurrency challenges by providing thread-safety, locking, timeout, and asynchronous execution annotations, and discusses their integration with AOP for enhanced thread management and performance.

AOPLockingannotations
0 likes · 5 min read
Applying Java Annotations in Concurrent Programming
Su San Talks Tech
Su San Talks Tech
Mar 7, 2024 · Databases

Master MySQL Locks: Types, Mechanisms, and How to Avoid Deadlocks

This article explains why MySQL uses locks, categorizes lock types from global to row level, details their implementation and commands, and shows how intention, metadata, and auto‑increment locks work while offering strategies to prevent deadlocks and lock contention.

DatabaseInnoDBLocks
0 likes · 13 min read
Master MySQL Locks: Types, Mechanisms, and How to Avoid Deadlocks
MaGe Linux Operations
MaGe Linux Operations
Mar 6, 2024 · Backend Development

Mastering Thread Safety in Python: Locks, Conditions, and More

This article explains thread safety in Python, illustrates race conditions with a shared counter example, and demonstrates how various synchronization primitives—including Lock, RLock, Condition, Event, and Semaphore—can be used to coordinate threads safely and avoid deadlocks.

PythonSynchronizationconcurrency
0 likes · 24 min read
Mastering Thread Safety in Python: Locks, Conditions, and More
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Mar 6, 2024 · Backend Development

Mastering Java 8 CompletableFuture: Async Patterns and Best Practices

This article introduces Java 8's CompletableFuture class, compares it with Future, demonstrates basic Future usage, then explores advanced asynchronous patterns—including CompletionService, chaining, exception handling, combining tasks, and various utility methods—providing code examples and execution results to illustrate each concept.

CompletableFutureFutureconcurrency
0 likes · 15 min read
Mastering Java 8 CompletableFuture: Async Patterns and Best Practices
FunTester
FunTester
Mar 5, 2024 · Backend Development

Building a Lightweight Java Object Pool Without Commons‑Pool2

This article walks through the design and implementation of a simple, thread‑safe object pool in Java using a LinkedBlockingQueue, explains the underlying concepts such as factory pattern and queue trimming, and provides a complete code example with a test script and output analysis.

Object PoolPerformancebackend
0 likes · 7 min read
Building a Lightweight Java Object Pool Without Commons‑Pool2
Go Development Architecture Practice
Go Development Architecture Practice
Mar 4, 2024 · Fundamentals

Rust vs Go: Which Language Should Power Your Next Project?

This article provides a balanced comparison of Rust and Go, examining their shared strengths such as memory safety and compiled binaries, while detailing key differences in performance, simplicity, feature richness, concurrency, safety, and scalability to help developers choose the right language for their needs.

PerformanceRustSafety
0 likes · 10 min read
Rust vs Go: Which Language Should Power Your Next Project?
php Courses
php Courses
Mar 4, 2024 · Backend Development

Using curl_multi_setopt() in PHP to Set Multiple cURL Options

This article explains the PHP curl_multi_setopt() function, its syntax, parameters, common options, and provides a complete example showing how to configure multiple cURL settings for efficient concurrent HTTP requests.

PHPcURLconcurrency
0 likes · 4 min read
Using curl_multi_setopt() in PHP to Set Multiple cURL Options
FunTester
FunTester
Mar 4, 2024 · Backend Development

How to Build a Simple Java Rate Limiter from Scratch

This article explains the concept and benefits of rate limiting, reviews popular Java libraries, and walks through a custom implementation using maps, locks, and atomic counters, complete with full source code and a test script demonstrating a 2‑requests‑per‑2‑seconds policy.

Backend DevelopmentToken Bucketconcurrency
0 likes · 9 min read
How to Build a Simple Java Rate Limiter from Scratch
FunTester
FunTester
Mar 4, 2024 · Backend Development

Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger

This article explains the purpose and benefits of rate limiting, reviews popular Java rate‑limiting libraries, and provides a step‑by‑step guide with complete source code for building a simple, thread‑safe custom rate limiter using maps, ReentrantLock, and AtomicInteger.

Token Bucketconcurrencyjava
0 likes · 9 min read
Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger
Java Captain
Java Captain
Mar 1, 2024 · Backend Development

Using Java Annotations to Solve Concurrency Timing Challenges

The article explains how Java's annotation mechanism, including @ThreadSafe, @NotThreadSafe, @GuardedBy, and @Immutable, can be applied to clarify and manage concurrent behavior, helping developers resolve the timing uncertainties inherent in multithreaded programming.

annotationsconcurrencyjava
0 likes · 5 min read
Using Java Annotations to Solve Concurrency Timing Challenges
Code Ape Tech Column
Code Ape Tech Column
Feb 29, 2024 · Backend Development

Introduction to Disruptor: A High‑Performance Java Message Queue with Full Example

This article introduces the open‑source Disruptor library, explains its core concepts such as Ring Buffer, Sequence, Sequencer and Wait Strategy, and provides a step‑by‑step Java demo—including Maven dependency, event model, handlers, configuration, producer, and test code—to show how to build a fast in‑memory message queue.

Backend DevelopmentDisruptorMessage Queue
0 likes · 11 min read
Introduction to Disruptor: A High‑Performance Java Message Queue with Full Example
Architect Chen
Architect Chen
Feb 23, 2024 · Fundamentals

Mastering Java’s Six Thread States: A Visual Guide

This article explains Java’s six thread states—NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED—using clear diagrams, concise descriptions, and practical code examples to help developers understand how threads transition during execution.

concurrencyprogrammingthread
0 likes · 6 min read
Mastering Java’s Six Thread States: A Visual Guide
37 Interactive Technology Team
37 Interactive Technology Team
Feb 21, 2024 · Fundamentals

Deconstructing Asynchronous Programming

The article breaks down modern asynchronous programming by examining four core models—callbacks, Promises, reactive observer patterns, and message‑driven architectures—explaining their mechanics, pros and cons, and providing JavaScript/Dart examples and system diagrams to help developers master non‑blocking concurrency.

Async/AwaitCallbacksMessage-driven
0 likes · 26 min read
Deconstructing Asynchronous Programming
Programmer DD
Programmer DD
Feb 20, 2024 · Backend Development

How to Throttle Java Virtual Threads with Semaphores for Optimal Throughput

This article explains how to manage the throughput of Java 21 virtual threads by using Executors to create them and applying java.util.concurrent.Semaphore to limit concurrent execution, ensuring efficient and safe concurrency without pooling virtual threads.

Backend DevelopmentSemaphoreconcurrency
0 likes · 4 min read
How to Throttle Java Virtual Threads with Semaphores for Optimal Throughput
Code Ape Tech Column
Code Ape Tech Column
Feb 20, 2024 · Backend Development

Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and its divide‑and‑conquer algorithm, demonstrates custom RecursiveTask implementations with full source code, analyzes ForkJoinPool construction, task submission, work‑stealing, monitoring APIs, commonPool pitfalls, and performance evaluation, providing practical guidance for Java developers.

ForkJoinPoolconcurrencydivide and conquer
0 likes · 24 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java
FunTester
FunTester
Feb 20, 2024 · Backend Development

Deadlock, Livelock, and Thread Starvation in Java Concurrency

This article explains Java concurrency issues such as deadlock, livelock, and thread starvation, demonstrates deadlock examples, discusses prevention techniques like timeouts and lock ordering, and provides an overview of the java.util.concurrent package including executors, locks, semaphores, latches, barriers, and concurrent collections.

DeadlockThread Starvationconcurrency
0 likes · 33 min read
Deadlock, Livelock, and Thread Starvation in Java Concurrency
Architect
Architect
Feb 18, 2024 · Backend Development

How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls

This article explains why distributed locks are needed, outlines Redisson's lock properties, walks through its Lua‑based acquisition, renewal, and release processes, examines master‑slave pitfalls, compares RedLock with Zookeeper, and provides practical code examples for Java developers.

Distributed LockLock MechanismRedis
0 likes · 14 min read
How Redisson Implements Distributed Locks: Deep Dive into Mechanisms and Pitfalls
Su San Talks Tech
Su San Talks Tech
Feb 18, 2024 · Backend Development

Mastering CompletableFuture: From Basics to RocketMQ Integration

This article explains Java's CompletableFuture, its advantages over the traditional Future API, demonstrates common methods with code examples, and shows how RocketMQ leverages CompletableFuture to coordinate asynchronous disk flush and replica synchronization tasks.

CompletableFutureFutureRocketMQ
0 likes · 15 min read
Mastering CompletableFuture: From Basics to RocketMQ Integration
FunTester
FunTester
Feb 18, 2024 · Backend Development

Mastering Java Concurrency: Threads, Synchronization, and Immutable Design

This article provides a step‑by‑step guide to Java concurrency, covering core concepts such as threads, runnables, thread lifecycle, synchronization primitives, wait/notify patterns, volatile variables, ThreadLocal storage, and how to design immutable objects for thread‑safety, all illustrated with concrete code examples and detailed explanations.

ImmutableSynchronizationThreadLocal
0 likes · 17 min read
Mastering Java Concurrency: Threads, Synchronization, and Immutable Design
Su San Talks Tech
Su San Talks Tech
Feb 11, 2024 · Backend Development

How to Retrieve Async Return Values with Java FutureTask?

This article explains how to obtain return values from asynchronous Java methods using FutureTask, covering its AQS foundation, execution flow, get() behavior, and provides concrete source code examples for practical implementation.

AQSAsyncFuture
0 likes · 13 min read
How to Retrieve Async Return Values with Java FutureTask?
Open Source Tech Hub
Open Source Tech Hub
Feb 10, 2024 · Backend Development

How to Use Workerman Timer for Scheduled PHP Tasks

This guide explains how Workerman's Timer runs functions or class methods at set intervals within the same process, showing examples of anonymous‑function timers and configuring timers to run only on specific worker processes.

Timerbackendconcurrency
0 likes · 3 min read
How to Use Workerman Timer for Scheduled PHP Tasks
IT Services Circle
IT Services Circle
Feb 9, 2024 · Fundamentals

Interview Topics: URL Processing, TLS Handshake, TCP Handshake, Page Fault, TCP vs UDP, HTTP Differences, Thread Safety in C++, and Thread‑Pool Implementation

This article reviews common interview questions covering URL request processing, TLS handshake steps, the three‑way TCP handshake and four‑way termination, page‑fault handling, differences between TCP and UDP, HTTP/1.0 vs 1.1, thread‑safety mechanisms in C++, and a hands‑on example of building a thread pool.

C++HTTPOperatingSystem
0 likes · 18 min read
Interview Topics: URL Processing, TLS Handshake, TCP Handshake, Page Fault, TCP vs UDP, HTTP Differences, Thread Safety in C++, and Thread‑Pool Implementation
Architect's Guide
Architect's Guide
Feb 9, 2024 · Backend Development

How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions

This article explains why exceptions from tasks submitted to a Java ThreadPool using submit are not printed, how execute shows them, and presents three practical approaches—try‑catch within the task, a custom Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably obtain and handle those exceptions.

ExceptionHandlingFutureconcurrency
0 likes · 14 min read
How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions
Java Tech Enthusiast
Java Tech Enthusiast
Jan 30, 2024 · Backend Development

Common Intermittent Bugs in Production: Scenarios, Cases, and Prevention

Production teams often face intermittent bugs that slip through local and test environments, typically caused by concurrency issues, cache inconsistencies, mutable shared templates, improper thread‑local cleanup, unsynchronized async tasks, race conditions, and resource failures, so writing thread‑safe code, simulating real traffic, logging clearly, and ensuring graceful shutdowns are essential for prevention.

concurrencyintermittent bugsproduction debugging
0 likes · 14 min read
Common Intermittent Bugs in Production: Scenarios, Cases, and Prevention
21CTO
21CTO
Jan 28, 2024 · Backend Development

How PayPal Processed Billions Daily with 8 VMs Using Go Actors

This article explores how PayPal achieved the processing of billions of daily transactions using only eight virtual machines by adopting an actor‑model architecture built with Go, detailing the underlying challenges, network and resource optimizations, and providing a complete Go code example.

GoPayPalactor-model
0 likes · 11 min read
How PayPal Processed Billions Daily with 8 VMs Using Go Actors
Architect's Guide
Architect's Guide
Jan 27, 2024 · Backend Development

Optimizing Thread Pool Size for CPU‑Bound and I/O‑Bound Tasks in Java

This article explains the differences between CPU‑intensive and I/O‑intensive workloads, provides optimization strategies such as multithreading, caching, and load balancing, and presents Java code examples and formulas for calculating the optimal thread‑pool size based on core count, target CPU utilization, and blocking factors.

CPU BoundI/O Boundconcurrency
0 likes · 12 min read
Optimizing Thread Pool Size for CPU‑Bound and I/O‑Bound Tasks in Java
Java High-Performance Architecture
Java High-Performance Architecture
Jan 24, 2024 · Backend Development

8 Powerful Ways to Implement Asynchronous Execution in Java

Understanding asynchronous execution in Java can dramatically reduce latency for tasks such as sending SMS, emails, or updating data, and this article walks through eight practical implementations—from raw Threads and Futures to Spring @Async, ApplicationEvent, message queues, ThreadUtil, and Guava ListenableFuture—complete with code samples and best‑practice tips.

CompletableFutureGuavaMessageQueue
0 likes · 13 min read
8 Powerful Ways to Implement Asynchronous Execution in Java
Tencent Cloud Developer
Tencent Cloud Developer
Jan 24, 2024 · Backend Development

Understanding the Safety of Redis Distributed Locks and the Redlock Debate

Redis distributed locks require unique identifiers, atomic Lua releases, and TTL refreshes to avoid deadlocks, while the Redlock algorithm adds majority quorum but remains vulnerable to clock drift and client pauses, so critical systems should combine it with fencing tokens or version checks for true safety.

Distributed LockEtcdRedis
0 likes · 36 min read
Understanding the Safety of Redis Distributed Locks and the Redlock Debate
Java Tech Enthusiast
Java Tech Enthusiast
Jan 22, 2024 · Backend Development

Transitioning from Java to Rust: Performance, Concurrency, and Ecosystem Insights

Switching from Java to Rust can shrink binaries from dozens of megabytes to a few kilobytes, cut memory use and latency dramatically, and provide safer, built‑in concurrency and async support, while Java remains attractive for its low learning curve and massive library ecosystem, prompting developers to wrap Rust crates for Java‑like productivity as they adopt Rust long‑term.

Backend DevelopmentPerformanceRust
0 likes · 10 min read
Transitioning from Java to Rust: Performance, Concurrency, and Ecosystem Insights
Selected Java Interview Questions
Selected Java Interview Questions
Jan 22, 2024 · Backend Development

Why HikariCP Is So Fast: An In‑Depth Source Code Exploration

This article examines the design and implementation details of HikariCP—Spring Boot's default JDBC connection pool—explaining how its dual‑pool architecture, FastList collection, custom ConcurrentBag, bytecode‑level optimizations, and efficient connection acquisition and release mechanisms together deliver exceptional performance for Java backend applications.

Connection PoolHikariCPPerformance
0 likes · 14 min read
Why HikariCP Is So Fast: An In‑Depth Source Code Exploration
Alibaba Cloud Developer
Alibaba Cloud Developer
Jan 22, 2024 · Backend Development

Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide

This comprehensive article explains Java thread lifecycle, state transitions, blocking and wake‑up mechanisms, differences between wait and sleep, various ways to create threads, thread‑pool architecture and rejection policies, lock implementations including synchronized, ReentrantLock, optimistic CAS, as well as ThreadLocal, concurrent collections, immutability, and the Java Memory Model, providing practical code examples and optimization tips for robust multithreaded programming.

Synchronizationconcurrencythreadpool
0 likes · 23 min read
Master Java Thread Scheduling, Pools, and Synchronization: A Complete Guide
Selected Java Interview Questions
Selected Java Interview Questions
Jan 15, 2024 · Backend Development

Preventing Inventory Overselling in High‑Concurrency Scenarios: Java, Redis Distributed Lock, MySQL Row Lock, Optimistic Lock, and SQL Solutions

The article analyzes the inventory oversell problem caused by concurrent purchase requests and presents four backend solutions—including a Redis distributed lock, MySQL row lock, optimistic locking with version fields, and conditional SQL updates—illustrated with Java code and SQL examples to ensure data consistency.

Distributed LockRedisconcurrency
0 likes · 10 min read
Preventing Inventory Overselling in High‑Concurrency Scenarios: Java, Redis Distributed Lock, MySQL Row Lock, Optimistic Lock, and SQL Solutions
FunTester
FunTester
Jan 14, 2024 · Backend Development

How to Build a More Flexible Java Phaser: Introducing FunPhaser

This article explains the limitations of java.util.concurrent.Phaser for large‑scale asynchronous tasks, presents a custom FunPhaser implementation that removes the party‑count ceiling, details its design, API, and usage examples, and compares it with the original Phaser approach.

Custom SynchronizerPhaserconcurrency
0 likes · 8 min read
How to Build a More Flexible Java Phaser: Introducing FunPhaser
Test Development Learning Exchange
Test Development Learning Exchange
Jan 14, 2024 · Fundamentals

Python Concurrency Techniques: Threads, Processes, Async, and Pools

This article introduces Python concurrency programming, explaining how to use multithreading, multiprocessing, thread and process pools, async/await, coroutines, and producer‑consumer models with code examples, helping developers improve performance and responsiveness for time‑consuming tasks and concurrent network requests.

Multiprocessingasyncioconcurrency
0 likes · 5 min read
Python Concurrency Techniques: Threads, Processes, Async, and Pools
Architect
Architect
Jan 13, 2024 · Backend Development

Mastering API Retry Strategies in Java: 8 Proven Techniques

This article walks through eight practical ways to implement retry mechanisms for remote API calls in Java, covering simple loops, recursion, Apache HttpClient settings, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries, while highlighting trade‑offs and best‑practice guidelines.

Best PracticesHttpClientResilience4j
0 likes · 18 min read
Mastering API Retry Strategies in Java: 8 Proven Techniques
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jan 12, 2024 · Backend Development

Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development

This article explores Spring 5.3.23’s core utility classes—including ID generators, concurrent LRU cache, concurrency throttling, StopWatch timing, digest calculation, method invocation, reflection helpers, route matching, collection utilities, and placeholder parsing—providing code examples, usage guidelines, and best practices to boost backend development efficiency.

CacheID Generatorconcurrency
0 likes · 12 min read
Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development