BestHub
Sign in
Tagged articles

concurrency

2234 articles · Page 9 of 23
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.

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

JavaLocksconcurrency
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 PatternLinkedBlockingQueueconcurrency
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.

JavaThreadLocalbest practices
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.

ImmutabilityJavaMemory Management
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.

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

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

JavaKMS clientPerformance
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.

System Designbackendconcurrency
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.

1BRCHash TableOptimization
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.

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

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

GoRedisbackend development
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.

AOPJavaThread Safety
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.

PythonThread Safetyconcurrency
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.

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

Design PatternJavaPerformance
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.

Language comparisonPerformanceRust
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.

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

Javabackend developmentconcurrency
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.

Javaconcurrencyrate limiting
0 likes · 9 min read
Implementing Custom Rate Limiting in Java with ReentrantLock and AtomicInteger
Nullbody Notes
Nullbody Notes
Mar 3, 2024 · Backend Development

Understanding Go’s Context Package: Essential Insights for Interviews

The article walks through Go’s context package, explaining how Context objects enable cancellation and timeout control in concurrent workflows, detailing the implementations of emptyCtx, cancelCtx, timerCtx, and valueCtx, and providing concrete code examples and internal mechanics.

Gocancellationconcurrency
0 likes · 19 min read
Understanding Go’s Context Package: Essential Insights for Interviews
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.

JavaThread Safetyannotations
0 likes · 5 min read
Using Java Annotations to Solve Concurrency Timing Challenges
Nullbody Notes
Nullbody Notes
Feb 29, 2024 · Backend Development

Implementing Parallel Computation in Go with a Custom MapReduce Framework

The article explains why parallel RPC calls are needed for assembling complex objects, introduces a Go‑based MapReduce framework, walks through concrete code examples for product detail retrieval and UID cleaning, and details the internal architecture—including generate, mapper, reducer, and cancellation mechanisms—while providing full source snippets and execution flow.

GoMapReduceParallel Computing
0 likes · 10 min read
Implementing Parallel Computation in Go with a Custom MapReduce Framework
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.

DisruptorJavaMessage 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/AwaitAsynchronous ProgrammingMessage-driven
0 likes · 26 min read
Deconstructing Asynchronous Programming
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.

Divide and ConquerForkJoinPoolJava
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.

DeadlockJavaJava Util Concurrent
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.

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

Asynchronous ProgrammingCompletableFutureFuture
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.

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

Scheduled Tasksbackendconcurrency
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++NetworkingOperatingSystem
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.

ExceptionHandlingFutureJava
0 likes · 14 min read
How to Capture Exceptions from Java ThreadPool Tasks: submit vs execute and Three Solutions
Nullbody Notes
Nullbody Notes
Feb 6, 2024 · Backend Development

A Minimal 70-Line Go Coroutine Pool: Simple and Elegant

This article presents a concise 70‑line Go implementation of a coroutine pool, explaining its design, how it manages task queues and worker goroutines, handles timeouts, and provides the full source code for easy integration.

Goconcurrencycoroutine pool
0 likes · 5 min read
A Minimal 70-Line Go Coroutine Pool: Simple and Elegant
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.

Thread Safetyconcurrencyintermittent bugs
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 BoundJava
0 likes · 12 min read
Optimizing Thread Pool Size for CPU‑Bound and I/O‑Bound Tasks in Java
Nullbody Notes
Nullbody Notes
Jan 25, 2024 · Backend Development

Building a Redis Connection Pool in Go: Design and Implementation

This article walks through the design and Go implementation of a reusable Redis connection pool, covering the pool data structure, object acquisition and release logic, handling of active limits and waiting queues, and an extended per‑IP socket pool for distributed Redis clusters.

GoRedisSocket
0 likes · 10 min read
Building a Redis Connection Pool in Go: Design and Implementation
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.

AsynchronousCompletableFutureGuava
0 likes · 13 min read
8 Powerful Ways to Implement Asynchronous Execution in Java
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.

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

HikariCPJavaPerformance
0 likes · 14 min read
Why HikariCP Is So Fast: An In‑Depth Source Code Exploration
LouZai
LouZai
Jan 22, 2024 · Backend Development

8 Interface Retry Mechanisms – Which One Should You Choose?

This article compares eight ways to implement retry logic for remote API calls—including simple loops, recursion, Apache HttpClient settings, Spring Retry, Resilience4j, a custom utility, thread‑pool asynchronous retries, and message‑queue based retries—while outlining best‑practice guidelines such as idempotency, retry limits, and concurrency control.

HTTP clientJavaMessage Queue
0 likes · 17 min read
8 Interface Retry Mechanisms – Which One Should You Choose?
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.

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

JavaRedisconcurrency
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 SynchronizerJavaPhaser
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.

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

HttpClientJavaResilience4j
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 GeneratorJava
0 likes · 12 min read
Unlock Spring’s Hidden Power: Essential Utility Classes for Faster Backend Development
MaGe Linux Operations
MaGe Linux Operations
Jan 7, 2024 · Backend Development

How Zookeeper Guarantees Reliable Session Management with Heartbeats

This article explains Zookeeper's session management mechanism, detailing why TCP alone is insufficient for client liveness detection, how Zookeeper implements its own heartbeat protocol, and the internal data structures and algorithms—including expiryMap and SessionTracker—that efficiently track and expire sessions.

HeartbeatJavaSession management
0 likes · 12 min read
How Zookeeper Guarantees Reliable Session Management with Heartbeats
Shepherd Advanced Notes
Shepherd Advanced Notes
Jan 5, 2024 · Fundamentals

Master Java Collections: Avoid Common Pitfalls in Real-World Development

This article provides a comprehensive overview of the Java Collections Framework, explains frequent mistakes such as modifying collections during iteration or using toMap with null values, and introduces practical utility libraries like Hutool, Apache Commons Collections, and Guava to help developers write safer and more efficient code.

Apache CommonsCollectionsGuava
0 likes · 16 min read
Master Java Collections: Avoid Common Pitfalls in Real-World Development
php Courses
php Courses
Jan 4, 2024 · Backend Development

Using Swoole Coroutines to Achieve High Concurrency in PHP Applications

This article explains how to boost PHP application performance by installing the Swoole extension and using its coroutine API to run concurrent tasks such as HTTP requests and database queries, providing code examples and configuration steps for effective backend concurrency.

CoroutinesPHPSwoole
0 likes · 4 min read
Using Swoole Coroutines to Achieve High Concurrency in PHP Applications
FunTester
FunTester
Jan 3, 2024 · Backend Development

Design and Implementation of a Java Virtual Thread Asynchronous Task Framework

This article introduces a Java virtual‑thread based asynchronous task framework, detailing its design constraints, a thread‑safe task queue, daemon thread management, and overloaded execute methods for Runnable and Groovy Closure, along with code examples and performance testing considerations.

Daemon ThreadJavaTask queue
0 likes · 9 min read
Design and Implementation of a Java Virtual Thread Asynchronous Task Framework
Nullbody Notes
Nullbody Notes
Dec 30, 2023 · Backend Development

Building a Simple In-Memory Redis Clone with Go

This article walks through the third part of an eleven‑article series that implements a functional Redis‑compatible in‑memory database in Go, detailing how the PING, AUTH, SELECT, SET and GET commands are parsed, routed and executed with concrete code examples.

Data StructuresGoIn-Memory Database
0 likes · 12 min read
Building a Simple In-Memory Redis Clone with Go
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Dec 26, 2023 · Backend Development

Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations

This article introduces Java thread pools, explaining their purpose, creation using ThreadPoolExecutor, execution flow, advantages such as resource reuse and management, common blocking queues, rejection policies, and provides multiple code examples of various pool types and a comprehensive monitoring example.

BlockingQueueJavaRejectionPolicy
0 likes · 11 min read
Understanding Java Thread Pools: Creation, Execution Flow, Advantages, and Common Implementations
IT Niuke
IT Niuke
Dec 24, 2023 · Fundamentals

Unveiling HashMap's Inner Mechanics: Design, Source Code Walkthrough, and Best Practices

This article dissects Java's HashMap by first explaining the collection framework's design goals—generality, scalability, performance, interoperability, readability, and thread safety—then walks through the core source code of HashMap (hash, put, resize, get, remove, treeify, etc.), illustrates LRU cache implementation, and finally offers practical usage tips, performance considerations, and version‑specific changes up to JDK 9.

Data StructuresHashMapJDK
0 likes · 28 min read
Unveiling HashMap's Inner Mechanics: Design, Source Code Walkthrough, and Best Practices
IT Services Circle
IT Services Circle
Dec 23, 2023 · Fundamentals

Java Multithreading: Processes, Threads, Creation Methods, and Common Controls

This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.

JavaRunnablecallable
0 likes · 9 min read
Java Multithreading: Processes, Threads, Creation Methods, and Common Controls
IT Services Circle
IT Services Circle
Dec 21, 2023 · Backend Development

Comprehensive Backend Interview Guide: MySQL, Redis, Java Collections, Concurrency, and TCP

This article compiles essential backend interview questions and answers covering MySQL storage engines and indexes, Redis persistence modes, Java collection frameworks and HashMap internals, thread‑safe ConcurrentHashMap implementations, as well as HTTP message structure and TCP reliability mechanisms, providing a thorough review for candidates preparing for backend positions.

InterviewJavaMySQL
0 likes · 26 min read
Comprehensive Backend Interview Guide: MySQL, Redis, Java Collections, Concurrency, and TCP
Java Captain
Java Captain
Dec 19, 2023 · Fundamentals

An Introduction to Java Multithreading: Basics, Techniques, and Applications

This article introduces Java multithreading, covering core concepts such as thread lifecycle, creation via Thread subclass and Runnable, synchronization mechanisms, thread pools, and practical applications in web, Android, game, and big data development, helping readers fully grasp multithreaded programming in Java.

JavaProgramming FundamentalsThreadPool
0 likes · 4 min read
An Introduction to Java Multithreading: Basics, Techniques, and Applications
FunTester
FunTester
Dec 12, 2023 · Backend Development

Understanding ResultSet Resource Release and Statement Concurrency in MySQL JDBC

This article examines how MySQL's JDBC driver manages ResultSet resource release, the internal close mechanisms, and the concurrency limitations of Statement objects, illustrated with code excerpts and a Groovy virtual‑thread demo that reveals runtime exceptions when ResultSets are accessed after implicit closure.

JDBCJavaMySQL
0 likes · 8 min read
Understanding ResultSet Resource Release and Statement Concurrency in MySQL JDBC
Nullbody Notes
Nullbody Notes
Dec 12, 2023 · Backend Development

Build a High‑Performance Go Cache Library (EasyCache) from Scratch

This article walks through implementing EasyCache, a Go‑based in‑memory cache with sharding, lock‑free concurrency, LRU eviction, and configurable expiration, explaining the underlying data structures, goroutine cleanup logic, and key handling with concrete code examples.

CacheGoLRU
0 likes · 9 min read
Build a High‑Performance Go Cache Library (EasyCache) from Scratch
macrozheng
macrozheng
Dec 12, 2023 · Backend Development

Mastering Retry Strategies in Java: 8 Proven Methods for Reliable API Calls

This article explains why retry mechanisms are essential for distributed Java applications and walks through eight practical implementations—including loop, recursion, Apache HttpClient, Spring Retry, Resilience4j, custom utilities, asynchronous thread‑pool retries, and message‑queue based retries—plus best‑practice guidelines to avoid common pitfalls.

HttpClientJavaResilience4j
0 likes · 17 min read
Mastering Retry Strategies in Java: 8 Proven Methods for Reliable API Calls
ITPUB
ITPUB
Dec 11, 2023 · Backend Development

Go vs Rust in 2024: Which Language Should Power Your Projects?

This article compares Go and Rust across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers decide which language best fits their specific project requirements in 2024.

GoLanguage comparisonPerformance
0 likes · 12 min read
Go vs Rust in 2024: Which Language Should Power Your Projects?
Bitu Technology
Bitu Technology
Dec 8, 2023 · Backend Development

Why Every Java Developer Should Learn Scala – Key Advantages and Insights from the Scala Meetup

The article reviews a Scala meetup where experts compare Java and Scala, highlighting Scala's stronger expressiveness, type inference, pattern matching, safety, and concurrency features, and discusses real‑world adoption, developer experiences, and a recruitment opportunity for a Scala‑focused big‑data team.

Big DataFunctional ProgrammingJava
0 likes · 13 min read
Why Every Java Developer Should Learn Scala – Key Advantages and Insights from the Scala Meetup
360 Smart Cloud
360 Smart Cloud
Dec 7, 2023 · Fundamentals

Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development

This article explains how asynchronous programming and event‑driven mechanisms work in both frontend JavaScript and backend Golang, covering the JavaScript event loop, macro‑ and micro‑tasks, goroutine‑based concurrency, and the kernel‑level epoll architecture that together enable efficient, non‑blocking execution.

Asynchronousbackendconcurrency
0 likes · 17 min read
Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development
Senior Brother's Insights
Senior Brother's Insights
Dec 3, 2023 · Backend Development

Rust vs Go in 2024: Which Language Wins Your Next Project?

This article compares Rust and Go across performance, concurrency, memory safety, development speed, and developer experience, highlighting each language's strengths and weaknesses to help developers choose the most suitable language for their 2024 projects.

GoLanguage comparisonRust
0 likes · 13 min read
Rust vs Go in 2024: Which Language Wins Your Next Project?
IT Services Circle
IT Services Circle
Nov 28, 2023 · Backend Development

Comprehensive Java Interview Guide: Basics, Collections, Concurrency, Spring Boot, MySQL, and Network Concepts

This article provides a thorough overview of Java interview topics, covering core language fundamentals, collection frameworks, concurrency mechanisms, Spring Boot transaction handling, database indexing strategies, and network protocol comparisons, all presented in clear English with code examples and diagrams.

InterviewJavaMySQL
0 likes · 19 min read
Comprehensive Java Interview Guide: Basics, Collections, Concurrency, Spring Boot, MySQL, and Network Concepts
Nullbody Notes
Nullbody Notes
Nov 27, 2023 · Backend Development

Build a Simple Go RPC Framework – A Beginner-Friendly Project

This article walks Go beginners through designing and implementing a lightweight RPC framework called easyrpc, covering protocol design, message serialization, network communication, graceful server shutdown, client stub generation with reflect.MakeFunc, and concurrent request handling, with full source code on GitHub.

Code ExampleGoRPC
0 likes · 16 min read
Build a Simple Go RPC Framework – A Beginner-Friendly Project
Test Development Learning Exchange
Test Development Learning Exchange
Nov 23, 2023 · Backend Development

Python Multithreading Techniques for Concurrent API Calls, File Downloads, Test Execution, and Database Inserts

This article explains Python's multithreading model, covering thread creation, synchronization, data sharing, and provides practical code examples for sending concurrent API requests, downloading files, running test cases, reading files, and inserting records into a SQLite database.

APIDatabaseFile Download
0 likes · 6 min read
Python Multithreading Techniques for Concurrent API Calls, File Downloads, Test Execution, and Database Inserts