BestHub
Sign in
Tagged articles

concurrency

2269 articles · Page 8 of 23
Code Farming
Code Farming
Sep 14, 2024 · Backend Development

How RocketMQ Handles Concurrency: Deep Dive into Its Design Principles

This article dissects RocketMQ's concurrency mechanisms, explaining why it uses ReentrantReadWriteLock with HashMaps, how Semaphore controls async send rates, the SemaphoreReleaseOnlyOnce wrapper, the CountDownLatch‑based sync‑to‑async pattern, and the CompletableFuture redesign that reduces blocking in message replication.

CompletableFutureDistributed MessagingJava
0 likes · 10 min read
How RocketMQ Handles Concurrency: Deep Dive into Its Design Principles
Tencent Cloud Developer
Tencent Cloud Developer
Sep 10, 2024 · Fundamentals

Why Does This Go Code Block? Uncovering Channel and Select Pitfalls

This article analyzes a Go program that deadlocks due to misuse of unbuffered channels and select, explains the underlying behavior of channels, blocking conditions, and select semantics, and provides a simple fix by buffering the stop channel while also covering Go's CSP roots and best‑practice guidelines.

Gobuffered-channelchannel
0 likes · 20 min read
Why Does This Go Code Block? Uncovering Channel and Select Pitfalls
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 10, 2024 · Fundamentals

Deep Dive into Guava: A Powerful Toolkit for Java Developers

This article provides a comprehensive guide to Google Guava, covering its core modules such as collections, concurrency, string utilities, I/O, caching, event bus, functional programming, reflection, and best‑practice code examples that demonstrate how to simplify and strengthen Java development.

CollectionsEventBusGuava
0 likes · 31 min read
Deep Dive into Guava: A Powerful Toolkit for Java Developers
Python Programming Learning Circle
Python Programming Learning Circle
Sep 9, 2024 · Fundamentals

Advanced Python Techniques: Data Structures, Decorators, Metaprogramming, Concurrency, and Performance Optimization

This article introduces experienced Python developers to advanced techniques and best practices, covering high‑level data structures from the collections module, custom data structures, decorators and context managers, metaclasses, dynamic class creation, concurrent and asynchronous programming, performance tuning, memory management, coding standards, and testing strategies.

Advanced TechniquesPerformanceconcurrency
0 likes · 10 min read
Advanced Python Techniques: Data Structures, Decorators, Metaprogramming, Concurrency, and Performance Optimization
DaTaobao Tech
DaTaobao Tech
Sep 6, 2024 · Backend Development

Go Language Coroutine Principles and GMP Model Implementation

The article examines Go's coroutine architecture and its GMP (Goroutine-Machine-Processor) model, tracing coroutine history, comparing kernel, user, and hybrid thread models, and detailing G, M, and P components, scheduling principles, work-stealing, preemption, and runtime implementation that give Go high concurrency and low latency.

CoroutinesGMP modelGo Language
0 likes · 37 min read
Go Language Coroutine Principles and GMP Model Implementation
Architect's Guide
Architect's Guide
Sep 5, 2024 · Databases

Strategies for Fast Import of 1 Billion Records into MySQL

To import one billion 1 KB log records stored in HDFS or S3 into MySQL efficiently, the article examines data partitioning, B‑tree index limits, batch insertion, storage engine choices, concurrency control, file‑reading methods, task scheduling with Redis, Redisson, and Zookeeper for reliable, ordered, high‑throughput loading.

Batch InsertData PartitioningMySQL
0 likes · 18 min read
Strategies for Fast Import of 1 Billion Records into MySQL
Architects' Tech Alliance
Architects' Tech Alliance
Sep 4, 2024 · Fundamentals

Why Bigger Transformers Win: Scaling Laws and Parallel Computing Essentials

The article explains OpenAI's 2020 Scaling Laws that show larger transformer models, more data, and greater compute consistently improve performance, introduces the concept of emergent abilities at critical size thresholds, and outlines the core principles of parallel computing such as multi‑processor usage, task decomposition, concurrent execution, and inter‑processor communication.

Task DecompositionTransformer Modelscommunication
0 likes · 6 min read
Why Bigger Transformers Win: Scaling Laws and Parallel Computing Essentials
Java Architect Essentials
Java Architect Essentials
Aug 31, 2024 · Backend Development

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

This article provides a comprehensive guide to improving Java backend performance by explaining parallel processing with CompletableFuture, minimizing transaction scope, effective caching strategies, proper thread‑pool configuration, cache‑line alignment, reducing object creation, lock granularity, copy‑on‑write collections, asynchronous patterns, loop optimizations, network payload reduction, and minimizing inter‑service dependencies.

JavaOptimizationPerformance
0 likes · 33 min read
Java Backend Performance Optimization: Parallel Processing, Transaction Scope, Caching, Thread Pools, and Concurrency
21CTO
21CTO
Aug 30, 2024 · Backend Development

How to Stay Ahead as a Java Developer: Tips for JDK 21, Spring Boot 3.2, and Beyond

This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.

Backend DevelopmentJDK 21Java
0 likes · 9 min read
How to Stay Ahead as a Java Developer: Tips for JDK 21, Spring Boot 3.2, and Beyond
IT Services Circle
IT Services Circle
Aug 30, 2024 · Backend Development

Technical Interview Q&A: C++ vs Go, Thread Communication, Goroutine, TCP Handshake, SQL, and More

This article compiles a series of technical interview questions and answers covering C++ and Go language differences, thread communication methods on Linux and Windows, stack versus heap memory, orphan processes, read‑write locks, Go goroutine concurrency, TCP three‑way handshake, and a sample SQL query for gender‑based grouping.

Backend DevelopmentC++Go
0 likes · 12 min read
Technical Interview Q&A: C++ vs Go, Thread Communication, Goroutine, TCP Handshake, SQL, and More
Su San Talks Tech
Su San Talks Tech
Aug 30, 2024 · Backend Development

Prevent Data Loss in Java Thread Pools When Services Crash

This article explains Java thread pools, their advantages, internal mechanics, common pitfalls such as oversized queues, excessive threads, and data loss on crashes, and presents a persistence‑based solution using database‑stored tasks and scheduled retries to ensure no data is lost when services go down.

Backend DevelopmentJavaOOM prevention
0 likes · 8 min read
Prevent Data Loss in Java Thread Pools When Services Crash
BirdNest Tech Talk
BirdNest Tech Talk
Aug 28, 2024 · Backend Development

Why Go Channels Slow Down on More CPUs and How to Fix It

A Fastly engineer discovered that increasing CPU cores can degrade Go channel performance due to lock contention, and this article reproduces the benchmarks, explains why goroutine count—not CPU count—is the real culprit, and offers practical optimization techniques.

ChannelsGOMAXPROCSGo
0 likes · 10 min read
Why Go Channels Slow Down on More CPUs and How to Fix It
IT Services Circle
IT Services Circle
Aug 28, 2024 · Backend Development

Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization

The article shares a graduate's interview experience and provides a comprehensive technical guide covering HTTP/1.x vs HTTP/2 differences, Java socket and HTTP server code, OS I/O buffering vs direct I/O, database concurrency control, Bloom filter principles, Java reflection, annotation usage, and synchronized locking semantics.

Bloom FilterHTTPJava
0 likes · 21 min read
Interview Experience and Technical Guide: HTTP Versions, Java Network Programming, OS I/O, Database Concurrency, Bloom Filter, Reflection, Annotations, and Synchronization
Code Ape Tech Column
Code Ape Tech Column
Aug 26, 2024 · Backend Development

Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions

This article explains why exceptions thrown by tasks submitted to a Java thread pool behave differently with submit and execute, demonstrates how to capture those exceptions using Future.get, try‑catch, Thread.setDefaultUncaughtExceptionHandler, and by overriding afterExecute, and provides complete code examples for each approach.

ExceptionHandlingExecutorServiceJava
0 likes · 13 min read
Handling Exceptions in Java ThreadPool: submit vs execute and Custom Solutions
21CTO
21CTO
Aug 24, 2024 · Backend Development

How PayPal Scaled to Billions of Transactions with Only 8 VMs via Actor Model

PayPal’s rapid growth forced it to process millions of transactions daily, leading the engineering team to expand beyond a thousand virtual machines and confront escalating network, maintenance, and resource challenges, which they solved by adopting the Akka‑based Actor model and implementing a Go‑based actor system for efficient, fault‑tolerant concurrency.

Actor modelAkkaPayPal
0 likes · 11 min read
How PayPal Scaled to Billions of Transactions with Only 8 VMs via Actor Model
Eric Tech Circle
Eric Tech Circle
Aug 22, 2024 · Backend Development

Mastering Asynchronous Batch Processing with JDK 21 Virtual Threads

Using JDK 21’s standardized Virtual Threads, this guide explains how to design and implement robust asynchronous batch processing, covering common pitfalls like CPU spikes and OOM, best‑practice concurrency controls, task queue architecture, and practical code illustrations.

AsynchronousProcessingBackendBatchProcessing
0 likes · 6 min read
Mastering Asynchronous Batch Processing with JDK 21 Virtual Threads
21CTO
21CTO
Aug 22, 2024 · Fundamentals

How Rust Revolutionized Memory Safety and Became the Fastest‑Growing Language

This article traces Rust’s origin from Graydon Hoare’s personal frustration with buggy elevators to its rise as a memory‑safe, high‑performance language adopted by major tech companies, highlighting its design principles, community culture, and impact on modern software development.

concurrencymemory safety
0 likes · 16 min read
How Rust Revolutionized Memory Safety and Became the Fastest‑Growing Language
php Courses
php Courses
Aug 22, 2024 · Backend Development

Understanding PHP 8.1 Fibers: Concepts, Usage, and Practical Examples

This article explains PHP 8.1's Fibers feature, describing how they enable lightweight cooperative multitasking, showing basic and advanced code examples for non‑blocking I/O, parallel API/database calls, and large‑file processing, and discusses benefits, use‑cases, and important limitations.

Fibersconcurrencynon-blocking I/O
0 likes · 12 min read
Understanding PHP 8.1 Fibers: Concepts, Usage, and Practical Examples
dbaplus Community
dbaplus Community
Aug 21, 2024 · Backend Development

How PayPal Handled Billions of Daily Transactions with Only 8 VMs via Actor Model

PayPal’s rapid growth forced a shift from simple hardware upgrades to a sophisticated, actor‑based architecture built on Akka, enabling efficient resource utilization, fault tolerance, and high‑throughput processing, ultimately allowing the company to handle billions of daily transactions using only eight virtual machines.

Actor modelBackendPayPal
0 likes · 11 min read
How PayPal Handled Billions of Daily Transactions with Only 8 VMs via Actor Model
Bin's Tech Cabin
Bin's Tech Cabin
Aug 20, 2024 · Backend Development

How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety

This article examines Netty 4.1.x’s ByteBuf reference‑counting mechanism, explains why reference counting was introduced, traces its original design, shows instruction‑level optimizations, reveals concurrency bugs in version 4.1.17, and details the clever even‑odd redesign that guarantees thread‑safe memory release while preserving high performance.

ByteBufJavaNetty
0 likes · 34 min read
How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety
Liangxu Linux
Liangxu Linux
Aug 18, 2024 · Backend Development

Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes

This article explains the thundering herd phenomenon in multi‑process/thread servers, details its performance costs, demonstrates the issue with accept() and epoll_wait() through C examples, explores thread‑level herd, and presents mitigation techniques such as accept mutexes, SO_REUSEPORT, and Nginx's handling.

EpollLinux kernelSO_REUSEPORT
0 likes · 20 min read
Why Does the Thundering Herd Problem Still Appear with epoll? Deep Dive and Fixes
Test Development Learning Exchange
Test Development Learning Exchange
Aug 17, 2024 · Backend Development

Python Decorator Examples for API Testing

This article presents ten practical Python decorator patterns—such as logging, performance measurement, exception handling, retry, status‑code validation, parameter checking, rate limiting, data‑driven testing, environment configuration, and concurrent execution—each illustrated with clear use‑case descriptions and complete code snippets for API testing.

DecoratorPerformanceRetry
0 likes · 9 min read
Python Decorator Examples for API Testing
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Aug 14, 2024 · Backend Development

How to Safely Pass ThreadLocal Values Across Thread Pools with TTL

This article explains the limitations of Java's ThreadLocal and InheritableThreadLocal in thread‑pool scenarios, introduces Alibaba's open‑source TransmittableThreadLocal (TTL) library, and provides detailed code examples for safely transmitting thread‑local data across threads, thread pools, and even via Java agents.

ThreadPoolTransmittableThreadLocalconcurrency
0 likes · 10 min read
How to Safely Pass ThreadLocal Values Across Thread Pools with TTL
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Aug 13, 2024 · Backend Development

Understanding Java Atomic Variables and Their Applications in Concurrent Programming

This article provides a comprehensive guide to Java atomic variables, explaining their core concepts, underlying CAS mechanism, key classes such as AtomicInteger, AtomicLong, AtomicReference, and AtomicBoolean, and demonstrating practical code examples, use‑cases, performance benefits, limitations, and comparisons with traditional lock‑based synchronization.

Atomic VariablesCASLock-Free
0 likes · 21 min read
Understanding Java Atomic Variables and Their Applications in Concurrent Programming
FunTester
FunTester
Aug 12, 2024 · Backend Development

Building a High‑Performance LRU Cache in Go from Scratch

This article explains the importance of caching, compares common replacement policies, and walks through a complete Go implementation of a thread‑safe local LRU cache, including interface design, data structures, linked‑list management, and concurrency handling.

Backend DevelopmentData StructuresGo
0 likes · 11 min read
Building a High‑Performance LRU Cache in Go from Scratch
Java Architect Essentials
Java Architect Essentials
Aug 11, 2024 · Backend Development

Why @Transactional Can Invalidate Locks in Spring and How to Fix It

This article explains how using Spring's @Transactional annotation together with explicit locks can cause unexpected concurrency issues, demonstrates the problem with sample code, analyzes why the lock becomes ineffective, and presents solutions such as separating transactional methods, using programmatic transactions, or locking the entire transaction.

@TransactionalJavaLock
0 likes · 6 min read
Why @Transactional Can Invalidate Locks in Spring and How to Fix It
Nullbody Notes
Nullbody Notes
Aug 10, 2024 · Backend Development

How to Build an Expiring Single-Node Lock in Go

This article explains how to implement a single‑process lock in Go that records an owner, allows only the owner to unlock, and automatically releases the lock after a specified timeout, providing full source code and a walkthrough of the key functions.

GoLockconcurrency
0 likes · 5 min read
How to Build an Expiring Single-Node Lock in Go
Tencent Cloud Developer
Tencent Cloud Developer
Aug 6, 2024 · Backend Development

Nine Common Techniques for Service Performance Optimization

The article outlines nine broadly applicable techniques—caching, parallel and batch processing, data compression, lock‑free design, sharding, eliminating unnecessary requests, and resource pooling—that together can dramatically cut service latency and improve throughput, as demonstrated by an 80% latency reduction in a real‑world project.

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

Unlock Java Distributed Locks with Lock4j: Guide & Advanced Tips

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

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

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

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

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

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

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

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

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

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

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

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

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

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

8 Effective Retry Strategies for Java APIs

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

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

Understanding ForkJoinPool: Theory, Implementation, and Performance in Java

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

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

Spring Controller Scope: Singleton vs Prototype and Concurrency Safety

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

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

Common Pitfalls and Best Practices for Using Java Thread Pools

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Investigation of JSF Thread‑Pool Exhaustion During R2M Redis Upgrade

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

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

Understanding False Sharing and Cache Padding in Go

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

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

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

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

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

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

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

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

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

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

Redisconcurrencydelayed tasks
0 likes · 27 min read
11 Ways to Implement Delayed Tasks in Java: From DelayQueue to Quartz
21CTO
21CTO
Jun 27, 2024 · Fundamentals

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

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

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

Understanding the Fork/Join Framework and ForkJoinPool in Java

This article explains the limitations of ThreadPoolExecutor, introduces the Fork/Join model and ForkJoinPool, demonstrates how to implement divide‑and‑conquer tasks with RecursiveTask, provides performance benchmarks, and discusses design details, task submission methods, work‑stealing, and cautions about using the common pool.

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

Understanding Fail-Fast Iterators and ConcurrentModificationException in Java Collections

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

CollectionsConcurrentModificationExceptionFail-Fast Iterator
0 likes · 5 min read
Understanding Fail-Fast Iterators and ConcurrentModificationException in Java Collections
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.

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

CangjieHarmonyOSMobile Development
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 DevelopmentGoGraceful Shutdown
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.

CompletableFutureExecutorServiceJava
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 InsertMySQLconcurrency
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.

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

Parallel Programmingconcurrencydistributed-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.

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

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

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

Database InternalsInnoDBMySQL
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 DevelopmentJDK21Virtual Threads
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.

FastThreadLocalJMHJava
0 likes · 11 min read
Why FastThreadLocal Beats ThreadLocal in High‑Concurrency Java Apps
Shepherd Advanced Notes
Shepherd Advanced Notes
Jun 4, 2024 · Backend Development

Understanding Java ThreadPoolExecutor: Implementation Details and Business Best Practices

This article explains the core concepts of Java thread pools, walks through the ThreadPoolExecutor class hierarchy and key methods, analyzes thread‑pool states and execution flow, and provides practical guidelines for configuring parameters, avoiding memory leaks, handling task dependencies, and managing exceptions in production systems.

BestPracticesJVMJava
0 likes · 23 min read
Understanding Java ThreadPoolExecutor: Implementation Details and Business Best Practices
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.

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

Database InternalsInnoDBMySQL
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 DevelopmentErrGroupGo
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.

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

Data Structuresalgorithmbig data
0 likes · 35 min read
Interview Algorithms and System Design: Bloom Filter, TopK, Median, and Concurrency Implementations