BestHub
Sign in
Tagged articles
633 articles
Page 4 of 7
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.

Frontend DevelopmentWebAssemblymultithreading
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.

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

ConcurrencyLocksSynchronization
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 optimizationPythonWeb Crawling
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 testingDebuggingHttpRunner
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.

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

BenchmarkConcurrentHashMapJava
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 UpdateMyBatisSpringBoot
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.

DatabaseMyBatisPerformance Optimization
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.

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

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

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

ConcurrencyJavamultithreading
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 BreakpointDebuggingIntelliJ
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.

ConcurrencyIntegerlocking
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 inferenceCConcurrency
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.

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

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

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

ConcurrencyJavaScheduled Tasks
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.

Decorator PatternJavaLogging
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.

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

Pyechartsdata-analysismultithreading
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.

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

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

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

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

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

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

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

ConcurrencyPerformance OptimizationSIMD
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.

ConcurrencyJavaSynchronization
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 TransactionDatabase OptimizationInsert Performance
0 likes · 6 min read
Improving MySQL Insert Performance with Multithreading, Prepared Statements, and Batch Transactions
Programmer DD
Programmer DD
May 30, 2021 · Backend Development

Why CommandLineRunner Can Halt Your Spring Boot Startup—and How to Fix It

This article explains the differences between Spring Boot’s CommandLineRunner and ApplicationRunner, illustrates common pitfalls when using CommandLineRunner—such as blocking startup and causing exceptions—and shows how to run tasks in a separate thread to avoid startup failures.

ApplicationRunnerStartupcommandlinerunner
0 likes · 9 min read
Why CommandLineRunner Can Halt Your Spring Boot Startup—and How to Fix It
FunTester
FunTester
May 28, 2021 · Operations

Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator

The article explains why a single‑threaded request generator fails at high QPS, introduces a multithreaded generator with a configurable per‑thread QPS limit, provides the full Java implementation, and shows that it reliably sustains 10‑20k QPS in practice.

JavaQPSload-testing
0 likes · 5 min read
Scaling Fixed‑QPS Load Tests with a Multithreaded Task Generator
Aikesheng Open Source Community
Aikesheng Open Source Community
May 27, 2021 · Databases

Essential Skills for Middleware Development and Database Middleware

This article outlines the fundamental and specialized technical skills required for developing middleware in general and database middleware in particular, covering multithreading, network programming, design patterns, asynchronous programming, algorithms, testing, performance tuning, as well as SQL, transaction handling, protocol implementation, and replication.

Design Patternsmiddlewaremultithreading
0 likes · 9 min read
Essential Skills for Middleware Development and Database Middleware
Programmer DD
Programmer DD
May 25, 2021 · Databases

Boost MySQL Insert Speed with Multithreading, Prepared Statements, and Batch Techniques

This article explains why multithreaded inserts into MySQL can outperform single‑threaded writes, breaks down the time spent on connection, parsing and insertion, and presents practical techniques such as prepared statements, batch processing, multi‑value inserts, and transaction batching that together can reduce insert time to seconds for massive data sets.

Batch InsertMySQLPrepared Statements
0 likes · 6 min read
Boost MySQL Insert Speed with Multithreading, Prepared Statements, and Batch Techniques
macrozheng
macrozheng
May 21, 2021 · Fundamentals

Why Java’s Memory Model Matters: Unveiling the Hidden Rules of Concurrency

This article explains the hardware memory hierarchy, cache‑coherency issues, processor optimizations and instruction reordering, and shows how the Java Memory Model (JMM) defines eight operations to guarantee visibility, atomicity and ordering for multithreaded Java programs.

Cache CoherencyConcurrencyJMM
0 likes · 12 min read
Why Java’s Memory Model Matters: Unveiling the Hidden Rules of Concurrency
Java Interview Crash Guide
Java Interview Crash Guide
May 19, 2021 · Backend Development

How to Optimize Java Scheduled Tasks for High‑Volume Data Sync

This article explains how to optimize Java scheduled tasks for large‑scale data synchronization by introducing phased improvements such as blacklist mechanisms, multithreaded execution with CountDownLatch, and server‑level sharding, providing practical guidelines for performance and reliability.

ConcurrencyJavaPerformance Optimization
0 likes · 13 min read
How to Optimize Java Scheduled Tasks for High‑Volume Data Sync
TAL Education Technology
TAL Education Technology
May 13, 2021 · Backend Development

Understanding Java Concurrency: Volatile, Synchronized, JMM, and MESI

This article provides a comprehensive tutorial on Java concurrency, covering the usage and implementation principles of the volatile and synchronized keywords, the Java Memory Model, the MESI cache protocol, common visibility and reordering issues, and practical code examples for designing efficient multithreaded solutions.

ConcurrencyJMMJava
0 likes · 17 min read
Understanding Java Concurrency: Volatile, Synchronized, JMM, and MESI
Top Architect
Top Architect
May 11, 2021 · Fundamentals

Understanding Java Locks: From Synchronized to Lock Upgrade Mechanisms

This article explains how Java implements locks—from the basic use of the synchronized keyword and Lock interface to the internal object header structures, bias, lightweight, and heavyweight lock upgrades, and the role of CAS and monitor objects in JVM concurrency control.

ConcurrencyJVMJava
0 likes · 18 min read
Understanding Java Locks: From Synchronized to Lock Upgrade Mechanisms