BestHub
Sign in
Tagged articles
632 articles
Page 1 of 7
Deepin Linux
Deepin Linux
May 11, 2026 · Fundamentals

Eliminate Memory Fragmentation: Understanding Memory Pools

The article explains how frequent dynamic allocations cause external and internal memory fragmentation, illustrates the problem with C++ examples, and shows that pre‑allocating a large contiguous block as a memory pool—managed via block division, free‑list tracking, and thread‑safe operations—significantly reduces fragmentation, improves allocation speed, and boosts concurrency performance.

CMemory FragmentationPerformance Optimization
0 likes · 30 min read
Eliminate Memory Fragmentation: Understanding Memory Pools
Deepin Linux
Deepin Linux
May 10, 2026 · Fundamentals

Do You Really Understand pthread Internals? Master Linux Multithreading Basics

This article dives deep into Linux pthread fundamentals, covering process‑vs‑thread concepts, the POSIX API, kernel implementation via the clone syscall, thread lifecycle, synchronization primitives, common pitfalls such as deadlocks, stack overflows and thread leaks, and provides practical debugging and mitigation techniques with real code examples.

Linuxclone syscalldeadlock
0 likes · 55 min read
Do You Really Understand pthread Internals? Master Linux Multithreading Basics
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
May 9, 2026 · Backend Development

9 Essential Java Code Optimizations to Eliminate Bad Practices

This article presents nine practical Java code‑optimization techniques—including string formatting, loop refactoring, resource management, buffered I/O, multithreading, enums, exception handling, and third‑party libraries—each illustrated with before‑and‑after code samples and clear explanations of why the improved version is more readable, efficient, and maintainable.

Code OptimizationException HandlingJava
0 likes · 14 min read
9 Essential Java Code Optimizations to Eliminate Bad Practices
Deepin Linux
Deepin Linux
Apr 25, 2026 · Fundamentals

Mastering Mutex Locks: Solving Linux Kernel Synchronization Challenges in One Article

This article provides a comprehensive deep‑dive into Linux kernel mutex locks, explaining their principles, implementation, and APIs, and demonstrates through detailed C/C++ examples how to use them safely to avoid data races, deadlocks, and performance bottlenecks in multithreaded kernel and user‑space code.

Linux kernelSynchronizationdeadlock
0 likes · 46 min read
Mastering Mutex Locks: Solving Linux Kernel Synchronization Challenges in One Article
Architect Chen
Architect Chen
Apr 16, 2026 · Big Data

Supercharge Kafka Consumer Performance: Parallelism, Batching, and Multithreading

This guide explains practical techniques to dramatically increase Kafka consumer throughput, including scaling consumer instances or partitions, tuning fetch and poll parameters, and implementing a multithreaded consumer model, while also covering hardware, JVM, and OS optimizations and monitoring recommendations.

Batch FetchConsumer ParallelismKafka
0 likes · 5 min read
Supercharge Kafka Consumer Performance: Parallelism, Batching, and Multithreading
Deepin Linux
Deepin Linux
Apr 11, 2026 · Fundamentals

Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency

This article explains what memory barriers are, why they are essential for correct multi‑core operation in the Linux kernel, how different barrier types work, their implementation details, and practical guidelines for using them safely in synchronization primitives and driver code.

Linux kernelSynchronizationSystem Programming
0 likes · 47 min read
Why Memory Barriers Are the Hidden Foundation of Linux Kernel Concurrency
macrozheng
macrozheng
Feb 12, 2026 · Fundamentals

How Time Slices, Hyper‑Threading, and Context Switching Enable Multithreading

The article explains why modern CPUs, even single‑core ones, can run multiple threads by using short time slices, hyper‑threading hardware, and context‑switch mechanisms, and it discusses the costs, Linux monitoring tools, scheduling strategies, and practical ways to reduce switching overhead.

CPU schedulingHyper-threadingOperating Systems
0 likes · 10 min read
How Time Slices, Hyper‑Threading, and Context Switching Enable Multithreading
Java Architect Handbook
Java Architect Handbook
Feb 3, 2026 · Backend Development

Speeding Up 100k MySQL Inserts: From 5 Minutes to 3 Seconds in Java

This article walks through a real‑world data‑migration case where 100,000 rows were moved from an old system to a new one, showing how naive per‑row inserts took five minutes and how a series of optimizations—batch SQL, JDBC batch mode, and multithreaded parallelism—reduced the runtime to just three seconds, while also covering common pitfalls and the final high‑performance implementation.

Batch InsertJDBCJava
0 likes · 11 min read
Speeding Up 100k MySQL Inserts: From 5 Minutes to 3 Seconds in Java
java1234
java1234
Jan 30, 2026 · Backend Development

How to Reduce MyBatis Batch Insert from 5 Minutes to 3 Seconds? Three Key Optimizations

The article walks through three concrete optimizations—batch SQL, JDBC batch mode with rewriteBatchedStatements, and multithreaded parallel inserts—that shrink a 100,000‑row MyBatis insertion from five minutes to three seconds, while highlighting configuration details, performance gains, and common pitfalls.

Batch InsertJDBCJava
0 likes · 10 min read
How to Reduce MyBatis Batch Insert from 5 Minutes to 3 Seconds? Three Key Optimizations
Java Companion
Java Companion
Jan 29, 2026 · Backend Development

How to Cut MyBatis Batch Insert Time from 5 Minutes to 3 Seconds: Three Key Optimizations

The article walks through turning a naïve MyBatis loop that took five minutes to insert 100,000 rows into a high‑performance solution that finishes in three seconds by applying batch SQL, JDBC batch mode with rewriteBatchedStatements, and multithreaded parallel execution, while highlighting pitfalls and best‑practice configurations.

Batch InsertExecutorType.BATCHJDBC
0 likes · 9 min read
How to Cut MyBatis Batch Insert Time from 5 Minutes to 3 Seconds: Three Key Optimizations
php Courses
php Courses
Jan 19, 2026 · Backend Development

Mastering PHP Multithreading Error Handling with pthreads

This guide explains how to install the pthreads extension for PHP and presents three practical techniques—try‑catch with throwable propagation, shared‑memory error variables, and file‑based logging—to reliably capture and manage errors in multithreaded PHP applications.

Error Handlingmultithreadingpthreads
0 likes · 5 min read
Mastering PHP Multithreading Error Handling with pthreads
Code Mala Tang
Code Mala Tang
Jan 2, 2026 · Frontend Development

Boost Web App Performance with Web Workers: A Practical Guide

This article explains how JavaScript's single‑threaded nature can freeze UI during heavy calculations and shows step‑by‑step how to offload work to Web Workers, integrate external libraries, configure build tools, and follow best practices for smooth, responsive web applications.

JavaScriptWeb DevelopmentWeb Workers
0 likes · 10 min read
Boost Web App Performance with Web Workers: A Practical Guide
Xiao Liu Lab
Xiao Liu Lab
Dec 28, 2025 · Operations

When to Use Async vs Multithreading: A Practical Guide for Ops Teams

This article explains the fundamental differences between asynchronous programming and multithreading, illustrates each with real‑world operations scenarios, outlines their key advantages and pitfalls, compares them in a concise table, and provides step‑by‑step guidance for communication, deployment, and troubleshooting.

AsynchronousDeploymentconcurrency
0 likes · 12 min read
When to Use Async vs Multithreading: A Practical Guide for Ops Teams
JavaScript
JavaScript
Dec 7, 2025 · Frontend Development

Unlock Faster Frontend Performance with Underused Web Workers

Web Workers, an often‑overlooked browser API, let JavaScript run in background threads, freeing the main thread, leveraging multi‑core CPUs, and improving memory management, with practical use‑cases ranging from large data processing to image filtering and AI inference, dramatically boosting frontend responsiveness.

JavaScriptWeb Workersmultithreading
0 likes · 5 min read
Unlock Faster Frontend Performance with Underused Web Workers
macrozheng
macrozheng
Dec 3, 2025 · Databases

How Redis’s New Multithreaded Query Engine Boosts Vector Search Performance

Redis has introduced a multithreaded query engine that dramatically reduces latency and increases throughput—up to 16×—for vector similarity searches, enabling vertical scaling and better support for real‑time RAG applications compared to traditional single‑threaded architectures and competing vector databases.

RAGdatabase scalingmultithreading
0 likes · 6 min read
How Redis’s New Multithreaded Query Engine Boosts Vector Search Performance
Su San Talks Tech
Su San Talks Tech
Nov 21, 2025 · Databases

Why Redis 6.0 Introduced Multithreading and How to Enable It

Redis 6.0 adds a multithreaded network I/O model, client caching, ACL and RESP3, and explains why earlier versions were single‑threaded, how the new IO threads cooperate with the main thread, and the practical steps to enable and tune multithreading for better performance.

Database PerformanceIO Modelmultithreading
0 likes · 10 min read
Why Redis 6.0 Introduced Multithreading and How to Enable It
Linux Kernel Journey
Linux Kernel Journey
Nov 10, 2025 · Fundamentals

Multithreaded Parallel Writeback: Vivo’s Exploration of Page Cache Write Acceleration

The article examines Linux's page‑cache writeback mechanism, explains why the single‑threaded writeback path becomes a bottleneck under heavy writes, and details Vivo's multithreaded writeback patches—including inode‑to‑context mapping and sysfs‑controlled thread counts—that achieve up to 2.4 GB/s on XFS and a 22 % speedup on F2FS, while also discussing fragmentation trade‑offs and optimal thread‑to‑allocation‑group ratios.

F2FSFilesystemLinux
0 likes · 8 min read
Multithreaded Parallel Writeback: Vivo’s Exploration of Page Cache Write Acceleration
Tech Freedom Circle
Tech Freedom Circle
Nov 8, 2025 · Interview Experience

What’s the Secret Behind Python’s Multi‑Process, Multi‑Thread & Coroutine Tricks That Top Tech Interviews Demand?

This article breaks down Python’s Global Interpreter Lock, explains when to use multiprocessing, multithreading or asyncio, provides concrete performance benchmarks and a hybrid process‑coroutine pattern, and guides you on choosing the right concurrency model for interview questions.

Pythonasyncioconcurrency
0 likes · 57 min read
What’s the Secret Behind Python’s Multi‑Process, Multi‑Thread & Coroutine Tricks That Top Tech Interviews Demand?
Architecture Digest
Architecture Digest
Nov 3, 2025 · Backend Development

Ensuring Transaction Rollback in Multithreaded Spring MyBatis Operations

This article explains why @Transactional fails in multithreaded MySQL insert scenarios, demonstrates how to split large data sets, configure a thread pool, and use SqlSession with manual commit to guarantee atomicity across parallel threads, complete with runnable code examples and test results.

JavaMyBatisconcurrency
0 likes · 8 min read
Ensuring Transaction Rollback in Multithreaded Spring MyBatis Operations
JavaScript
JavaScript
Oct 30, 2025 · Frontend Development

Unlock Hidden Performance: How Web Workers Supercharge Frontend Apps

Web Workers, an often‑overlooked browser API, enable JavaScript to run heavy computations in background threads, freeing the main UI thread, boosting multi‑core utilization, improving memory management, and powering use‑cases such as big data processing, image filtering, AI inference, and encryption, dramatically enhancing frontend performance.

JavaScriptPerformance OptimizationWeb Workers
0 likes · 5 min read
Unlock Hidden Performance: How Web Workers Supercharge Frontend Apps
Architect
Architect
Oct 21, 2025 · Backend Development

Boost PostgreSQL IN Query Performance with Spring AOP SplitWork Annotation

This article explains how to improve the performance of large PostgreSQL IN queries by splitting them into smaller batches, executing them concurrently with Spring AOP and custom annotations, and then merging the results, providing a reusable solution for high‑volume database operations.

IN query optimizationJavaPostgreSQL
0 likes · 11 min read
Boost PostgreSQL IN Query Performance with Spring AOP SplitWork Annotation
JavaScript
JavaScript
Oct 2, 2025 · Frontend Development

Unlock Hidden Performance: How Web Workers Supercharge Frontend Apps

This article explains why Web Workers, an often‑overlooked browser API, can free the main thread, leverage multi‑core CPUs, and improve memory management, offering concrete scenarios and code examples to dramatically boost JavaScript performance in modern front‑end applications.

JavaScriptPerformance OptimizationWeb Workers
0 likes · 5 min read
Unlock Hidden Performance: How Web Workers Supercharge Frontend Apps
php Courses
php Courses
Sep 16, 2025 · Fundamentals

Mastering std::mutex in C++: Prevent Data Races with Simple Examples

Learn why mutexes are essential for safe multithreaded C++ programming, explore the basic std::mutex API, see practical code examples, and discover advanced lock management with std::lock_guard and other mutex types to avoid data races and deadlocks.

Cconcurrencylock_guard
0 likes · 9 min read
Mastering std::mutex in C++: Prevent Data Races with Simple Examples
Python Programming Learning Circle
Python Programming Learning Circle
Sep 15, 2025 · Fundamentals

Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them

This article explains the fundamental concepts of processes and threads, compares their definitions, lifecycles, advantages and disadvantages, and provides practical guidelines for choosing between multi‑processing and multi‑threading based on factors such as resource usage, performance, reliability, and application requirements.

Threadconcurrencymultithreading
0 likes · 19 min read
Processes vs Threads: Key Differences, Pros, Cons, and When to Use Them
php Courses
php Courses
Sep 15, 2025 · Fundamentals

Mastering std::thread: Create, Manage, and Synchronize C++ Threads

This tutorial explains the fundamentals of C++11 std::thread, covering thread creation with functions and lambdas, the use of join() and detach(), argument passing techniques, and essential best practices for safe and portable multithreaded programming.

CJOINLambda
0 likes · 10 min read
Mastering std::thread: Create, Manage, and Synchronize C++ Threads
Su San Talks Tech
Su San Talks Tech
Sep 10, 2025 · Backend Development

Master Java Backend Interview Questions: HTTP Status, JVM, Multithreading & More

This article shares Beike's recent campus hiring salary data and provides a comprehensive Java backend interview guide covering HTTP response codes, session vs. cookie, runtime and checked exceptions, abstract classes vs. interfaces, StringBuilder vs. String, JVM memory structure, multithreading techniques, thread‑pool parameters, the synchronized keyword, B+‑tree indexing, and essential Linux commands.

Backend DevelopmentJVMJava
0 likes · 23 min read
Master Java Backend Interview Questions: HTTP Status, JVM, Multithreading & More
Python Programming Learning Circle
Python Programming Learning Circle
Sep 6, 2025 · Fundamentals

Stop Reinventing the Wheel: Use Python’s Built‑In Queue for Fast, Thread‑Safe Tasks

Python developers often create simple queues with lists using append and pop(0), but this approach has O(n) complexity and thread‑safety issues; the article explains how the built‑in queue module provides efficient, thread‑safe FIFO, LIFO, and priority queues, with code examples for single‑thread and multithreaded task processing.

Producer ConsumerPythonQueue
0 likes · 5 min read
Stop Reinventing the Wheel: Use Python’s Built‑In Queue for Fast, Thread‑Safe Tasks
Deepin Linux
Deepin Linux
Sep 6, 2025 · Fundamentals

Why Memory Barriers Are Essential for Multithreaded Programming

Memory barriers act like traffic signals for concurrent threads, enforcing a strict order of memory operations to prevent data races, cache incoherence, and compiler reordering, thereby ensuring program correctness and stability across multi‑core and multi‑processor systems.

CPU orderingLinux kernelcache coherence
0 likes · 37 min read
Why Memory Barriers Are Essential for Multithreaded Programming
Architect
Architect
Sep 3, 2025 · Backend Development

Mastering Java Thread Pools: Deep Dive into ThreadPoolExecutor Architecture

This comprehensive guide explores Java thread pools, detailing their advantages, design concepts, core classes, constructors, task queues, rejection policies, lifecycle states, initialization, dynamic resizing, shutdown procedures, and the internal workings of ThreadPoolExecutor, Worker, and related methods with clear examples and diagrams.

ExecutorThreadPoolmultithreading
0 likes · 34 min read
Mastering Java Thread Pools: Deep Dive into ThreadPoolExecutor Architecture
Data STUDIO
Data STUDIO
Sep 1, 2025 · Frontend Development

Build Advanced GUI Applications with PyQt6 and Python

This article walks through setting up a Python development environment for Qt6, demonstrates core and advanced PyQt6 widgets, layout management, dialogs, graphics view, database integration, multithreading, MVC architecture, custom widgets, and a complete simple calculator example, concluding with best‑practice guidelines.

Custom WidgetsMVCPyQt6
0 likes · 19 min read
Build Advanced GUI Applications with PyQt6 and Python
Code Mala Tang
Code Mala Tang
Aug 31, 2025 · Backend Development

Boost Node.js Performance with Worker Threads: A Practical Guide

This article explains how Node.js Worker Threads enable true parallelism for CPU‑intensive tasks, prevent event‑loop blocking, improve scalability with microservices, leverage shared memory for speed, and lead to cleaner, more maintainable code, complete with real‑world examples and starter code.

Backend DevelopmentNode.jsWorker Threads
0 likes · 10 min read
Boost Node.js Performance with Worker Threads: A Practical Guide
Sohu Smart Platform Tech Team
Sohu Smart Platform Tech Team
Aug 9, 2025 · Mobile Development

Mastering iOS Locks: From Spin Locks to Semaphores Explained

This article explains the purpose, actions, and common types of locks in iOS—including spin locks, mutexes, semaphores, and read‑write locks—provides practical code examples, discusses underlying principles such as busy‑waiting and priority inversion, and compares performance across different lock implementations.

LocksSynchronizationiOS
0 likes · 18 min read
Mastering iOS Locks: From Spin Locks to Semaphores Explained
Liangxu Linux
Liangxu Linux
Aug 5, 2025 · Fundamentals

Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery

This article explains what C++11 condition variables are, why they are essential for efficient multithreading, shows their basic usage with std::condition_variable and std::mutex, walks through a producer‑consumer example, demonstrates a thread‑pool implementation, and lists crucial best‑practice tips.

C++C++11concurrency
0 likes · 15 min read
Master C++11 Condition Variables: From Basics to Thread‑Pool Mastery
Sohu Tech Products
Sohu Tech Products
Jul 23, 2025 · Mobile Development

Mastering iOS Locks: From NSLock to os_unfair_lock and Performance Tips

This article explains the relationship between locks and multithreading on iOS, introduces various lock types such as NSRecursiveLock, NSConditionLock, OSSpinLock, os_unfair_lock, pthread_mutex, and @synchronized, demonstrates resource contention with code examples, and compares their performance and usage scenarios.

LocksObjective‑CiOS
0 likes · 21 min read
Mastering iOS Locks: From NSLock to os_unfair_lock and Performance Tips
Deepin Linux
Deepin Linux
Jul 17, 2025 · Fundamentals

Why Traditional C++ Memory Management Fails and How TCMalloc Boosts Performance

Modern C++ applications face severe performance bottlenecks due to traditional memory management techniques like new/delete and malloc/free, which cause fragmentation and high overhead; TCMalloc, a thread‑caching allocator from Google, dramatically reduces latency, improves memory utilization, and scales efficiently across multithreaded workloads.

CMemory ManagementTCMalloc
0 likes · 29 min read
Why Traditional C++ Memory Management Fails and How TCMalloc Boosts Performance
Deepin Linux
Deepin Linux
Jul 15, 2025 · Operations

Why the Thundering Herd Problem Slows Your Linux Server and How to Fix It

The thundering herd problem in Linux causes multiple processes or threads to wake up simultaneously for a single event, leading to wasted CPU cycles, excessive context switches, lock contention, and severe performance degradation, but it can be mitigated with kernel tweaks, epoll flags, SO_REUSEPORT, thread pools, and other strategies.

Linux performanceacceptepoll
0 likes · 45 min read
Why the Thundering Herd Problem Slows Your Linux Server and How to Fix It
Deepin Linux
Deepin Linux
Jul 8, 2025 · Operations

Unlock Linux NUMA Performance: A Practical Multithreaded Tuning Guide

This article explains the fundamentals of NUMA architecture, why it matters for multithreaded Linux applications, and provides step‑by‑step practical guidance—including kernel internals, memory allocation policies, useful commands, and performance‑monitoring tools—to help developers optimize memory locality and boost overall program efficiency.

LinuxNUMAmultithreading
0 likes · 37 min read
Unlock Linux NUMA Performance: A Practical Multithreaded Tuning Guide
Deepin Linux
Deepin Linux
Jul 5, 2025 · Backend Development

Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained

This comprehensive guide explores C++ multithreaded network programming for high‑concurrency servers, covering threads, processes, socket basics, TCP/UDP protocols, thread pools, synchronization primitives, lock‑free structures, I/O multiplexing techniques, and a practical high‑performance chat server implementation.

C++I/O MultiplexingNetwork programming
0 likes · 54 min read
Mastering High-Concurrency C++ Servers: Multithreaded Network Programming Explained
Deepin Linux
Deepin Linux
Jul 5, 2025 · Fundamentals

Master GDB: Essential Debugging Techniques for C/C++ Developers

This comprehensive guide explains what GDB is, how to launch it, its core functions, essential debugging commands, multithreaded debugging strategies, and practical code examples, helping developers efficiently locate and fix bugs in C/C++ programs.

CDebuggingLinux
0 likes · 21 min read
Master GDB: Essential Debugging Techniques for C/C++ Developers
Deepin Linux
Deepin Linux
Jul 2, 2025 · Backend Development

How to Detect and Fix C++ Deadlocks on Linux Using Shell and GDB

This guide explains why deadlocks occur in Linux C++ multithreaded programs, demonstrates how to reproduce them with sample code, and shows step‑by‑step how to use shell commands and GDB to identify and resolve the deadlock, ensuring stable and efficient execution.

C++DebuggingLinux
0 likes · 18 min read
How to Detect and Fix C++ Deadlocks on Linux Using Shell and GDB
Architect's Guide
Architect's Guide
Jun 27, 2025 · Backend Development

Demystifying Java Locks: From Pessimistic vs Optimistic to ReentrantLock Internals

This article explains the classification of Java locks—including pessimistic, optimistic, fair, and unfair variants—details their state transitions from biased to heavyweight, and walks through the source code of ReentrantLock and Condition to illustrate how synchronization, queuing, and thread parking are implemented in the JVM.

AQSConditionLocks
0 likes · 20 min read
Demystifying Java Locks: From Pessimistic vs Optimistic to ReentrantLock Internals
Code Ape Tech Column
Code Ape Tech Column
Jun 22, 2025 · Databases

How KeyDB Transforms Redis with Multi‑Threading: Architecture & Locks

KeyDB, a Redis fork, replaces the single‑threaded design with a multi‑threaded architecture using a main thread and worker I/O threads, SO_REUSEPORT, per‑thread connection lists, fastlock spin‑lock mechanisms, asynchronous pipelines, and active‑replica support, enabling higher concurrency while remaining 100 % Redis‑compatible.

Connection ManagementKeyDBdatabase
0 likes · 8 min read
How KeyDB Transforms Redis with Multi‑Threading: Architecture & Locks
Code Mala Tang
Code Mala Tang
Jun 21, 2025 · Backend Development

When to Choose asyncio, Threads, or Multiprocessing in Python?

This article explains how to decide between asyncio, threading, and multiprocessing for Python programs by examining I/O‑bound versus CPU‑bound workloads, showing real code examples, trade‑offs, and common pitfalls to help you pick the right concurrency tool for your task.

Pythonasynciomultiprocessing
0 likes · 9 min read
When to Choose asyncio, Threads, or Multiprocessing in Python?
Code Mala Tang
Code Mala Tang
Jun 20, 2025 · Fundamentals

Boost Python Performance: Multithreading, Multiprocessing, and Best Practices

This article explains how Python’s GIL affects concurrency, when to use multithreading versus multiprocessing, and provides practical tips on efficient inter‑process communication, iteration, string handling, sorting, file I/O, and leveraging the standard library to dramatically improve script performance.

Data Structuresbest-practicesmultiprocessing
0 likes · 17 min read
Boost Python Performance: Multithreading, Multiprocessing, and Best Practices
Sohu Tech Products
Sohu Tech Products
Jun 11, 2025 · Fundamentals

Mastering iOS Locks: Types, Usage, and Performance Comparison

This article explains the relationship between locks and multithreading on iOS, introduces common lock types such as NSRecursiveLock, NSConditionLock, OSSpinLock, os_unfair_lock, pthread_mutex, and @synchronized, demonstrates resource contention with code examples, discusses lock selection, priority inversion, and provides a performance ranking of various locks.

LocksObjective‑CiOS
0 likes · 22 min read
Mastering iOS Locks: Types, Usage, and Performance Comparison
Java Captain
Java Captain
Jun 10, 2025 · Fundamentals

Understanding Java Monitors: How Thread Synchronization Works

Java monitors provide a mechanism for thread synchronization by associating each object with a monitor lock, comprising an entry list, owner thread, and wait set, and the article explains their structure, thread state transitions, and demonstrates usage with a practical code example.

JavaMonitorSynchronization
0 likes · 6 min read
Understanding Java Monitors: How Thread Synchronization Works
Su San Talks Tech
Su San Talks Tech
Jun 9, 2025 · Databases

How to Efficiently Count 100 Million Redis Keys Without Crashing Your Cluster

This article explains why the KEYS command is dangerous for large keyspaces, introduces the SCAN command and its multithreaded variants, discusses distributed counting strategies, compares built‑in counters and real‑time incremental approaches, and provides guidance on selecting the best solution for your Redis deployment.

Key CountingSCANdatabase
0 likes · 10 min read
How to Efficiently Count 100 Million Redis Keys Without Crashing Your Cluster
Lobster Programming
Lobster Programming
Jun 3, 2025 · Backend Development

How ThreadLocal Can Cause Memory Leaks in Java Multithreading

This article explains how ThreadLocal creates per‑thread variable copies, demonstrates its usage with sample Java code, illustrates the internal storage structure, and reveals why improper handling can lead to memory leaks when thread‑local values persist in thread pools.

JavaThreadLocalmemory leak
0 likes · 3 min read
How ThreadLocal Can Cause Memory Leaks in Java Multithreading
FunTester
FunTester
May 30, 2025 · Databases

MySQL Performance Testing Practice: Simulating New User Registration

This article demonstrates a practical MySQL performance test using a simulated e‑commerce scenario, detailing the user table schema, multithreaded Java code for inserting random user records, parameterized inputs, success counting, and resource management to evaluate and improve registration throughput.

Javamultithreadingmysql
0 likes · 9 min read
MySQL Performance Testing Practice: Simulating New User Registration
Deepin Linux
Deepin Linux
May 20, 2025 · Fundamentals

Understanding and Preventing Deadlocks in C++ Multithreaded Programming

This article explains what deadlocks are in C++ multithreaded programming, outlines their causes and four necessary conditions, presents common scenarios and code examples, and offers practical strategies such as consistent lock ordering, std::lock, std::scoped_lock, recursive mutexes, and lock hierarchies to avoid them.

C++Lockconcurrency
0 likes · 20 min read
Understanding and Preventing Deadlocks in C++ Multithreaded Programming
JD Tech Talk
JD Tech Talk
May 19, 2025 · Backend Development

Detailed Explanation of Java ConcurrentHashMap Source Code: Constructors, put, get, resize, and Concurrency Mechanisms

This article provides an in‑depth analysis of the Java ConcurrentHashMap implementation, covering its constructor logic, hash‑table sizing, the core put and get operations, element counting with addCount, multi‑threaded resizing via transfer, treeification of bins, removal, computeIfAbsent, and the design choices that forbid null keys and values to simplify concurrency handling.

CASConcurrentHashMapJava
0 likes · 36 min read
Detailed Explanation of Java ConcurrentHashMap Source Code: Constructors, put, get, resize, and Concurrency Mechanisms
JD Cloud Developers
JD Cloud Developers
May 19, 2025 · Backend Development

Unlocking Java’s ConcurrentHashMap: Inside Constructors, Put, and Resizing

This article provides a thorough, English‑language walkthrough of Java 8+ ConcurrentHashMap’s source code, covering its constructor logic, load‑factor handling, CAS‑based insertion, node optimizations, the put method, element‑count updates, multi‑threaded resizing, treeification, and auxiliary operations such as get, remove, and computeIfAbsent.

ConcurrentHashMapData StructuresJava
0 likes · 42 min read
Unlocking Java’s ConcurrentHashMap: Inside Constructors, Put, and Resizing
macrozheng
macrozheng
May 16, 2025 · Fundamentals

Why More Threads Can Slow Down Your Java App—and How to Optimize Context Switching

This article explains how CPU time slices, hyper‑threading, and context‑switching affect multithreaded performance, outlines the costs of thread switches, and offers practical strategies such as lock‑free programming, CAS, reducing thread count, and using coroutines to improve efficiency.

CPU schedulingHyper-threadingJava concurrency
0 likes · 11 min read
Why More Threads Can Slow Down Your Java App—and How to Optimize Context Switching
Lin is Dream
Lin is Dream
May 8, 2025 · Backend Development

Boost Large-Scale Excel Exports in Java with a Multi-Threaded EasyExcel Template

This article introduces a reusable Java template that leverages EasyExcel v3.3.2 to efficiently export massive backend datasets—such as orders or financial records—to Excel, supporting both multi‑threaded and synchronous modes, pagination, sheet splitting, and customizable query logic, thereby reducing repetitive code and improving performance.

Javaeasyexcelexcel-export
0 likes · 11 min read
Boost Large-Scale Excel Exports in Java with a Multi-Threaded EasyExcel Template
AntTech
AntTech
May 7, 2025 · Game Development

Performance Optimization Techniques for Alipay Mini‑Games Runtime

This article details the architectural analysis and a series of six optimization strategies—including multithreading, independent audio, file‑system improvements, text rendering, dedicated render thread, and iOS high‑performance mode—that collectively boost frame rates, reduce latency, and enhance the overall user experience of Alipay mini‑games.

AlipayRenderingmini-game
0 likes · 15 min read
Performance Optimization Techniques for Alipay Mini‑Games Runtime
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 6, 2025 · Backend Development

Understanding Java CyclicBarrier with Practical Examples

This article explains Java's CyclicBarrier synchronization tool, compares it with CountDownLatch, demonstrates basic and array‑sum examples with reusable barriers and callback actions, and shows how it can coordinate multiple threads for tasks such as parallel computation and result aggregation.

CyclicBarrierJavaSynchronization
0 likes · 6 min read
Understanding Java CyclicBarrier with Practical Examples
Deepin Linux
Deepin Linux
May 6, 2025 · Fundamentals

Understanding Processes and Threads: Concepts, Differences, and When to Use Them

This article explains the fundamental concepts of processes and threads, their relationship, resource allocation, scheduling, communication methods, practical use cases, and interview preparation tips, helping readers choose between multiprocessing and multithreading for various scenarios.

Threadconcurrencymultiprocessing
0 likes · 22 min read
Understanding Processes and Threads: Concepts, Differences, and When to Use Them
Full-Stack Internet Architecture
Full-Stack Internet Architecture
May 5, 2025 · Backend Development

Using CountDownLatch in Java to Synchronize Multiple Threads for a Lucky Card Collection Example

This article explains the Java CountDownLatch utility, demonstrates its countdown synchronization mechanism with a lucky‑card‑collection scenario, provides a complete runnable example, and shows how the main thread waits for all worker threads to finish before proceeding to the lottery step.

CountDownLatchJavaSynchronization
0 likes · 5 min read
Using CountDownLatch in Java to Synchronize Multiple Threads for a Lucky Card Collection Example
Cognitive Technology Team
Cognitive Technology Team
May 2, 2025 · Backend Development

Stopping Java Threads: interrupt, volatile flag, and combined approaches

This article explains three methods for safely terminating Java threads—using the interrupt mechanism, a volatile boolean flag, and a combination of both—detailing their principles, code examples, advantages, disadvantages, and a comparative summary to guide developers in choosing the appropriate technique.

JavaThread Interruptionmultithreading
0 likes · 8 min read
Stopping Java Threads: interrupt, volatile flag, and combined approaches
Sohu Tech Products
Sohu Tech Products
Apr 29, 2025 · Backend Development

Mastering Java Concurrency: Deep Dive into Threads, Locks, and AQS

This comprehensive guide explores Java multithreading fundamentals, covering thread creation, lifecycle, synchronization challenges, context switching costs, deadlock detection, various lock mechanisms such as synchronized, ReentrantLock, ReadWriteLock, and the underlying AbstractQueuedSynchronizer architecture with practical code examples and performance tips.

AQSConditionJava
0 likes · 42 min read
Mastering Java Concurrency: Deep Dive into Threads, Locks, and AQS
Alipay Experience Technology
Alipay Experience Technology
Apr 23, 2025 · Game Development

How Alipay Boosted Mini‑Game Performance with Multithreading and Rendering Optimizations

This article explains how Alipay’s mini‑games platform was optimized through multithreading, independent audio and rendering threads, file‑system and text‑rendering improvements, and an iOS high‑performance mode, resulting in dramatically higher frame rates and lower latency across a range of games.

AlipayGame DevelopmentRendering
0 likes · 16 min read
How Alipay Boosted Mini‑Game Performance with Multithreading and Rendering Optimizations
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Apr 23, 2025 · Backend Development

Efficient Large File Processing in Node.js: Stream, Buffer, and Multithreading Techniques

This article explains how to handle massive HDFS‑derived text and CSV files in Node.js by analyzing memory and CPU bottlenecks, comparing client‑side upload strategies, and presenting synchronous, callback, promise, streaming, and multithreaded worker‑thread solutions with complete code examples.

Node.jsStreamsfile I/O
0 likes · 13 min read
Efficient Large File Processing in Node.js: Stream, Buffer, and Multithreading Techniques
Deepin Linux
Deepin Linux
Apr 21, 2025 · Backend Development

POSIX Multithreading and Network Programming in C: Threads, Synchronization, and Socket APIs

This article introduces the POSIX standard for portable multithreaded and network programming in C, explains thread creation, lifecycle, and synchronization mechanisms such as mutexes, semaphores and condition variables, and provides complete server‑client socket examples together with practical multithreaded file‑processing code and debugging tips.

CPOSIXSocket
0 likes · 23 min read
POSIX Multithreading and Network Programming in C: Threads, Synchronization, and Socket APIs
Top Architect
Top Architect
Apr 18, 2025 · Backend Development

Optimizing XML-to-MySQL Import: Reducing Execution Time from 300 s to 4 s with Batch Processing and Multithreading

This article details how to dramatically speed up importing over 60,000 XML records into MySQL by profiling the original 300‑second implementation, enabling JDBC batch writes, configuring MySQL rewriteBatchedStatements, and applying a Disruptor‑based multithreaded pipeline, ultimately achieving sub‑5‑second runtimes with modest memory usage.

BatchProcessingDisruptorJava
0 likes · 15 min read
Optimizing XML-to-MySQL Import: Reducing Execution Time from 300 s to 4 s with Batch Processing and Multithreading
php Courses
php Courses
Apr 18, 2025 · Fundamentals

Understanding Multithreading in Python with the threading Module

This article explains Python's multithreading concepts, covering thread creation via subclassing Thread or using target functions, synchronization mechanisms like Lock, RLock, and Condition, and discusses the impact of the Global Interpreter Lock, helping readers apply threading effectively for I/O‑bound tasks.

GILPythonSynchronization
0 likes · 9 min read
Understanding Multithreading in Python with the threading Module
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 1, 2025 · Fundamentals

Why Do Deadlocks Happen and How Can You Prevent Them?

This article explains what deadlocks are, outlines the four classic conditions that cause them, provides Java thread and MySQL transaction examples, and offers practical solutions such as consistent lock ordering, timeout settings, batch updates, and shortening transaction duration to prevent deadlocks.

concurrencydatabasedeadlock
0 likes · 5 min read
Why Do Deadlocks Happen and How Can You Prevent Them?
JavaScript
JavaScript
Mar 29, 2025 · Frontend Development

Unlock Faster Frontend Performance with Web Workers: The Hidden Power

This article explains how Web Workers can dramatically improve frontend performance by offloading heavy computations from the main thread, detailing their benefits, common misconceptions, practical use cases like data processing and image filtering, and providing a concrete code example for real‑world implementation.

JavaScriptPerformance Optimizationfrontend
0 likes · 5 min read
Unlock Faster Frontend Performance with Web Workers: The Hidden Power
Top Architecture Tech Stack
Top Architecture Tech Stack
Mar 27, 2025 · Fundamentals

Understanding Time Slices, Hyper‑Threading, and Thread Context Switching

The article explains how modern multi‑core CPUs use time slices, hyper‑threading, and various types of context switches to manage multithreaded workloads, discusses the performance costs of switching, and offers practical optimization strategies such as lock‑free programming, appropriate thread counts, and coroutine usage.

CPU schedulingHyper-threadingJava
0 likes · 9 min read
Understanding Time Slices, Hyper‑Threading, and Thread Context Switching
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Mar 20, 2025 · Backend Development

Why Does Pointer Collision Cause Concurrency Bugs in Java and How to Fix It?

Pointer collision is an efficient memory allocation technique that can trigger severe concurrency problems in multithreaded Java environments, and this article explains the underlying causes, illustrates conflict scenarios, and presents common remedies such as CAS (Compare‑And‑Swap) and TLAB (Thread‑Local Allocation Buffer) with sample code.

CASJavaTLAB
0 likes · 6 min read
Why Does Pointer Collision Cause Concurrency Bugs in Java and How to Fix It?
Architecture Development Notes
Architecture Development Notes
Mar 16, 2025 · Backend Development

Choosing the Right Concurrency Model: Go vs Python vs Rust

This article compares Go, Python, and Rust concurrency implementations—covering CSP‑based goroutines, GIL constraints, and ownership‑driven thread safety—to help developers select the most suitable model for high‑throughput, CPU‑bound, or safety‑critical applications.

AsyncGoParallelism
0 likes · 9 min read
Choosing the Right Concurrency Model: Go vs Python vs Rust
Cognitive Technology Team
Cognitive Technology Team
Mar 9, 2025 · Fundamentals

Understanding Concurrency Levels: Blocking, Starvation‑Free, Obstruction‑Free, Lock‑Free, and Wait‑Free in Java

The article explains five fundamental concurrency levels—Blocking, Starvation‑Free, Obstruction‑Free, Lock‑Free, and Wait‑Free—detailing their definitions, implementation mechanisms in Java, performance trade‑offs, suitable scenarios, and practical decision guidance for building high‑performance, reliable systems.

Javahigh‑concurrencymultithreading
0 likes · 6 min read
Understanding Concurrency Levels: Blocking, Starvation‑Free, Obstruction‑Free, Lock‑Free, and Wait‑Free in Java
FunTester
FunTester
Mar 8, 2025 · Backend Development

How to Add Real‑Time TPS and Latency Display to a Java Performance Test Engine

Implementing real‑time statistics in a Java performance testing engine involves adding TPS and average latency counters, creating a controllable monitoring thread, using LongAdder for high‑concurrency metrics, and gracefully shutting down the thread, enabling testers to instantly observe system load and detect bottlenecks.

JavaPerformance Testinglongadder
0 likes · 6 min read
How to Add Real‑Time TPS and Latency Display to a Java Performance Test Engine
Linux Kernel Journey
Linux Kernel Journey
Feb 23, 2025 · Fundamentals

Debugging C++ Deadlocks on Linux with Shell Commands and GDB

This article explains how to identify and resolve multithreaded deadlocks in Linux C++ programs by using shell utilities such as ps and top for initial diagnosis, then attaching GDB to inspect thread stacks and pinpoint the exact lock contention causing the freeze.

CLinuxShell
0 likes · 20 min read
Debugging C++ Deadlocks on Linux with Shell Commands and GDB
FunTester
FunTester
Feb 23, 2025 · Operations

How to Efficiently Process Test Data in a Multithreaded Performance Engine

This article explains two design approaches for handling test data in a multithreaded performance testing engine, compares their trade‑offs, and provides complete Java code for data aggregation, statistical analysis, TPS calculation, and refactoring the tool for cleaner extensibility.

BackendData StatisticsJava
0 likes · 14 min read
How to Efficiently Process Test Data in a Multithreaded Performance Engine
FunTester
FunTester
Feb 20, 2025 · Backend Development

How to Build a Custom Multithreaded Test Engine in Java

This article walks through designing and implementing a Java multithreaded execution class for performance testing, covering thread‑pool creation, task coordination with CountDownLatch, start/stop control, and a complete demo that runs concurrent tasks with timed logging.

CountDownLatchJavaPerformance Testing
0 likes · 10 min read
How to Build a Custom Multithreaded Test Engine in Java
Sohu Tech Products
Sohu Tech Products
Feb 19, 2025 · Fundamentals

Deep Dive into ReentrantLock: Fair Lock vs Non-Fair Lock Implementation Principles

The article explains Java’s ReentrantLock implementation, contrasting fair locks that queue threads in request order with non‑fair locks that allow immediate acquisition, detailing the internal Sync, FairSync and NonfairSync classes, lock/unlock mechanisms, performance trade‑offs, and guidance on selecting the appropriate lock type.

AQSJUCJava concurrency
0 likes · 19 min read
Deep Dive into ReentrantLock: Fair Lock vs Non-Fair Lock Implementation Principles
Deepin Linux
Deepin Linux
Feb 14, 2025 · Fundamentals

Understanding Jemalloc: Principles, Comparisons, and Optimization Practices

This article provides a comprehensive overview of Jemalloc, covering its architecture, memory allocation fundamentals, performance comparison with ptmalloc and tcmalloc, practical optimization cases across web, database, and big‑data workloads, and detailed configuration guidelines to improve memory efficiency and multithreaded performance.

Performance Optimizationfragmentationjemalloc
0 likes · 31 min read
Understanding Jemalloc: Principles, Comparisons, and Optimization Practices
FunTester
FunTester
Feb 14, 2025 · Fundamentals

Design and Implementation of a Multithreaded Task Class in Java for Performance Testing

This article explains the design and implementation of a flexible, extensible Java multithreaded task class for performance testing, covering the choice of Runnable over Thread, execution control mechanisms, data collection methods, and sample abstract code illustrating before, test, and after lifecycle hooks.

Abstract ClassAtomicBooleanJava
0 likes · 10 min read
Design and Implementation of a Multithreaded Task Class in Java for Performance Testing