BestHub
Sign in
Tagged articles
2077 articles
Page 7 of 21
Cognitive Technology Team
Cognitive Technology Team
Jun 23, 2024 · Backend Development

Customizing Thread Pools for Java parallelStream to Improve Performance and Isolation

This article explains how Java's parallelStream uses the shared ForkJoinPool, why developers may need to customize the thread pool for better performance and isolation, and provides two approaches—setting the system property and creating a dedicated ForkJoinPool—along with complete code examples and execution results.

ConcurrencyForkJoinPoolJava
0 likes · 4 min read
Customizing Thread Pools for Java parallelStream to Improve Performance and Isolation
Liangxu Linux
Liangxu Linux
Jun 23, 2024 · Mobile Development

Why Huawei’s New Cangjie Language Could Redefine HarmonyOS App Development

Huawei unveiled the fully self‑developed Cangjie programming language at the 2024 Developer Conference, detailing its native intelligence, full‑scene support, high performance, strong security, multi‑paradigm features, and simple syntax designed specifically for HarmonyOS applications.

CangjieConcurrencyHarmonyOS
0 likes · 9 min read
Why Huawei’s New Cangjie Language Could Redefine HarmonyOS App Development
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Jun 18, 2024 · Backend Development

Graceful Shutdown in Go: Designing Robust Service Termination with the GS Library

This article describes a real‑world incident where rapid pod scaling caused order‑submission failures in a serverless e‑commerce platform, analyzes the root causes, and presents a Go‑based graceful‑shutdown solution—including ASyncClose, SyncClose, and ForceSyncClose modes—implemented in the open‑source GS library to help developers reliably terminate services.

Backend DevelopmentConcurrencyGo
0 likes · 21 min read
Graceful Shutdown in Go: Designing Robust Service Termination with the GS Library
FunTester
FunTester
Jun 17, 2024 · Backend Development

Mastering Java CompletableFuture: Simplify Asynchronous Programming

This article explains how Java's CompletableFuture extends traditional concurrency tools with rich APIs for parallel execution, chaining, error handling, and timeout management, providing clear code examples that demonstrate building maintainable asynchronous applications.

AsynchronousCompletableFutureConcurrency
0 likes · 10 min read
Mastering Java CompletableFuture: Simplify Asynchronous Programming
Code Ape Tech Column
Code Ape Tech Column
Jun 14, 2024 · Databases

Designing an Efficient Import of 1 Billion Records into MySQL: Architecture, Batch Loading, Sharding, and Concurrency Control

This article analyzes how to import one billion 1 KB log records stored in HDFS or S3 into MySQL by evaluating single‑table limits, choosing storage engines, designing sharding, batch insertion, file‑reading strategies, task coordination, and distributed locking to achieve high‑throughput and ordered writes.

Batch InsertConcurrencyMySQL
0 likes · 19 min read
Designing an Efficient Import of 1 Billion Records into MySQL: Architecture, Batch Loading, Sharding, and Concurrency Control
Su San Talks Tech
Su San Talks Tech
Jun 14, 2024 · Backend Development

Master Java ThreadPoolExecutor: Interview Questions & Deep Dive

This article provides a comprehensive guide to Java thread pools, covering common interview questions, core parameters, execution flow, lock mechanisms, custom queue implementations, rejection policies, best practices, monitoring strategies, and dynamic tuning with DynamicTp, all illustrated with code examples and diagrams.

ConcurrencyInterviewJUC
0 likes · 33 min read
Master Java ThreadPoolExecutor: Interview Questions & Deep Dive
Go Development Architecture Practice
Go Development Architecture Practice
Jun 13, 2024 · Fundamentals

Why Is Concurrency So Hard? Uncovering the State‑Space Explosion

The article explores why concurrent programming is notoriously difficult, arguing that the root cause lies not in human cognition but in the combinatorial explosion of possible states and interleavings, and presents heuristics for reducing state space, such as using processes, atomic operations, and language constructs.

ConcurrencyParallel Programmingdistributed-systems
0 likes · 8 min read
Why Is Concurrency So Hard? Uncovering the State‑Space Explosion
MaGe Linux Operations
MaGe Linux Operations
Jun 12, 2024 · Fundamentals

Boost Python Performance: Master Thread Pools vs Process Pools

This guide explains Python's multithreading and multiprocessing concepts, compares thread pools and process pools, provides practical code examples for task execution and file downloading, and offers best‑practice advice for efficient concurrent programming.

ConcurrencyProcessPoolExecutorPython
0 likes · 14 min read
Boost Python Performance: Master Thread Pools vs Process Pools
Cognitive Technology Team
Cognitive Technology Team
Jun 10, 2024 · Backend Development

Gracefully Shutting Down a Thread Pool in Java

To gracefully shut down a Java thread pool, use ExecutorService's shutdown() to reject new tasks, awaitTermination() to wait for running tasks with optional timeout, handle exceptions, and optionally invoke shutdownNow() for forced termination, as illustrated by code examples from Dubbo3 and RocketMQ.

ConcurrencyExecutorServiceGracefulShutdown
0 likes · 4 min read
Gracefully Shutting Down a Thread Pool in Java
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jun 7, 2024 · Fundamentals

Understanding Java CAS and AQS: Unlock Lock-Free Concurrency

This article explains the principles and implementation of Java's Compare-and-Swap (CAS) and AbstractQueuedSynchronizer (AQS), illustrating how CAS enables lock‑free algorithms and how AQS underpins high‑level synchronization constructs like ReentrantLock and CountDownLatch, while also providing practical step‑by‑step examples.

AQSCASConcurrency
0 likes · 5 min read
Understanding Java CAS and AQS: Unlock Lock-Free Concurrency
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 5, 2024 · Databases

Understanding the InnoDB Lock Module Structure

This article explains the structure and components of InnoDB's lock module, including the global lock_sys object, its hash tables, latch mechanisms, waiting thread slots, and related attributes, with detailed code examples and diagrams to illustrate how row and table locks are managed.

ConcurrencyDatabase InternalsInnoDB
0 likes · 15 min read
Understanding the InnoDB Lock Module Structure
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 5, 2024 · Backend Development

Unlock Massive Concurrency: How Java Virtual Threads Transform Backend Development

This article explains Java virtual threads, contrasting them with platform threads, and shows how to create, schedule, and use them effectively with Thread.Builder and Executors to achieve high‑throughput, low‑latency server applications while avoiding common pitfalls like pooling and pinning.

Backend DevelopmentConcurrencyJDK21
0 likes · 14 min read
Unlock Massive Concurrency: How Java Virtual Threads Transform Backend Development
FunTester
FunTester
Jun 4, 2024 · Backend Development

Why FastThreadLocal Beats ThreadLocal in High‑Concurrency Java Apps

This article compares Java's standard ThreadLocal with Netty's FastThreadLocal, explains their internal mechanisms, shows practical code examples, runs a JMH microbenchmark, and discusses performance, memory management, and usage scenarios to help developers choose the right thread‑local storage solution.

ConcurrencyFastThreadLocalJMH
0 likes · 11 min read
Why FastThreadLocal Beats ThreadLocal in High‑Concurrency Java Apps
Open Source Linux
Open Source Linux
Jun 1, 2024 · Fundamentals

Mastering Concurrency and Parallelism in Java: From Basics to Advanced APIs

This article explains the concepts of concurrency, parallelism, and serial execution, describes common multi‑core scheduling algorithms, and demonstrates Java's concurrent programming tools—including Future, Fork/Join, Stream API, and CompletableFuture—through clear code examples and practical guidelines.

CompletableFutureConcurrencyFuture
0 likes · 20 min read
Mastering Concurrency and Parallelism in Java: From Basics to Advanced APIs
Aikesheng Open Source Community
Aikesheng Open Source Community
May 29, 2024 · Databases

Analysis of InnoDB Table and Row Lock Structures in MySQL 8.0.32

This article examines the shared and distinct fields of InnoDB's table‑lock and row‑lock structures in MySQL 8.0.32, explains the layout of the lock_t, lock_table_t and lock_rec_t structs, decodes the type_mode bit‑field, and discusses how InnoDB merges compatible row‑locks using a bitmap memory area.

ConcurrencyDatabase InternalsInnoDB
0 likes · 13 min read
Analysis of InnoDB Table and Row Lock Structures in MySQL 8.0.32
MaGe Linux Operations
MaGe Linux Operations
May 22, 2024 · Backend Development

Why Switch from PHP to Go? Boosting Live‑Streaming Concurrency

The article explains why a backend developer moved from PHP to Go, highlights Go’s popularity and simplicity, and demonstrates how Go’s concurrency primitives like sync.WaitGroup and errgroup can transform serial live‑stream data fetching into parallel execution, drastically reducing request latency.

Backend DevelopmentConcurrencyGo
0 likes · 9 min read
Why Switch from PHP to Go? Boosting Live‑Streaming Concurrency
Lobster Programming
Lobster Programming
May 18, 2024 · Backend Development

How to Prevent Inventory Overselling in High‑Traffic E‑Commerce Systems

This article explains several common technical solutions—locking queues, update‑statement limits, optimistic locking, temporary tables, and Redis pre‑stocking—to prevent inventory overselling, comparing their suitability for different concurrency levels and recommending the best approach for high‑traffic scenarios.

Concurrencyecommerceinventory
0 likes · 5 min read
How to Prevent Inventory Overselling in High‑Traffic E‑Commerce Systems
DaTaobao Tech
DaTaobao Tech
May 13, 2024 · Big Data

Interview Algorithms and System Design: Bloom Filter, TopK, Median, and Concurrency Implementations

The article presents a suite of interview‑style algorithm and system‑design solutions—including Bloom‑filter URL blacklists, hash‑partitioned word frequencies, missing‑number bit arrays, top‑K min‑heap, low‑memory median, short‑URL encoding, Redis user counting, and extensive Java implementations of sorting, singleton, LRU cache, custom thread pools, producer‑consumer models and various FooBar synchronization techniques.

Big DataConcurrencyData Structures
0 likes · 35 min read
Interview Algorithms and System Design: Bloom Filter, TopK, Median, and Concurrency Implementations
macrozheng
macrozheng
May 11, 2024 · Backend Development

When Does @Transactional Commit? Before or After Unlock?

This article explains the timing of Spring's @Transactional commit relative to lock release, analyzes why committing after unlock can cause overselling, shows how to trace the transaction lifecycle in the source code, and offers practical solutions to ensure atomicity in high‑concurrency scenarios.

ConcurrencyDatabaseJava
0 likes · 19 min read
When Does @Transactional Commit? Before or After Unlock?
Su San Talks Tech
Su San Talks Tech
May 11, 2024 · Backend Development

Unlock Ultra‑Fast Java Concurrency with the Disruptor Framework

Disruptor is an open‑source, lock‑free Java framework that uses a ring‑buffer and sequencer to achieve ultra‑high‑throughput, handling millions of events per second, and is employed by projects like LMAX, Storm, Camel, and Log4j2, with detailed concepts, wait strategies, and usage examples.

ConcurrencyDisruptorJava
0 likes · 13 min read
Unlock Ultra‑Fast Java Concurrency with the Disruptor Framework
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.

Concurrencydistributed-idsnowflake
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.

ConcurrencyKeepaliveSpring Boot
0 likes · 9 min read
Master Spring Boot 3 Virtual Threads: Prevent Daemon Issues & Keep Apps Alive
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 IOConcurrencyInterprocess Communication
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.

ConcurrencyJavaPriority Scheduling
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.

ConcurrencyExport QueueJava
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.

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

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

ConcurrencyExport QueueJava
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.

ConcurrencyDesign PatternsGenerics
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.

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

ConcurrencyDistributedLockJava
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 DevelopmentConcurrencyConnection Pool
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.

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

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

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

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

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

Boto3ConcurrencyFile Download
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.

ConcurrencyConnection PoolHikariCP
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.

CachingConcurrencyI/O optimization
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.

ConcurrencyOptimistic Lockinventory
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.

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

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

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

ConcurrencyFactory PatternLinkedBlockingQueue
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 PracticesConcurrencyJava
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.

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

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

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

ConcurrencyJavaKMS client
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.

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

1BRCConcurrencyOptimization
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.

ConcurrencyGILPEP703
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 DevelopmentConcurrencyDisruptor
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.

ConcurrencyExportJava
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 DevelopmentConcurrencyGo
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.

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

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

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

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

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

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

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

ConcurrencyJavaRate Limiting
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.

ConcurrencyJavaannotations
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 DevelopmentConcurrencyDisruptor
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.

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

CallbacksConcurrencyasync/await
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.

ConcurrencyForkJoinPoolJava
0 likes · 24 min read
Understanding ForkJoinPool: Divide‑and‑Conquer, Task Splitting, and Performance in Java