BestHub
Sign in
Tagged articles

multithreading

643 articles · Page 4 of 7
Top Architect
Top Architect
Aug 26, 2022 · Backend Development

Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations

This article explains thread safety in Java by detailing how the synchronized keyword and various Lock implementations work, covering their underlying JVM mechanisms, lock upgrade paths, optimizations like biased and lightweight locks, and practical differences between synchronized, ReentrantLock, and ReadWriteLock.

JVMJavaReadWriteLock
0 likes · 19 min read
Deep Dive into Java synchronized and Lock Mechanisms: Principles, JVM Internals, and Optimizations
Tuanzi Tech Team
Tuanzi Tech Team
Aug 25, 2022 · Fundamentals

Unlocking Java’s Memory Model: CPU Caches, Cache Coherence, and Thread Safety

This article explains the hardware memory hierarchy, CPU multi‑level caches, cache coherence protocols, and how Java’s memory model abstracts these concepts to ensure thread safety, covering local and main memory, synchronization primitives, and the three core properties of atomicity, visibility, and ordering.

CPUCacheJavaMemoryModel
0 likes · 17 min read
Unlocking Java’s Memory Model: CPU Caches, Cache Coherence, and Thread Safety
Python Programming Learning Circle
Python Programming Learning Circle
Aug 19, 2022 · Backend Development

Essential Python Web Scraping Techniques: GET/POST Requests, Proxy IPs, Cookie Handling, Header Spoofing, Gzip Compression, and Multithreading

This article presents a comprehensive guide to Python web scraping, covering basic GET and POST requests with urllib2, using proxy IPs, managing cookies, disguising as a browser via custom headers, handling gzip-compressed responses, and accelerating crawls with a simple multithreaded worker pool.

cookiesgzipmultithreading
0 likes · 8 min read
Essential Python Web Scraping Techniques: GET/POST Requests, Proxy IPs, Cookie Handling, Header Spoofing, Gzip Compression, and Multithreading
Su San Talks Tech
Su San Talks Tech
Aug 19, 2022 · Fundamentals

Master Java Concurrency: 60+ Interview Q&A on Threads, Locks & Thread Pools

This comprehensive guide explores Java concurrency fundamentals, covering thread creation, lifecycle, synchronization mechanisms, lock implementations, thread-local storage, memory model, atomic classes, common concurrency utilities, and detailed explanations of thread pools, their configurations, states, and best practices, accompanied by over sixty interview-style questions and code examples.

JavaSynchronizationThreadPool
0 likes · 81 min read
Master Java Concurrency: 60+ Interview Q&A on Threads, Locks & Thread Pools
Java Architect Essentials
Java Architect Essentials
Aug 18, 2022 · Backend Development

Batch Processing with Multithreading in Java: Splitting Large Collections and Using Thread Pools

This article explains how to efficiently handle massive data batch updates in Java by splitting large collections into smaller chunks, processing them concurrently with a configurable ThreadPoolExecutor, and controlling execution order, while providing reusable utility code and practical implementation examples.

ApacheCommonsBatchProcessingGuava
0 likes · 8 min read
Batch Processing with Multithreading in Java: Splitting Large Collections and Using Thread Pools
Shepherd Advanced Notes
Shepherd Advanced Notes
Aug 18, 2022 · Databases

Is Redis Really Single‑Threaded? Exploring Redis 6.0 Multithreading and Bottlenecks

The article explains why Redis has traditionally been single‑threaded, details the new IO‑thread multithreading model introduced in Redis 6.0, walks through its four processing stages, lists essential INFO monitoring commands, examines memory overhead of strings versus hashes, compares List and Sorted Set ordering, and identifies five key performance‑blocking points.

Blocking operationsINFO commandIO threads
0 likes · 17 min read
Is Redis Really Single‑Threaded? Exploring Redis 6.0 Multithreading and Bottlenecks
Node Underground
Node Underground
Aug 15, 2022 · Backend Development

Boost Node.js Performance with Worker Threads: A Hands‑On Guide

Node.js runs JavaScript on a single thread, limiting CPU‑intensive tasks, but the worker‑threads module enables developers to spawn hidden threads, offload heavy computations, and prevent main‑thread blocking, with a practical example showing how to parallelize a CPU‑bound task across multiple workers.

CPU-intensiveNode.jsmultithreading
0 likes · 4 min read
Boost Node.js Performance with Worker Threads: A Hands‑On Guide
Su San Talks Tech
Su San Talks Tech
Aug 14, 2022 · Backend Development

9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution

Switching from single‑threaded synchronous calls to multithreaded asynchronous execution can boost performance, but it also introduces nine common problems—including missing return values, data loss, ordering issues, thread‑safety bugs, ThreadLocal anomalies, OOM, high CPU usage, transaction failures, and service crashes—that developers must understand and mitigate.

JavaThreadLocalThreadPool
0 likes · 19 min read
9 Hidden Pitfalls When Converting Synchronous Code to Multithreaded Execution
ELab Team
ELab Team
Aug 11, 2022 · Frontend Development

Why Front‑End Developers Should Try Rust: Learning Curve, Pros, Cons & Use Cases

From a front‑end developer’s viewpoint, this article examines Rust’s learning curve, pros and cons compared with JavaScript/TypeScript, performance benchmarks, multithreading, testing, and real‑world application scenarios such as tooling, WebAssembly, and desktop clients, while also providing learning resources and reference links.

WebAssemblyfrontend developmentmultithreading
0 likes · 14 min read
Why Front‑End Developers Should Try Rust: Learning Curve, Pros, Cons & Use Cases
Top Architect
Top Architect
Jul 18, 2022 · Backend Development

Understanding ThreadPoolExecutor Parameters and Working Mechanism in Java

This article explains the core concepts, configurable parameters, and execution workflow of Java's ThreadPoolExecutor, illustrating each setting with analogies, code examples, and step‑by‑step analysis to help developers design safe and efficient thread pools.

JavaThreadPoolThreadPoolExecutor
0 likes · 8 min read
Understanding ThreadPoolExecutor Parameters and Working Mechanism in Java
Sohu Tech Products
Sohu Tech Products
Jul 13, 2022 · Mobile Development

What Is a Lock? Understanding iOS Synchronization Primitives

This article explains the concept of locks in iOS, describing their purpose, the actions of acquiring and releasing, common lock types such as spin locks, mutexes, semaphores, and their implementations using OSSpinLock, pthread_mutex, NSCondition, NSLock, recursive locks, and read‑write locks, along with performance considerations and underlying principles.

LocksSynchronizationconcurrency
0 likes · 19 min read
What Is a Lock? Understanding iOS Synchronization Primitives
Java Backend Technology
Java Backend Technology
Jul 12, 2022 · Backend Development

Boost Java Batch Updates with Multithreading: A Practical Guide

This article explains how to efficiently handle large‑scale batch updates in Java by splitting the data set, using a thread pool for concurrent processing, and providing reusable utility code, all illustrated with a clear workflow diagram and step‑by‑step examples.

Batch ProcessingJavabackend
0 likes · 7 min read
Boost Java Batch Updates with Multithreading: A Practical Guide
Python Programming Learning Circle
Python Programming Learning Circle
Jul 5, 2022 · Fundamentals

12 Essential Python Code Snippets for Everyday Programming

This article presents twelve practical Python code snippets—including regular‑expression validation, list slicing, swapping without a temporary variable, f‑strings, dictionary inversion, multithreading, most‑common element detection, CSV parsing, and more—to help developers write concise, efficient code without lengthy boilerplate.

CSVcode snippetslist slicing
0 likes · 9 min read
12 Essential Python Code Snippets for Everyday Programming
IT Services Circle
IT Services Circle
Jul 5, 2022 · Backend Development

Optimizing feapder Spider with Gevent: Reducing CPU Usage and Thread Count

This article demonstrates how adding two gevent monkey‑patch lines to a feapder spider reduces CPU usage from 121% to 99% while changing the effective thread count from 36 to 12, and discusses the underlying principle, performance trade‑offs, and future directions for coroutine support.

CPU optimizationPythonfeapder
0 likes · 6 min read
Optimizing feapder Spider with Gevent: Reducing CPU Usage and Thread Count
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Jul 4, 2022 · Backend Development

Understanding Netty’s Multithreaded Reactor Model and Its Application in an Online Customer Service IM System

This article explains Netty’s multithreaded Reactor architecture, introduces the underlying concepts such as Channel, ChannelPipeline, and EventLoop, shows how threads are allocated to ChannelHandlers, and demonstrates how to customize thread pools for customer‑service and agent‑side logic in an IM system.

Backend DevelopmentEventLoopJava
0 likes · 21 min read
Understanding Netty’s Multithreaded Reactor Model and Its Application in an Online Customer Service IM System
Su San Talks Tech
Su San Talks Tech
Jul 4, 2022 · Fundamentals

Understanding CPU Cache False Sharing and How to Eliminate It

This article explains the concept of CPU cache false sharing, how it degrades performance on multi‑core systems, and provides practical techniques—including cache‑line alignment macros and padding strategies—to prevent it and improve multithreaded application efficiency.

CPU cachePerformance Optimizationcache line
0 likes · 10 min read
Understanding CPU Cache False Sharing and How to Eliminate It
360 Quality & Efficiency
360 Quality & Efficiency
Jul 1, 2022 · Backend Development

Common Issues and Solutions When Using HttpRunner for API Automation Testing

This article summarizes practical problems encountered with HttpRunner—such as YAML parsing errors, missing attributes, duplicate assertions, custom function parameter issues, and performance bottlenecks—and provides detailed debugging steps, code patches, multithreading enhancements, and report‑optimization techniques for large‑scale API test suites.

API testingHttpRunnerYAML
0 likes · 8 min read
Common Issues and Solutions When Using HttpRunner for API Automation Testing
Programmer DD
Programmer DD
Jun 29, 2022 · Fundamentals

Why Real-World Analogies Reveal the 3 Core Challenges of Concurrent Programming

The article explains that concurrent programming is deeply tied to real-life scenarios and outlines its three core problems—division of work, synchronization, and mutual exclusion—using company organization, task dependencies, and traffic flow analogies, plus Java code examples to illustrate each concept.

JavaSynchronizationconcurrency
0 likes · 9 min read
Why Real-World Analogies Reveal the 3 Core Challenges of Concurrent Programming
FunTester
FunTester
Jun 14, 2022 · Backend Development

Why ConcurrentHashMap Slows Down with Hundreds of Threads? A Deep Performance Test

This article presents a detailed benchmark of java.util.concurrent.ConcurrentHashMap under high thread counts, explains the test methodology using a Groovy‑based FunTester framework, shares raw performance numbers, and uncovers that CPU limits and random number generation are the primary bottlenecks.

JavaThreadLocalRandombenchmark
0 likes · 7 min read
Why ConcurrentHashMap Slows Down with Hundreds of Threads? A Deep Performance Test
Architect
Architect
May 24, 2022 · Big Data

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

The article presents a complete Java solution for generating, reading, and analyzing a 10 GB file of age values (18‑70) on a 4 GB RAM, 2‑core PC, comparing single‑threaded counting with a producer‑consumer multithreaded design that dramatically improves CPU utilization and reduces total processing time.

JavaPerformance OptimizationProducer Consumer
0 likes · 20 min read
Processing 10 GB Age Data on a 4 GB Memory Machine Using Java: Single‑Threaded and Multi‑Threaded Approaches
vivo Internet Technology
vivo Internet Technology
May 18, 2022 · Mobile Development

Optimizing Android PopupWindow and Snackbar UI Thread to Prevent Frame Drops

To eliminate frame drops caused by animated PopupWindow and Snackbar conflicts, the article shows how moving costly view inflation and show/dismiss operations to a dedicated HandlerThread—while still invoking show() on the UI thread—creates a separate UI thread that respects Android’s thread‑checking rules and keeps animations smooth.

AndroidPerformance OptimizationPopupWindow
0 likes · 20 min read
Optimizing Android PopupWindow and Snackbar UI Thread to Prevent Frame Drops
Selected Java Interview Questions
Selected Java Interview Questions
May 14, 2022 · Backend Development

Optimizing Large‑Scale MySQL Updates with Manual Transactions and Multithreading in Spring Boot

This article demonstrates how to accelerate massive MySQL data updates in a Spring Boot application by replacing naïve loops with manual transaction control, multithreaded processing, CountDownLatch synchronization, and UNION‑based SQL batching, achieving up to a five‑fold speed increase.

Batch UpdateMyBatisTransaction Management
0 likes · 14 min read
Optimizing Large‑Scale MySQL Updates with Manual Transactions and Multithreading in Spring Boot
Sohu Tech Products
Sohu Tech Products
May 11, 2022 · Backend Development

Optimizing Large-Scale Database Updates with Manual Transactions and Multithreading in Spring Boot MyBatis

This article demonstrates how to efficiently update up to 50,000 MySQL records in a Spring Boot‑MyBatis application by comparing simple loops, manual transaction control, multithreaded execution with CountDownLatch coordination, and union‑based batch updates, while analyzing performance and connection‑pool considerations.

MyBatisPerformance OptimizationSpring Boot
0 likes · 14 min read
Optimizing Large-Scale Database Updates with Manual Transactions and Multithreading in Spring Boot MyBatis
Code Ape Tech Column
Code Ape Tech Column
May 5, 2022 · Backend Development

Optimizing Bulk Database Updates with Manual Transactions and Multithreading in Spring/MyBatis

This article demonstrates how to dramatically speed up updating tens of thousands of records in a Spring‑MyBatis application by switching from automatic per‑operation commits to manual transaction control, applying multithreaded processing, tuning the Hikari connection pool, and using SQL UNION‑based batch updates.

MyBatisSpringTransaction
0 likes · 13 min read
Optimizing Bulk Database Updates with Manual Transactions and Multithreading in Spring/MyBatis
Su San Talks Tech
Su San Talks Tech
May 2, 2022 · Fundamentals

12 Real-World Java Concurrency Scenarios Every Developer Should Master

This article explores twelve practical multithreading use cases in Java, ranging from simple scheduled tasks and listeners to Excel imports, remote call aggregation, user context handling, MDC logging, high‑concurrency simulation, Kafka message processing, atomic counters, and delayed jobs, providing code examples and best‑practice tips for each scenario.

JavaSpringThreadPool
0 likes · 25 min read
12 Real-World Java Concurrency Scenarios Every Developer Should Master
Snowball Engineer Team
Snowball Engineer Team
Apr 2, 2022 · Mobile Development

Startup Optimization for the Snowball Android App: Principles, Problem Attribution, and Solutions

This article explains the fundamentals of Android app startup, categorizes cold, hot, and warm launches, identifies performance bottlenecks using tools like ADB, Systrace, and Traceview, and presents concrete optimization strategies for Application creation and splash-screen rendering that reduce launch time by up to 60 percent.

AndroidPerformance OptimizationSystrace
0 likes · 12 min read
Startup Optimization for the Snowball Android App: Principles, Problem Attribution, and Solutions
FunTester
FunTester
Mar 28, 2022 · Backend Development

Why LongAdder Beats AtomicLong in High‑Concurrency Java Performance Tests

This article explains how Java's LongAdder works, compares its API and performance to AtomicLong, provides usage examples and a benchmark showing its superior throughput under high thread contention, while noting its higher memory cost and appropriate scenarios for adoption.

Javaatomiclongconcurrency
0 likes · 7 min read
Why LongAdder Beats AtomicLong in High‑Concurrency Java Performance Tests
Code Ape Tech Column
Code Ape Tech Column
Mar 10, 2022 · Backend Development

10 Common Pitfalls in Java Concurrency and How to Avoid Them

This article outlines ten typical concurrency pitfalls in Java—including SimpleDateFormat thread‑safety, double‑checked locking flaws, volatile atomicity limits, deadlocks, lock release issues, HashMap race conditions, default thread‑pool misuse, @Async thread explosion, spin‑lock CPU waste, and ThreadLocal memory leaks—providing explanations, code examples, and practical solutions for each.

JavaSpringconcurrency
0 likes · 20 min read
10 Common Pitfalls in Java Concurrency and How to Avoid Them
Architect's Tech Stack
Architect's Tech Stack
Mar 2, 2022 · Backend Development

Advanced Java Debugging Techniques: Conditional Breakpoints, Drop Frame, Multithreaded and Remote Debugging

This article explains practical Java debugging tricks such as setting conditional breakpoints, using Drop Frame to revisit previous execution points, handling multithreaded breakpoints, configuring remote debugging, and evaluating or modifying expressions on the fly to streamline development and troubleshooting.

Conditional BreakpointIntelliJJava
0 likes · 6 min read
Advanced Java Debugging Techniques: Conditional Breakpoints, Drop Frame, Multithreaded and Remote Debugging
Su San Talks Tech
Su San Talks Tech
Feb 23, 2022 · Fundamentals

Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency

This article examines why Java's synchronized keyword can become ineffective when locking on an Integer object, explores how autoboxing and Integer caching cause lock objects to change, and presents reliable alternatives such as class‑level locks or explicit lock maps for safe multithreaded programming.

IntegerLockingconcurrency
0 likes · 18 min read
Why Does synchronized Fail with Integer Locks? Deep Dive into Java Concurrency
Top Architect
Top Architect
Feb 1, 2022 · Fundamentals

Understanding CPU Cache Hierarchy, Cache Coherence, and Performance Optimization

This article explains the structure of modern CPU caches, the principles of cache lines, associativity, and coherence protocols, and demonstrates how these hardware details affect program performance through multiple code examples covering loop stride, matrix traversal, multithreading, and false sharing.

CPU cacheMemory HierarchyPerformance Optimization
0 likes · 21 min read
Understanding CPU Cache Hierarchy, Cache Coherence, and Performance Optimization
Yiche Technology
Yiche Technology
Jan 27, 2022 · Backend Development

C++ Multithreaded Service Architecture for High‑Throughput AI Inference

The article explains how to design a C++‑based multithreaded service that uses Pthreads, channels, and TensorRT to parallelize deep‑learning inference tasks, thereby reducing latency and dramatically increasing throughput for AI applications such as facial‑recognition access control systems.

AI inferenceC#TensorRT
0 likes · 11 min read
C++ Multithreaded Service Architecture for High‑Throughput AI Inference
Selected Java Interview Questions
Selected Java Interview Questions
Jan 25, 2022 · Fundamentals

Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods

This article examines how Java's synchronized keyword and ReentrantLock behave when multiple threads invoke two synchronized methods of the same class, exploring scenarios with the same instance, different instances, and Runnable run methods, and summarizing the resulting concurrency rules.

JavaReentrantLockSynchronization
0 likes · 15 min read
Understanding Java synchronized and ReentrantLock: When Multiple Threads Can Access Synchronized Methods
Architecture Digest
Architecture Digest
Jan 24, 2022 · Fundamentals

Understanding Python Threads, Processes, GIL, and the multiprocessing & concurrent.futures Modules

This article explains the fundamental differences between threads and processes, the role of Python's Global Interpreter Lock, and provides a comprehensive guide to using the multiprocessing and concurrent.futures modules—including their main classes, synchronization primitives, and practical code examples—for effective concurrent programming in Python.

GILMultiprocessingPython
0 likes · 40 min read
Understanding Python Threads, Processes, GIL, and the multiprocessing & concurrent.futures Modules
FunTester
FunTester
Jan 6, 2022 · Backend Development

A Simple Custom Wait Method for Java/Groovy Multithreaded Tests

The article explains how to create a lightweight custom waiting utility in Java (using Groovy syntax) that repeatedly checks a condition every 0.5 seconds, simplifying thread synchronization for performance testing of multithreaded code.

CustomWaitGroovyJava
0 likes · 5 min read
A Simple Custom Wait Method for Java/Groovy Multithreaded Tests
Tencent Cloud Developer
Tencent Cloud Developer
Jan 4, 2022 · Fundamentals

Smart Pointers in C++: Problems Solved, Usage, Best Practices, and Implementation Details

C++11 smart pointers—unique_ptr, shared_ptr, and weak_ptr—replace manual new/delete by providing exclusive, shared, and non‑owning ownership semantics, automatically preventing leaks and dangling references, simplifying multithreaded code, and, when used with best‑practice guidelines, avoid common pitfalls such as double deletions and cyclic dependencies.

C++multithreadingshared_ptr
0 likes · 24 min read
Smart Pointers in C++: Problems Solved, Usage, Best Practices, and Implementation Details
Code Ape Tech Column
Code Ape Tech Column
Jan 4, 2022 · Backend Development

How to Enable Multithreaded Scheduled Tasks in Spring Boot

This article explains why Spring Boot's default scheduled tasks run on a single thread and demonstrates three practical ways to configure multithreaded scheduling using SchedulingConfigurer, application properties, and the @Async annotation with a custom thread pool.

ConfigurationJavaSpring Boot
0 likes · 4 min read
How to Enable Multithreaded Scheduled Tasks in Spring Boot
Open Source Linux
Open Source Linux
Dec 16, 2021 · Fundamentals

From Mechanical Calculators to Modern CPUs: Exploring Computer Fundamentals and Java Concurrency

This comprehensive guide traces the evolution of computing from early mechanical calculators to today's CPUs, delving into binary systems, memory hierarchies, synchronization primitives, thread states, lock mechanisms, and Java concurrency intricacies, while providing code examples, diagrams, and interview insights for developers.

CPU architectureJava concurrencyLocks
0 likes · 38 min read
From Mechanical Calculators to Modern CPUs: Exploring Computer Fundamentals and Java Concurrency
Programmer DD
Programmer DD
Dec 12, 2021 · Backend Development

How to Trace Multi‑Threaded Requests with SLF4J MDC in Java

This article explains how to use SLF4J's MDC feature to attach a request ID to log entries, enabling fast filtering of all logs belonging to a single request even across asynchronous threads and thread pools, and shows a decorator‑based solution for proper propagation.

JavaLoggingMDC
0 likes · 10 min read
How to Trace Multi‑Threaded Requests with SLF4J MDC in Java
FunTester
FunTester
Nov 18, 2021 · Backend Development

Dynamic Load Adjustment in FunTester: A Step‑by‑Step Implementation Guide

This article explains how to redesign the FunTester framework to enable real‑time pressure scaling by treating each multithreaded task as a manageable object, adding interrupt capabilities, and implementing global management for dynamic thread addition, removal, and cloning during load testing.

Dynamic ScalingFunTesterJava
0 likes · 12 min read
Dynamic Load Adjustment in FunTester: A Step‑by‑Step Implementation Guide
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 11, 2021 · Fundamentals

Understanding and Implementing the CLH Spin Lock in Java

This article explains the concepts of spin locks and mutexes, introduces the CLH lock as a fair spin lock used in Java's AbstractQueuedSynchronizer, and provides a detailed step‑by‑step walkthrough of its initialization, lock acquisition, release, testing, and common pitfalls with illustrative code and diagrams.

AQSCLHLockJava
0 likes · 17 min read
Understanding and Implementing the CLH Spin Lock in Java
Java Tech Enthusiast
Java Tech Enthusiast
Nov 9, 2021 · Fundamentals

Understanding Variable Visibility and the volatile Keyword in Java

The article explains Java’s variable‑visibility problem in multithreaded code, describes the Java Memory Model and the happens‑before rules, and shows how synchronization or declaring a field volatile (as in double‑checked‑locking Singleton) guarantees that updates become visible across threads and prevents instruction reordering.

JMMJavamultithreading
0 likes · 13 min read
Understanding Variable Visibility and the volatile Keyword in Java
Python Programming Learning Circle
Python Programming Learning Circle
Oct 28, 2021 · Backend Development

Scraping and Analyzing Douban Top250 Movies with Python

This tutorial shows how to use Python to crawl Douban's Top250 movie list, handle anti‑scraping measures, extract detailed fields, store the data in Excel, and perform data cleaning, statistical analysis, and visualizations such as year distribution, rating trends, and genre word clouds.

PandasPyechartsdata-analysis
0 likes · 12 min read
Scraping and Analyzing Douban Top250 Movies with Python
Java Interview Crash Guide
Java Interview Crash Guide
Oct 18, 2021 · Backend Development

Why Thread Safety Fails in Java and How to Ensure It

This article explains how variable sharing in multithreaded Java programs leads to thread‑unsafe behavior, explores the JVM memory model and stack frame structure, and demonstrates practical ways to achieve thread safety by keeping variables thread‑local or using proxy objects.

JVMJavaconcurrency
0 likes · 10 min read
Why Thread Safety Fails in Java and How to Ensure It
FunTester
FunTester
Oct 13, 2021 · Operations

Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo

This article details the design and implementation of a dynamic pressure model for the FunTester performance testing framework, covering the goal of flexible load adjustments, core features, multithread synchronization using Phaser, code examples, a demo execution, console output analysis, and identified limitations.

FunTesterJava concurrencyPhaser
0 likes · 15 min read
Dynamic Load Adjustment in FunTester: A Real‑World Pressure‑Control Demo
MaGe Linux Operations
MaGe Linux Operations
Oct 9, 2021 · Fundamentals

Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained

This article delves into Python's threading module, explaining thread safety, the role of various lock types—including Lock, RLock, Condition, Event, and Semaphore—along with their methods, usage patterns, common pitfalls like deadlocks, and practical code examples to illustrate proper synchronization techniques.

LocksSynchronizationconcurrency
0 likes · 25 min read
Master Python Thread Synchronization: Locks, RLocks, Conditions, Events & Semaphores Explained
Programmer DD
Programmer DD
Sep 29, 2021 · Backend Development

When and How to Use CountDownLatch and CyclicBarrier in Java

This article explains the purpose, usage, and real‑world scenarios of Java’s CountDownLatch and CyclicBarrier synchronization aids, illustrating their behavior with relatable analogies and providing guidance on when to apply each construct in multithreaded applications.

CountDownLatchCyclicBarrierJava
0 likes · 4 min read
When and How to Use CountDownLatch and CyclicBarrier in Java
MaGe Linux Operations
MaGe Linux Operations
Sep 18, 2021 · Backend Development

How to Build a Python Crawler to Grab TV Drama Links Automatically

This article explains how to create a Python web crawler that automatically generates URLs for a drama‑download site, filters out invalid pages, extracts ed2k links using requests and regular expressions, saves them to text files, and employs multithreading to speed up processing, while discussing challenges such as duplicate URLs and filename sanitization.

CrawlerWeb Scrapingmultithreading
0 likes · 7 min read
How to Build a Python Crawler to Grab TV Drama Links Automatically
Ops Development Stories
Ops Development Stories
Sep 13, 2021 · Backend Development

Mastering Java Locks: When to Use synchronized vs ReentrantLock

This article explains how Java locks solve concurrent access problems, compares the built‑in synchronized lock with ReentrantLock, describes their upgrade mechanisms, usage patterns, and scenarios, and offers guidance on choosing the appropriate lock for different environments.

JavaLocksReentrantLock
0 likes · 7 min read
Mastering Java Locks: When to Use synchronized vs ReentrantLock
Python Programming Learning Circle
Python Programming Learning Circle
Aug 31, 2021 · Backend Development

Python Web Crawler for Downloading Drama Links from cn163.net

This article describes how to build a Python web crawler that automatically generates numeric URLs, checks their validity, extracts download links for TV dramas from cn163.net, saves them to text files, and discusses practical challenges such as regex parsing, filename restrictions, and multithreading performance.

Pythoncrawlingfile-handling
0 likes · 7 min read
Python Web Crawler for Downloading Drama Links from cn163.net
Wukong Talks Architecture
Wukong Talks Architecture
Aug 17, 2021 · Fundamentals

Core Java Multithreading Interview Questions and Concepts

This article compiles 16 classic Java multithreading interview questions covering high‑concurrency containers, CAS and ABA problems, volatile vs synchronized, the Java Memory Model, ThreadLocal drawbacks, AQS, thread‑pool architecture, queue types, sizing strategies, rejection policies, lifecycle management, and graceful shutdown techniques.

CASJMMJava
0 likes · 20 min read
Core Java Multithreading Interview Questions and Concepts
MaGe Linux Operations
MaGe Linux Operations
Aug 14, 2021 · Frontend Development

Build a Stunning Python Music Player with PyQt5 – Step‑by‑Step Guide

This tutorial walks you through creating a feature‑rich desktop music player in Python using PyQt5, covering UI layout design, keyword‑based music crawling, multithreaded downloading, playback controls, volume adjustment, and additional functions like random and repeat modes, all illustrated with complete code snippets and screenshots.

Audio PlaybackGUIWeb Scraping
0 likes · 22 min read
Build a Stunning Python Music Player with PyQt5 – Step‑by‑Step Guide
Top Architect
Top Architect
Aug 10, 2021 · Backend Development

Understanding Java Concurrency Utilities: CountDownLatch, CyclicBarrier, Semaphore, and Exchanger

This article explains four Java concurrency utilities—CountDownLatch, CyclicBarrier, Semaphore, and Exchanger—detailing their concepts, typical use cases, and providing complete code examples that demonstrate synchronization patterns such as thread coordination, resource limiting, and data exchange.

CountDownLatchCyclicBarrierExchanger
0 likes · 13 min read
Understanding Java Concurrency Utilities: CountDownLatch, CyclicBarrier, Semaphore, and Exchanger
Top Architect
Top Architect
Aug 7, 2021 · Backend Development

Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow

The article explains why multithreading is essential for modern CPUs, introduces thread pools to reduce overhead, and details Java's ThreadPoolExecutor creation parameters, execution process, and core methods such as addWorker, runWorker, and getTask, using JDK 1.8 source code examples.

Backend DevelopmentJavaThreadPoolExecutor
0 likes · 7 min read
Understanding Java ThreadPoolExecutor: Creation, Parameters, and Execution Flow
JD Tech Talk
JD Tech Talk
Jul 29, 2021 · Mobile Development

Crash Analysis and Mitigation Strategies for JD Finance iOS App

This article explains the fundamentals of iOS crashes, categorizes common crash types such as wild pointers, deadlocks and watchdogs, presents real-world JD Finance app crash cases with code analysis, and outlines systematic debugging, logging, and preventive practices to keep crash rates well below industry averages.

Crash HandlingiOSmultithreading
0 likes · 26 min read
Crash Analysis and Mitigation Strategies for JD Finance iOS App
Baidu Intelligent Testing
Baidu Intelligent Testing
Jul 27, 2021 · Backend Development

Comprehensive Guide to Concurrency Optimization in Modern CPUs and Multithreaded Programming

This article systematically explores concurrency optimization for high‑performance C++ engineering, covering CPU trends, SIMD and out‑of‑order execution, single‑thread parallelism, lock‑free and wait‑free synchronization, and practical case studies of counters and queues to improve multithreaded scalability.

CPU architectureSIMDmultithreading
0 likes · 35 min read
Comprehensive Guide to Concurrency Optimization in Modern CPUs and Multithreaded Programming
Xianyu Technology
Xianyu Technology
Jul 27, 2021 · Mobile Development

Chaplin Project: Template‑Based Dynamic Image‑to‑Video Rendering

Chaplin Project replaces costly image‑to‑video synthesis on Xianyu by using centrally managed, OpenGL‑shader templates that combine product images with dynamic effects at playback, supported by a visual editor, resource platform, recommendation engine, and multi‑threaded client architecture, delivering richer browsing while conserving resources.

Mobile DevelopmentOpenGLTemplate Engine
0 likes · 9 min read
Chaplin Project: Template‑Based Dynamic Image‑to‑Video Rendering
Python Programming Learning Circle
Python Programming Learning Circle
Jul 23, 2021 · Artificial Intelligence

Understanding PyTorch's Backward Propagation Engine (BP Engine)

This article explains how PyTorch's BP Engine dynamically builds the computation graph for back‑propagation, detailing its C++ class structure, thread management, task queues, and key functions such as start_threads, compute_dependencies, execute, and evaluate_function, with illustrative code examples.

BackpropagationC#Engine
0 likes · 17 min read
Understanding PyTorch's Backward Propagation Engine (BP Engine)
Programmer DD
Programmer DD
Jun 25, 2021 · Fundamentals

Can Other Threads Keep Running After a Java Thread Hits OOM?

This article analyzes a Meituan interview question about whether other threads can continue when one thread throws a Java OutOfMemoryError, explains different OOM types, provides a sample program that triggers heap OOM, and demonstrates that remaining threads keep running while memory is reclaimed.

OutOfMemoryErrormemory-managementmultithreading
0 likes · 5 min read
Can Other Threads Keep Running After a Java Thread Hits OOM?
Baidu Geek Talk
Baidu Geek Talk
Jun 16, 2021 · Fundamentals

Concurrent Optimization Techniques in C++: SIMD, Out‑of‑Order Execution, and Lock‑Free/Wait‑Free Algorithms

The article reviews Baidu C++ engineers' concurrency optimizations, explaining why modern software must exploit parallelism and detailing SIMD vectorization, out‑of‑order execution, and micro‑architectural analysis, then compares mutex, lock‑free, and wait‑free synchronization, showcasing case studies where atomic and wait‑free designs dramatically improve multithreaded performance.

Performance OptimizationSIMDconcurrency
0 likes · 35 min read
Concurrent Optimization Techniques in C++: SIMD, Out‑of‑Order Execution, and Lock‑Free/Wait‑Free Algorithms
dbaplus Community
dbaplus Community
Jun 14, 2021 · Backend Development

How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive

This article traces Redis’s transition from its original single‑threaded design to a multi‑threaded architecture by examining the historical VM thread, the BIO background‑job threads introduced in Redis 2.4 and 4.0, and the network IO threads added in Redis 6.0, complete with source‑code excerpts and detailed explanations of each component’s purpose and implementation.

BIO threadIO threadRedis
0 likes · 43 min read
How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive
Top Architect
Top Architect
Jun 12, 2021 · Fundamentals

Understanding Java Threads, Thread Pools, and Concurrency Mechanisms

This article provides a comprehensive guide to Java multithreading, covering thread concepts, lifecycle states, synchronization methods, thread creation techniques, ThreadPoolExecutor parameters, blocking queues, rejection policies, and inter‑thread communication mechanisms, including examples and best practices for efficient concurrent programming.

JavaSynchronizationThreadPoolExecutor
0 likes · 19 min read
Understanding Java Threads, Thread Pools, and Concurrency Mechanisms
IT Xianyu
IT Xianyu
Jun 1, 2021 · Databases

Improving MySQL Insert Performance with Multithreading, Prepared Statements, and Batch Transactions

The article explains why multithreaded inserts can be faster than single‑threaded ones in MySQL, breaks down the time spent on each step of an insert operation, and presents practical techniques such as using PreparedStatement, multi‑value INSERT statements, and transaction batching to dramatically reduce insertion time.

Batch TransactionInsert PerformancePreparedStatement
0 likes · 6 min read
Improving MySQL Insert Performance with Multithreading, Prepared Statements, and Batch Transactions