BestHub
Sign in
Tagged articles

multithreading

655 articles · Page 3 of 7
Programmer XiaoFu
Programmer XiaoFu
Apr 26, 2024 · Backend Development

8 Code Patterns That Can Spike Your CPU to 100%

The article enumerates eight common coding practices—such as fetching massive data at once, using Kafka auto‑acknowledgement, infinite loops, aggressive multithreaded imports, bulk file synchronization, deadlocks, poorly designed regexes, and heavy real‑time calculations—that can cause Java services to hit 100% CPU usage, explaining the underlying mechanisms like full GC, thread‑context switching, and NFA backtracking.

CPU usageFull GCJava performance
0 likes · 9 min read
8 Code Patterns That Can Spike Your CPU to 100%
Liangxu Linux
Liangxu Linux
Apr 9, 2024 · Fundamentals

How to Handle Signals in Multithreaded Linux Programs (C Example)

This article explains the differences between threads and processes in Linux, introduces the concept of POSIX signals, describes how signals are delivered and handled in multithreaded programs, and provides a complete C example demonstrating proper signal handling across threads.

C++LinuxPOSIX
0 likes · 5 min read
How to Handle Signals in Multithreaded Linux Programs (C Example)
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.

ConcurrencyJavaThreadLocal
0 likes · 5 min read
Understanding Java ThreadLocal: Mechanism, Use Cases, and Best Practices
JD Retail Technology
JD Retail Technology
Mar 20, 2024 · Backend Development

Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage

This article explains how using a Java thread pool for multithreaded pagination can dramatically speed up large‑scale data queries, outlines thread‑pool concepts and benefits, details ThreadPoolExecutor parameters and work‑queue options, and reviews common rejection policies and built‑in pool factories.

BackendJavaPerformance
0 likes · 6 min read
Multithreaded Pagination Query with Java ThreadPoolExecutor: Principles, Parameters, and Usage
IT Services Circle
IT Services Circle
Mar 17, 2024 · Backend Development

Understanding the volatile Keyword in Java Concurrency

This article explains the Java volatile keyword, covering its underlying principles, effects on visibility and instruction reordering, appropriate usage scenarios, limitations, and provides a practical code example demonstrating how volatile ensures thread visibility and prevents dead loops in multithreaded programs.

CASJavaatomic
0 likes · 6 min read
Understanding the volatile Keyword in Java Concurrency
Liangxu Linux
Liangxu Linux
Mar 17, 2024 · Fundamentals

Master Linux Synchronization: From Semaphores to Mutexes with Practical Code

Learn the core principles of synchronization and mutual exclusion in multi‑process or multi‑threaded Linux environments, explore design concepts such as atomic operations and deadlock avoidance, and see complete POSIX‑thread code examples using semaphores, condition variables, mutexes and spinlocks.

LinuxPOSIXmultithreading
0 likes · 8 min read
Master Linux Synchronization: From Semaphores to Mutexes with Practical Code
Java Tech Enthusiast
Java Tech Enthusiast
Mar 16, 2024 · Backend Development

Common Causes of 100% CPU Usage in Java Backend Services

Typical reasons for Java backend services hitting 100 % CPU include fetching massive data sets, misusing Kafka auto‑acknowledge, infinite loops or recursion, thread‑pool overload causing context‑switch thrashing, bulk file synchronization, lock‑order deadlocks, poorly designed regular expressions, and intensive real‑time calculations under high concurrency.

CPUJavaKafka
0 likes · 8 min read
Common Causes of 100% CPU Usage in Java Backend Services
macrozheng
macrozheng
Mar 15, 2024 · Backend Development

Why Does My Java Service Hit 100% CPU? 8 Real-World Causes & Fixes

This article examines common reasons behind persistent 100% CPU usage in Java backend systems—ranging from excessive full GC and Kafka auto‑acknowledgment to dead loops, thread‑pool overload, massive file sync, deadlocks, inefficient regex and heavy real‑time calculations—offering practical diagnostics and solutions.

CPUmultithreading
0 likes · 10 min read
Why Does My Java Service Hit 100% CPU? 8 Real-World Causes & Fixes
Alibaba Cloud Developer
Alibaba Cloud Developer
Mar 15, 2024 · Fundamentals

Unlocking High-Performance Multithreading: Lock-Free Techniques in iLogtail

This article explores the fundamentals of multithreaded programming, comparing traditional lock-based synchronization with advanced lock-free techniques, and demonstrates how iLogtail implements thread models, memory barriers, atomic operations, spin locks, double-buffering, and deferred reclamation to achieve scalable, high-performance concurrency.

C++Lock-FreeiLogtail
0 likes · 25 min read
Unlocking High-Performance Multithreading: Lock-Free Techniques in iLogtail
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.

ConcurrencyPythonThread Safety
0 likes · 24 min read
Mastering Thread Safety in Python: Locks, Conditions, and More
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.

ConcurrencyJavaThread Safety
0 likes · 5 min read
Using Java Annotations to Solve Concurrency Timing Challenges
Architect's Guide
Architect's Guide
Mar 1, 2024 · Backend Development

Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions

The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.

CompletableFutureJavaProgrammaticTransaction
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Java Tech Enthusiast
Java Tech Enthusiast
Feb 28, 2024 · Backend Development

Understanding Java Processes, Threads, and Thread Creation Techniques

The article clarifies Java processes and threads using a game analogy, then demonstrates three thread‑creation techniques—extending Thread, implementing Runnable, and implementing Callable with FutureTask—while covering run vs start, thread control methods such as sleep, join, and daemon settings.

JavaRunnablecallable
0 likes · 9 min read
Understanding Java Processes, Threads, and Thread Creation Techniques
Su San Talks Tech
Su San Talks Tech
Feb 26, 2024 · Backend Development

Why Does My Java Service Hit 100% CPU? 8 Real-World Causes and Fixes

This article examines eight common reasons why Java backend services experience 100% CPU usage—such as fetching excessive data, automatic Kafka acknowledgments, infinite loops, multithreaded imports, massive file syncs, deadlocks, inefficient regular expressions, and heavy real‑time calculations—and provides practical mitigation strategies.

CPUJavaKafka
0 likes · 9 min read
Why Does My Java Service Hit 100% CPU? 8 Real-World Causes and Fixes
Su San Talks Tech
Su San Talks Tech
Feb 15, 2024 · Backend Development

How to Ensure Transaction Rollback in Spring Multithreaded Operations

This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.

JavaMyBatisSpring
0 likes · 10 min read
How to Ensure Transaction Rollback in Spring Multithreaded Operations
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.

ConcurrencyCustom SynchronizerJava
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.

Concurrencyasynciomultiprocessing
0 likes · 5 min read
Python Concurrency Techniques: Threads, Processes, Async, and Pools
Selected Java Interview Questions
Selected Java Interview Questions
Dec 28, 2023 · Databases

KeyDB Multithreaded Architecture, Connection Management, Fastlock, and Active‑Replica Mechanism

This article explains how KeyDB, a multithreaded fork of Redis, restructures the original single‑threaded design by introducing worker threads, per‑thread connection handling, a fastlock spin‑lock implementation, and an active‑replica feature that enables writable replicas with conflict‑resolution using timestamped keys.

Active-ReplicaKeyDBLock
0 likes · 9 min read
KeyDB Multithreaded Architecture, Connection Management, Fastlock, and Active‑Replica Mechanism
Sohu Tech Products
Sohu Tech Products
Dec 27, 2023 · Artificial Intelligence

OCR-Based Video Review System: Technology Selection, Optimization, and Model Fine-Tuning

An OCR‑based video review system using PaddleOCR’s DB detector and SVTR recognizer, combined with multi‑level frame deduplication, message‑queue task decoupling, Redis prioritization, and dynamic thread‑pool scheduling, was fine‑tuned on 5 000 samples to cut daily frames from 794 million to 3.6 million, achieving automated detection of over 230 abnormal videos per day and replacing three manual reviewers, with future plans for GPU acceleration and cross‑instance GRPC dispatch.

AIFine-tuningOCR
0 likes · 20 min read
OCR-Based Video Review System: Technology Selection, Optimization, and Model Fine-Tuning
Deepin Linux
Deepin Linux
Dec 20, 2023 · Fundamentals

C++ Interview Questions: Polymorphism, Vtables, Memory Alignment, STL Containers, and Multithreading Locks

This article presents a comprehensive C++ interview guide covering dynamic polymorphism, vtable mechanics, static vs virtual functions, memory alignment benefits, iterator invalidation in vector and map, erase‑remove idiom, map implementation details, and common synchronization primitives used in multithreaded programming.

C++STLiterator invalidation
0 likes · 12 min read
C++ Interview Questions: Polymorphism, Vtables, Memory Alignment, STL Containers, and Multithreading Locks
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.

ConcurrencyJavaProgramming Fundamentals
0 likes · 4 min read
An Introduction to Java Multithreading: Basics, Techniques, and Applications
php Courses
php Courses
Dec 5, 2023 · Backend Development

Error Handling in PHP Multithreaded Programming with pthreads

This article explains how to install the pthreads extension for PHP and demonstrates three approaches—try‑catch blocks, shared variables, and logging—to capture and propagate errors from worker threads back to the main thread, ensuring stable multithreaded applications.

Backendmultithreadingpthreads
0 likes · 5 min read
Error Handling in PHP Multithreaded Programming with pthreads
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.

APIConcurrencyFile Download
0 likes · 6 min read
Python Multithreading Techniques for Concurrent API Calls, File Downloads, Test Execution, and Database Inserts
php Courses
php Courses
Nov 8, 2023 · Backend Development

Implementing Thread Pools and Coroutines in PHP

This article explains how to implement low‑level thread pools and coroutine mechanisms in PHP, providing detailed code examples that demonstrate creating a ThreadPool class, managing worker threads, and using generator‑based coroutines to achieve high‑performance, concurrent execution.

ConcurrencyPHPPerformance
0 likes · 5 min read
Implementing Thread Pools and Coroutines in PHP
Architects' Tech Alliance
Architects' Tech Alliance
Nov 4, 2023 · Fundamentals

Fundamentals of CPU Architecture and Technology

This article provides a comprehensive overview of CPU fundamentals, covering core concepts such as clock speed, external frequency, front‑side bus, multiplier, bit and word length, cache hierarchy, instruction sets, voltage levels, manufacturing processes, pipelines, superscalar execution, SMP, multicore designs, multithreading, hyper‑threading, and NUMA technology.

CPUInstruction Setarchitecture
0 likes · 13 min read
Fundamentals of CPU Architecture and Technology
360 Quality & Efficiency
360 Quality & Efficiency
Nov 3, 2023 · Backend Development

Automated Video Quality Detection and Multithreaded Optimization for Live Stream Transcoding

This article describes an automated workflow for capturing frames from live‑stream transcode outputs, using OpenCV and ffmpeg to perform black‑screen and artifact detection, integrating results via an API, storing images in S3, and applying a producer‑consumer multithreaded model to reduce detection latency by up to 42%.

FFmpegOpenCVS3-storage
0 likes · 10 min read
Automated Video Quality Detection and Multithreaded Optimization for Live Stream Transcoding
政采云技术
政采云技术
Oct 31, 2023 · Fundamentals

Understanding Java Threads, Thread Models, and Scheduling

This article explains what threads are, how Java maps its threads to operating‑system thread models (1:1, N:1, N:M), the differences between kernel and user threads, thread scheduling, context switching, priority handling, and includes sample Java code to compare serial and multithreaded execution.

ConcurrencyJavamultithreading
0 likes · 19 min read
Understanding Java Threads, Thread Models, and Scheduling
FunTester
FunTester
Oct 30, 2023 · Backend Development

How to Build a High‑Performance Object Pool for Multithreaded Systems

This article explores the motivation, design, implementation, and performance testing of a high‑performance object pool that reduces allocation overhead in multithreaded environments by using thread‑local storage, freelists, and lock‑optimized global resources.

C++ConcurrencyPerformance Optimization
0 likes · 25 min read
How to Build a High‑Performance Object Pool for Multithreaded Systems
FunTester
FunTester
Oct 26, 2023 · Fundamentals

Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained

This article provides a comprehensive guide to Java locking mechanisms, covering ReentrantLock, synchronized, ReadWriteLock, and spin locks, with detailed code examples, performance considerations, common use cases, and best practices to ensure thread safety, avoid deadlocks, and optimize concurrency in multithreaded applications.

ConcurrencyJavaLocks
0 likes · 17 min read
Mastering Java Locks: Reentrant, Synchronized, ReadWrite, and Spin Locks Explained
JD Cloud Developers
JD Cloud Developers
Oct 11, 2023 · Backend Development

How Many Threads Should You Run? Real‑World Tests Reveal the Truth

This article debunks common thread‑count myths by running Java CPU‑bound and I/O‑bound experiments on a 6‑core/12‑thread Ryzen, showing how core count, context‑switching overhead, and I/O wait time affect CPU utilization and guiding practical thread‑pool sizing.

CPU utilizationJava concurrencymultithreading
0 likes · 12 min read
How Many Threads Should You Run? Real‑World Tests Reveal the Truth
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 8, 2023 · Backend Development

Spring Transaction Deep Dive: Thread‑Bound Connections and Multithreaded Consistency

This article explains Spring's transaction core, showing how TransactionInterceptor and TransactionAspectSupport use AOP to bind a Connection to ThreadLocal, walks through key code snippets for creating, committing, and rolling back transactions, and demonstrates a JUC‑based solution for maintaining transaction consistency across multiple threads.

JavaJdbcTemplateSpring
0 likes · 9 min read
Spring Transaction Deep Dive: Thread‑Bound Connections and Multithreaded Consistency
Sohu Tech Products
Sohu Tech Products
Sep 20, 2023 · Backend Development

Java CompletableFuture Tutorial: Asynchronous Programming and Task Composition

This tutorial explains Java 8's CompletableFuture, showing how to create, compose, and handle asynchronous tasks with methods like supplyAsync, thenApply, allOf, and anyOf, while emphasizing custom thread pools, non‑blocking patterns, and robust exception handling for real‑world concurrent programming.

Asynchronous ProgrammingCompletableFutureJava
0 likes · 17 min read
Java CompletableFuture Tutorial: Asynchronous Programming and Task Composition
MaGe Linux Operations
MaGe Linux Operations
Sep 15, 2023 · Information Security

How to Build a Fast, Accurate Honeypot Detector with Python and CrawlerGo

This article explains what web honeypots are, outlines their distinctive JSONP‑hijacking behavior, and provides a step‑by‑step guide—including asset collection with CrawlerGo, data cleaning, dictionary matching, multithreaded scanning, and proxy‑pool integration—to automatically identify and filter honeypots from large domain lists.

Pythoncrawlergohoneypot detection
0 likes · 15 min read
How to Build a Fast, Accurate Honeypot Detector with Python and CrawlerGo
AI Skills Research
AI Skills Research
Sep 12, 2023 · Fundamentals

Understanding C#'s volatile Keyword for Thread Safety

The article explains how the C# volatile keyword ensures that fields accessed by multiple threads always hold the latest value by preventing compiler optimizations, lists the types it can be applied to, and warns of pitfalls when used with complex data structures.

C++ConcurrencyThread Safety
0 likes · 3 min read
Understanding C#'s volatile Keyword for Thread Safety
Tencent Cloud Developer
Tencent Cloud Developer
Sep 11, 2023 · Fundamentals

Understanding Python's Global Interpreter Lock (GIL) and Its Impact

The article explains Python’s Global Interpreter Lock—its historical origins, how CPython’s tick‑based and later time‑slice schedulers manage thread execution, why it limits multi‑core performance, common multiprocessing workarounds, and the difficulties of removing it despite recent proposals for a GIL‑free build.

ConcurrencyGILPerformance
0 likes · 15 min read
Understanding Python's Global Interpreter Lock (GIL) and Its Impact
Selected Java Interview Questions
Selected Java Interview Questions
Aug 8, 2023 · Big Data

Processing 10GB Age Data on a 4GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Solutions

This article demonstrates how to generate, read, and analyze a 10 GB file of age statistics on a 4 GB RAM, 2‑core machine using Java, comparing a single‑threaded counting method with a producer‑consumer multi‑threaded approach that dramatically improves CPU utilization and reduces processing time.

JavaPerformance Optimizationbig data
0 likes · 11 min read
Processing 10GB Age Data on a 4GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Solutions
Liangxu Linux
Liangxu Linux
Aug 8, 2023 · Fundamentals

Mastering Pthreads: Complete Guide to Thread Creation, Sync, and Management on Linux

This article explains why traditional Unix fork/exec models are costly, introduces POSIX threads (Pthreads) as a lightweight alternative, and provides detailed guidance on thread data structures, creation, termination, synchronization primitives, and attribute configuration with practical code examples for Linux developers.

Concurrencymultithreadingpthreads
0 likes · 20 min read
Mastering Pthreads: Complete Guide to Thread Creation, Sync, and Management on Linux
FunTester
FunTester
Aug 7, 2023 · Backend Development

Atomic Operation Pitfalls in Java Performance Testing and How to Fix Them

This article describes a Java performance‑testing script that uses concurrent user initialization, explains how overlooking atomicity in thread‑safe classes caused some users to miss initialization, and presents three practical solutions such as improving stop logic, tracking completed users, and using concurrent collections.

Atomicitymultithreadingperformance-testing
0 likes · 7 min read
Atomic Operation Pitfalls in Java Performance Testing and How to Fix Them
HelloTech
HelloTech
Jul 28, 2023 · Backend Development

Understanding Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock Implementation

The article explains Java’s AbstractQueuedSynchronizer framework and how ReentrantLock uses its inner Sync classes—FairSync and NonfairSync—to manage lock acquisition via CAS, queueing, spinning, and parking, detailing the acquire/release loops, fair vs non‑fair behavior, and interview‑ready insights.

AQSJavaLock
0 likes · 12 min read
Understanding Java's AbstractQueuedSynchronizer (AQS) and ReentrantLock Implementation
ByteFE
ByteFE
Jul 19, 2023 · Frontend Development

WebAssembly‑Based Video Editing: Architecture, Multithreading, Graphics, and Performance Optimizations

This article reviews the adoption of WebAssembly for a web‑based video editing SDK, covering its technical background, browser compatibility, JavaScript vs. WebAssembly trade‑offs, multithreading with Web Workers, OpenGL/WebGL rendering, virtual file‑system handling, package‑size reduction techniques, development tooling, and future directions such as front‑end synthesis and collaborative editing.

EmscriptenWebAssemblyWebGL
0 likes · 30 min read
WebAssembly‑Based Video Editing: Architecture, Multithreading, Graphics, and Performance Optimizations
IT Services Circle
IT Services Circle
Jun 27, 2023 · Fundamentals

Using CyclicBarrier for Alternating Thread Printing of ABC in Java

This article explains how to use Java's CyclicBarrier to coordinate three threads that alternately print the characters A, B, and C, providing a detailed analysis, example analogy, complete implementation code, execution result, and a brief summary of its relevance in multithreading interviews.

ConcurrencyCyclicBarrierJava
0 likes · 5 min read
Using CyclicBarrier for Alternating Thread Printing of ABC in Java
Java Interview Crash Guide
Java Interview Crash Guide
Jun 27, 2023 · Backend Development

How to Ensure Transaction Consistency in Multithreaded Spring Applications

This article explains how to execute two dependent tasks in parallel using CompletableFuture, why @Async and @Transactional are insufficient for multithreaded transaction consistency, and provides a programmatic solution that copies Spring transaction resources between threads to guarantee atomic commit or rollback across asynchronous operations.

CompletableFutureProgrammatic Transactionmultithreading
0 likes · 19 min read
How to Ensure Transaction Consistency in Multithreaded Spring Applications
Selected Java Interview Questions
Selected Java Interview Questions
Jun 25, 2023 · Backend Development

Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions

This article explains how to execute two dependent tasks in parallel with CompletableFuture, why the usual @Transactional annotation fails in a multi‑threaded environment, and provides a programmatic transaction solution that copies Spring's transaction resources between threads to guarantee atomic commit or rollback across all parallel operations.

CompletableFutureProgrammatic TransactionSpring
0 likes · 19 min read
Ensuring Transaction Consistency in Multi‑threaded Spring Applications Using Programmatic Transactions
Architect's Tech Stack
Architect's Tech Stack
Jun 24, 2023 · Backend Development

Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP

This article explains why @Transactional fails in multithreaded Spring Boot scenarios, then demonstrates how to combine @Async, a custom thread‑pool, @MainTransaction and @SonTransaction annotations with AOP logic to achieve reliable multi‑threaded transaction control, complete with code examples and usage guidelines.

AOPCustom AnnotationJava
0 likes · 12 min read
Implementing Multi‑threaded Transactions in Spring Boot with Custom Annotations and AOP
HomeTech
HomeTech
Jun 14, 2023 · Backend Development

Design and Implementation of a Task Orchestration Framework for Business Systems

This article introduces the background, core concepts, architecture, and implementation details of a lightweight Java task orchestration framework that simplifies complex business workflows by managing task dependencies, parallel execution, and error handling, thereby improving development efficiency and system maintainability.

Java concurrencyTask Orchestrationmultithreading
0 likes · 25 min read
Design and Implementation of a Task Orchestration Framework for Business Systems
php Courses
php Courses
May 21, 2023 · Backend Development

Implementing Multithreaded Bulk Email Sending with PHP and Swoole

This article explains how to use the PHP Swoole extension to create asynchronous, coroutine‑based multithreaded email sending, dramatically improving the performance of bulk mail dispatch compared with traditional single‑threaded PHP scripts.

asynchronousemailmultithreading
0 likes · 8 min read
Implementing Multithreaded Bulk Email Sending with PHP and Swoole
Top Architect
Top Architect
May 11, 2023 · Fundamentals

How to Properly Stop a Java Thread: Methods, Examples, and Common Pitfalls

This article explains the various ways to terminate a running Java thread—including using exit flags, the deprecated stop() method, interrupt(), and exception handling—illustrates each technique with complete code examples, compares their effects on thread state, and warns about the dangers of forceful termination.

ExceptionStopinterrupt
0 likes · 12 min read
How to Properly Stop a Java Thread: Methods, Examples, and Common Pitfalls
JD Tech
JD Tech
May 11, 2023 · Fundamentals

Evolution of Java Multithreading: From Manual Gear to Virtual Threads

This article systematically traces the evolution of Java multithreading from the early native Thread model through the introduction of java.util.concurrent and synchronized optimizations to the modern virtual thread era, highlighting key concepts, milestones, and performance impacts.

ConcurrencyJDKJava 19
0 likes · 19 min read
Evolution of Java Multithreading: From Manual Gear to Virtual Threads
Programmer DD
Programmer DD
May 11, 2023 · Backend Development

Why Java’s ArrayList addAll Fails Under Concurrency and How to Fix It

This article explains the importance and challenges of concurrent programming, details Java's memory model and synchronization primitives, analyzes a real‑world case where concurrent addAll on ArrayList caused missing UI elements, and demonstrates how using thread‑safe collections resolves the issue.

ConcurrencyJavaThread Safety
0 likes · 14 min read
Why Java’s ArrayList addAll Fails Under Concurrency and How to Fix It
Liangxu Linux
Liangxu Linux
Apr 26, 2023 · Operations

How to Monitor Multi‑Threaded Linux Processes with top -H

This guide shows how to create and manage multiple pthreads in an embedded Linux program, then monitor each thread’s runtime using the top command with the -H option, including the need to set thread names via pthread_setname_np for clear identification.

Linuxmultithreadingpthread
0 likes · 5 min read
How to Monitor Multi‑Threaded Linux Processes with top -H
Selected Java Interview Questions
Selected Java Interview Questions
Apr 26, 2023 · Backend Development

Implementing a Flexible Excel Export Utility with Apache POI in Java

This article explains how to build a reusable Java utility for exporting large Excel reports using Apache POI, covering header configuration, data transformation, cell formatting, multithreaded data retrieval, asynchronous handling of long‑running exports, and provides full source snippets and SQL schema examples.

@AsyncApache POIExcel Export
0 likes · 13 min read
Implementing a Flexible Excel Export Utility with Apache POI in Java
Code Ape Tech Column
Code Ape Tech Column
Apr 25, 2023 · Backend Development

Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios

This article explores Java multithreading concepts, JVM safety tools, thread creation methods, coordination mechanisms, and practical scenarios such as parallel data aggregation, for‑loop conversion, map‑based processing, and multi‑threaded transaction handling, providing code examples and performance tips for backend developers.

CompletableFutureConcurrencyJava
0 likes · 22 min read
Advanced Java Multithreading: From Fundamentals to High‑Performance Transactional Scenarios
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 20, 2023 · Backend Development

Overview of Four Core Java Concurrency Utilities

This article introduces the four essential Java concurrency utilities—CountDownLatch, CyclicBarrier, Semaphore, and Exchanger—explaining their functions, underlying principles, typical usage patterns, and practical scenarios such as thread synchronization, resource limiting, and data exchange in multithreaded applications.

CountDownLatchCyclicBarrierExchanger
0 likes · 7 min read
Overview of Four Core Java Concurrency Utilities
Ctrip Technology
Ctrip Technology
Apr 20, 2023 · Backend Development

Performance Optimization of Multi‑Modal Transfer Route Stitching in Ctrip Backend

This article analyzes the challenges of stitching multi‑modal transport routes in Ctrip's backend, identifies performance bottlenecks through monitoring, profiling and benchmarking, and presents a series of optimizations—including code refactoring, indexing, multi‑way merge, multi‑level caching, preprocessing, multithreading, lazy computation, and JVM tuning—that collectively reduce latency and resource consumption.

BackendCachingJava
0 likes · 17 min read
Performance Optimization of Multi‑Modal Transfer Route Stitching in Ctrip Backend
IT Services Circle
IT Services Circle
Apr 10, 2023 · Fundamentals

Nine Common Pitfalls of Using Multithreading in Java Applications

Switching from single‑threaded synchronous code to multithreaded asynchronous execution can improve performance, but introduces nine major issues—including missing return values, data loss, ordering problems, thread‑safety, ThreadLocal anomalies, OOM risks, high CPU usage, transaction failures, and service crashes—each explained with Java examples and solutions.

ConcurrencyJavaThread Safety
0 likes · 17 min read
Nine Common Pitfalls of Using Multithreading in Java Applications
AI Cyberspace
AI Cyberspace
Mar 29, 2023 · Fundamentals

Mastering POSIX Threads: From User Threads to Thread Pools in Linux

This article explains the concepts of user threads, the pthread library implementation, thread creation and termination functions, synchronization mechanisms like mutexes and condition variables, and demonstrates how to design and use a lightweight C thread‑pool with practical code examples.

C ProgrammingLinuxThread Pool
0 likes · 21 min read
Mastering POSIX Threads: From User Threads to Thread Pools in Linux
AI Cyberspace
AI Cyberspace
Mar 28, 2023 · Fundamentals

Why NUMA Slows Multithreaded Apps and How to Optimize It

This article explains NUMA architecture, its multithreaded performance overheads such as remote memory access, cache synchronization, context and mode switches, interrupt handling, TLB misses, and memory copies, and then presents optimization techniques like NUMA and CPU affinity, IRQ tuning, and large‑page usage.

CPU affinityLinuxNUMA
0 likes · 20 min read
Why NUMA Slows Multithreaded Apps and How to Optimize It
JD Cloud Developers
JD Cloud Developers
Mar 1, 2023 · Fundamentals

From Manual to Autonomous: Java Multithreading Evolution & Virtual Threads

This article chronicles the evolution of Java multithreading from early native threads through the introduction of the concurrency utilities, lock optimizations, the Fork/Join framework, CompletableFuture, reactive streams, and finally virtual threads in JDK 19, explaining each milestone, its motivations, and its impact on modern Java development.

JDKJavaJava 19
0 likes · 26 min read
From Manual to Autonomous: Java Multithreading Evolution & Virtual Threads
ByteDance SYS Tech
ByteDance SYS Tech
Feb 16, 2023 · Fundamentals

Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism

This article dives deep into the OpenJDK G1 FullGC implementation, explaining its architecture, trigger conditions, preparation steps, and the four‑phase collection process while comparing single‑threaded and multi‑threaded implementations in JDK 8 and JDK 11, and highlighting code paths that can cause long GC pauses.

FullGCG1 GCGarbage Collection
0 likes · 18 min read
Unlocking G1 FullGC: Inside OpenJDK’s Garbage‑First Full Collection Mechanism
Cloud Native Technology Community
Cloud Native Technology Community
Feb 16, 2023 · Backend Development

How to Optimize High‑Concurrency Services (QPS > 200k)

This article outlines practical strategies for handling online services with extremely high request rates—over 200,000 QPS—by avoiding relational databases, employing multi‑level caching, leveraging multithreading, implementing circuit‑breaker and downgrade mechanisms, optimizing I/O, controlling retries, handling edge cases, and logging efficiently.

Circuit BreakerPerformance Optimizationhigh concurrency
0 likes · 9 min read
How to Optimize High‑Concurrency Services (QPS > 200k)
IT Services Circle
IT Services Circle
Jan 15, 2023 · Backend Development

Understanding ThreadLocal and InheritableThreadLocal: Causes and Solutions for Missing Client Information in Multithreaded Java Services

This article explains why client information stored in ThreadLocal becomes unavailable after switching a single‑threaded search service to multithreading, analyzes the underlying ThreadLocal and InheritableThreadLocal mechanisms, and provides two practical solutions—passing the context manually or using InheritableThreadLocal—to avoid the upgrade‑prompt bug.

ConcurrencyInheritableThreadLocalJava
0 likes · 13 min read
Understanding ThreadLocal and InheritableThreadLocal: Causes and Solutions for Missing Client Information in Multithreaded Java Services
MaGe Linux Operations
MaGe Linux Operations
Jan 13, 2023 · Fundamentals

Why Python’s GIL Slows Multithreading and How It Actually Works

This article explains the purpose and mechanics of Python’s Global Interpreter Lock (GIL), how it serializes bytecode execution on single- and multi‑core CPUs, its impact on I/O‑bound versus CPU‑bound workloads, and why certain operations remain thread‑safe despite the lock.

CPythonGILThread Safety
0 likes · 8 min read
Why Python’s GIL Slows Multithreading and How It Actually Works
Top Architect
Top Architect
Nov 24, 2022 · Backend Development

Using SLF4J MDC to Correlate Logs Across Threads in Java

This article explains how to use SLF4J's MDC feature to attach a request ID to log entries, demonstrates the limitation of MDC in asynchronous threads, and provides a decorator‑based solution (MDCRunnable) that propagates the context to child threads and thread pools.

JavaMDCThreadLocal
0 likes · 10 min read
Using SLF4J MDC to Correlate Logs Across Threads in Java
Bilibili Tech
Bilibili Tech
Nov 11, 2022 · Backend Development

Optimizing a Rust STUN Server with Multi‑Threading, SO_REUSEPORT, and Linux recvmmsg/sendmmsg

The article shows how to transform a single‑threaded Rust STUN server into a high‑performance, multi‑core service by using Linux’s SO_REUSEPORT to bind multiple threads, assigning each to a NIC queue, and employing batch syscalls recvmmsg/sendmmsg, achieving over a million packets per second with significantly lower CPU usage.

LinuxRustSTUN
0 likes · 15 min read
Optimizing a Rust STUN Server with Multi‑Threading, SO_REUSEPORT, and Linux recvmmsg/sendmmsg
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 9, 2022 · Mobile Development

Using Isolates and the compute Function in Flutter to Offload Heavy Computation

This article explains how to prevent UI blocking in Flutter by moving intensive calculations to background isolates using the compute helper and raw Isolate APIs, demonstrates code examples for task execution, progress reporting, and inter‑isolate communication, and discusses performance considerations and best practices.

ComputeDartFlutter
0 likes · 15 min read
Using Isolates and the compute Function in Flutter to Offload Heavy Computation