BestHub
Sign in
Tagged articles

multithreading

655 articles · Page 7 of 7
Java Backend Technology
Java Backend Technology
Jul 29, 2018 · Backend Development

Turning a 2‑Month Data Migration into 4 Hours: Backend Performance Secrets

After struggling with a two‑month data migration that processed 20 million users, the author iteratively redesigned the system—from a single‑threaded, procedural approach to a fully decoupled, multithreaded architecture using queues and batch operations—ultimately reducing runtime to just four hours while ensuring data consistency and recoverability.

Batch Processingdata migrationmultithreading
0 likes · 13 min read
Turning a 2‑Month Data Migration into 4 Hours: Backend Performance Secrets
iQIYI Technical Product Team
iQIYI Technical Product Team
Jul 20, 2018 · Mobile Development

Android App Startup Optimization: Process, Measurement, and Performance Improvements

The article details iQIYI’s systematic approach to Android app startup optimization—analyzing cold‑start processes, measuring latency with SysTrace and adb, applying process‑aware initialization, async work off the UI thread, layout simplifications, delayed services, and automated tracing—to achieve up to 40 % launch‑time reduction and establish continuous monitoring.

ADBAndroidPerformance
0 likes · 15 min read
Android App Startup Optimization: Process, Measurement, and Performance Improvements
360 Tech Engineering
360 Tech Engineering
Jul 4, 2018 · Backend Development

Understanding and Avoiding Common Concurrency Bugs in Java

This article introduces the four major categories of multithreaded bugs—data races, atomicity failures, ordering failures, and deadlocks—explains their causes with Java examples, and provides practical techniques such as using state machines, volatile variables, consistent lock ordering, and proper exception handling to prevent them.

Data RaceJavadeadlock
0 likes · 7 min read
Understanding and Avoiding Common Concurrency Bugs in Java
MaGe Linux Operations
MaGe Linux Operations
Jul 3, 2018 · Fundamentals

Why Zombie Processes Occur in Linux and How Multithreading Works

This article explains Linux process fundamentals—including creation, the PCB, scheduling, and the emergence of zombie processes—details their causes and removal methods, and then compares processes with threads, covering multithreading implementation, issues, classifications, priorities, and synchronization techniques.

LinuxOS fundamentalsmultithreading
0 likes · 13 min read
Why Zombie Processes Occur in Linux and How Multithreading Works
Programmer DD
Programmer DD
Jul 1, 2018 · Backend Development

Mastering Java’s CyclicBarrier: How Threads Synchronize and What Can Go Wrong

This article explains Java’s CyclicBarrier synchronization aid, detailing its purpose, constructors, the await() workflow, internal implementation with ReentrantLock and Condition, generation handling, error scenarios, timeout support, and provides a complete multithreaded example illustrating its practical use.

ConcurrencyCyclicBarrierJava
0 likes · 10 min read
Mastering Java’s CyclicBarrier: How Threads Synchronize and What Can Go Wrong
JD Tech
JD Tech
Jun 21, 2018 · Backend Development

Understanding High Concurrency: From Network Cards to Multithreading Models

This article explains the fundamentals of high‑concurrency systems, covering how network cards and routers handle massive traffic, the role of the operating system and epoll/select, various I/O models, reactor and multithreading patterns, and strategies to improve CPU and I/O utilization.

EpollIO MultiplexingReactor Pattern
0 likes · 19 min read
Understanding High Concurrency: From Network Cards to Multithreading Models
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 20, 2018 · Mobile Development

How to Supercharge Mobile Deep Learning: Model Compression & Engine Optimizations

This article explains how to overcome the performance, size, memory, and compatibility challenges of deploying deep‑learning inference engines on mobile devices by jointly optimizing model compression and engine implementation, covering speed tricks, cache‑friendly coding, multithreading, sparsity, quantization, NEON intrinsics, package size reduction, memory pooling, and reliability techniques.

NEON SIMDmemory managementmobile deep learning
0 likes · 22 min read
How to Supercharge Mobile Deep Learning: Model Compression & Engine Optimizations
Java Captain
Java Captain
Jun 3, 2018 · Fundamentals

Understanding High Concurrency in Java: Memory Model, Thread Safety, and Synchronization Techniques

This article explores Java high‑concurrency concepts, detailing the Java Memory Model, thread communication, instruction reordering, atomic classes, synchronization mechanisms, lock implementations, concurrent collections, and safe object publication, providing code examples and practical guidance for building robust multithreaded applications.

JavaThreadSafetyjmm
0 likes · 18 min read
Understanding High Concurrency in Java: Memory Model, Thread Safety, and Synchronization Techniques
MaGe Linux Operations
MaGe Linux Operations
Apr 15, 2018 · Fundamentals

Master Python Threading: From Basics to Advanced Synchronization

This article explains Python threading fundamentals, including thread context, kernel vs. user threads, the low‑level _thread module and the high‑level threading module, functional and class‑based thread creation, synchronization with locks, and using Queue for thread‑safe communication, all illustrated with complete code examples.

ConcurrencyPythonQueue
0 likes · 13 min read
Master Python Threading: From Basics to Advanced Synchronization
Baidu Intelligent Testing
Baidu Intelligent Testing
Mar 26, 2018 · Fundamentals

C/C++ Segment Fault Case Analysis and Debugging Techniques

This article presents a comprehensive analysis of real-world C/C++ core dump cases, categorizing common causes such as stack integrity, memory leaks, multithreading issues, and misuse of system libraries, and offers practical debugging strategies and code examples to help developers prevent and resolve such crashes.

core dumpmemory issuesmultithreading
0 likes · 17 min read
C/C++ Segment Fault Case Analysis and Debugging Techniques
Java Captain
Java Captain
Mar 21, 2018 · Backend Development

Java Multithreading: Extending Thread, Implementing Runnable, and Using ExecutorService with Callable and Future

This article explains three primary ways to create multithreaded Java programs—extending Thread, implementing Runnable, and employing ExecutorService with Callable and Future—providing code examples, execution details, and a complete runnable example that demonstrates thread creation, execution, and result retrieval.

ExecutorServiceFutureJava
0 likes · 7 min read
Java Multithreading: Extending Thread, Implementing Runnable, and Using ExecutorService with Callable and Future
Java Architect Essentials
Java Architect Essentials
Mar 19, 2018 · Backend Development

40 Common Java Multithreading Interview Questions and Answers

This article compiles and answers 40 frequently asked Java multithreading interview questions, covering thread purpose, creation methods, key APIs, synchronization mechanisms, thread safety levels, performance considerations, and practical debugging techniques for developers seeking a solid understanding of concurrent programming.

ConcurrencyThreadPoolinterview
0 likes · 29 min read
40 Common Java Multithreading Interview Questions and Answers
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Mar 12, 2018 · Fundamentals

Understanding Java Processes vs Threads and Key Concurrency Methods

This article explains the fundamental differences between processes and threads, compares Thread and Runnable in Java, outlines thread lifecycle states, and details common concurrency methods such as sleep, join, yield, interrupt, wait, and synchronized, helping developers write robust multithreaded code.

Javamultithreadingprocesses
0 likes · 12 min read
Understanding Java Processes vs Threads and Key Concurrency Methods
Java Captain
Java Captain
Feb 19, 2018 · Fundamentals

Creating and Starting Java Threads: Subclassing Thread and Implementing Runnable

This article explains how to create and start Java threads by directly instantiating Thread, extending the Thread class, implementing the Runnable interface, handling common pitfalls such as calling run() instead of start(), and demonstrates naming threads and using thread pools with clear code examples.

JavaRunnableThreadSubclass
0 likes · 7 min read
Creating and Starting Java Threads: Subclassing Thread and Implementing Runnable
Java Captain
Java Captain
Feb 5, 2018 · Fundamentals

Java Multithreading Basics: History, Thread States, Creation Methods, Synchronization, and Control

This article provides a comprehensive introduction to Java multithreading, covering its historical background, thread lifecycle states, two ways to create threads, code examples for shared and non‑shared data, synchronization with the synchronized keyword, thread control methods such as interrupt, sleep, suspend, yield, priority settings, and daemon threads, concluding with key takeaways.

Javadaemoninterrupt
0 likes · 18 min read
Java Multithreading Basics: History, Thread States, Creation Methods, Synchronization, and Control
Architecture Digest
Architecture Digest
Feb 4, 2018 · Game Development

Understanding Entity‑Component‑System (ECS) Architecture in Game Development

This article explains the origins, design principles, advantages, and trade‑offs of the Entity‑Component‑System (ECS) pattern in game development, illustrating how moving logic from Components and Managers into Systems can improve modularity, cache friendliness, and multithreading while highlighting potential pitfalls and decoupling strategies.

Component SystemECSGame Architecture
0 likes · 9 min read
Understanding Entity‑Component‑System (ECS) Architecture in Game Development
Java Captain
Java Captain
Feb 1, 2018 · Fundamentals

Common Java Multithreading and Concurrency Interview Questions and Answers

This article compiles essential Java multithreading and concurrency interview questions, covering thread basics, lifecycle, synchronization, thread pools, executors, atomic classes, deadlocks, and related concepts, providing concise explanations and code examples for interview preparation.

JavaThreadPoolinterview
0 likes · 20 min read
Common Java Multithreading and Concurrency Interview Questions and Answers
Java Captain
Java Captain
Jan 31, 2018 · Backend Development

Understanding Callable and Future in Java Concurrency

This article explains how Java's Callable interface and Future objects work together to produce asynchronous results, compares direct FutureTask usage with ExecutorService submission, and demonstrates handling multiple tasks using CompletionService for efficient multithreaded programming.

ExecutorServiceFutureJava
0 likes · 5 min read
Understanding Callable and Future in Java Concurrency
Java Captain
Java Captain
Jan 11, 2018 · Fundamentals

Understanding Java's synchronized(this) Object Lock and Thread Interaction

This article explains how Java's synchronized(this) keyword creates an object lock that allows only one thread to execute a synchronized block at a time, demonstrates various scenarios with code examples, and shows how non‑synchronized sections remain concurrent while all synchronized sections on the same object are blocked.

Concurrencymultithreadingobject lock
0 likes · 9 min read
Understanding Java's synchronized(this) Object Lock and Thread Interaction
MaGe Linux Operations
MaGe Linux Operations
Jan 11, 2018 · Backend Development

Master Python Web Scraping: From Basic Requests to Multithreaded Crawlers

This comprehensive guide walks you through Python web‑scraping techniques—including basic URL fetching, proxy usage, cookie and form handling, browser impersonation, gzip/deflate support, captcha processing, multithreading with thread pools and Twisted async I/O, plus practical tips on connection pooling, thread stack size, retries, timeouts and login automation—providing a solid foundation for building robust crawlers.

GZIPPythonWeb Scraping
0 likes · 17 min read
Master Python Web Scraping: From Basic Requests to Multithreaded Crawlers
21CTO
21CTO
Oct 24, 2017 · Backend Development

Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained

This article explains essential Java concurrency concepts—including synchronous vs. asynchronous execution, concurrency vs. parallelism, critical sections, blocking and non‑blocking operations—covers thread states, creation methods, priorities, common thread APIs, and the Java Memory Model’s guarantees on atomicity, visibility, and ordering.

ConcurrencyJavajmm
0 likes · 22 min read
Mastering Java Concurrency: Key Concepts, Thread Lifecycle, and JMM Explained
Architecture Digest
Architecture Digest
Oct 24, 2017 · Backend Development

Understanding Java Thread Concurrency: Concepts, Lifecycle, and the Java Memory Model

This article explains key Java concurrency concepts—including synchronization, parallelism, critical sections, blocking vs non‑blocking, thread lifecycle, priority, common thread methods, interrupt handling, and the Java Memory Model’s guarantees of atomicity, visibility, ordering, and happens‑before relations—providing practical examples and code snippets for backend developers.

ConcurrencyJavajmm
0 likes · 24 min read
Understanding Java Thread Concurrency: Concepts, Lifecycle, and the Java Memory Model
Java Captain
Java Captain
Aug 22, 2017 · Fundamentals

Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage

This article explains the limitations of Java's synchronized keyword, introduces the Lock framework from java.util.concurrent.locks, compares their features, and demonstrates practical usage through multiple code examples covering ReentrantLock, tryLock, lockInterruptibly, ReadWriteLock, and fairness concepts.

ConcurrencyLockmultithreading
0 likes · 25 min read
Comparison of synchronized and Lock in Java: Limitations, Advantages, and Usage
Tencent TDS Service
Tencent TDS Service
Jun 8, 2017 · Mobile Development

Why iOS CoreMotion Crashes on QQ: Debugging Misaligned Address Errors

An in‑depth investigation of a CoreMotion‑related crash in the latest QQ mobile app reveals misaligned address access caused by unsafe multithreaded use of UIAccelerometer and CMMotionManager, and demonstrates how to reproduce, trace, and fix the issue by moving accelerometer operations back to the main thread.

CMMotionManagerCoreMotionUIAccelerometer
0 likes · 11 min read
Why iOS CoreMotion Crashes on QQ: Debugging Misaligned Address Errors
ITPUB
ITPUB
Apr 29, 2017 · Backend Development

40 Essential Java Multithreading Interview Questions Explained

This article compiles and clarifies forty common Java multithreading interview questions, covering thread creation, synchronization mechanisms, thread pools, memory model, and practical debugging techniques to help developers deepen their understanding and prepare for technical interviews.

Java Memory ModelThread Poolinterview
0 likes · 30 min read
40 Essential Java Multithreading Interview Questions Explained
Liulishuo Tech Team
Liulishuo Tech Team
Jun 3, 2016 · Backend Development

Understanding Ruby Multithreading and Multiprocessing

This article explains the differences between Ruby threads and processes, when to use each for performance gains, illustrates practical scenarios, and provides code examples for simple multithreading, multiprocessing, and using the Parallel gem.

ConcurrencyGILParallel
0 likes · 11 min read
Understanding Ruby Multithreading and Multiprocessing
Qunar Tech Salon
Qunar Tech Salon
May 9, 2016 · Backend Development

Comprehensive Overview of Java Locks: Fair, Unfair, Spin, Reentrant, Biased, Lightweight, Heavyweight, and More

This article provides a detailed explanation of various Java lock mechanisms—including fair and unfair locks, spin locks, lock elimination, lock coarsening, reentrant, class and object locks, biased, lightweight, heavyweight, pessimistic and optimistic locks—as well as practical code examples and a lock state table to help developers understand concurrency control in the JVM.

ConcurrencyJVMJava
0 likes · 16 min read
Comprehensive Overview of Java Locks: Fair, Unfair, Spin, Reentrant, Biased, Lightweight, Heavyweight, and More
ITPUB
ITPUB
Apr 6, 2016 · Fundamentals

Why Python Multithreading Struggles and When to Switch to Multiprocessing

This article explains the purpose of Python’s Global Interpreter Lock, how it limits multithreaded performance on multi‑core CPUs, distinguishes CPU‑bound versus I/O‑bound scenarios, and shows why multiprocessing is usually the preferred solution for parallel execution.

ConcurrencyGILmultiprocessing
0 likes · 6 min read
Why Python Multithreading Struggles and When to Switch to Multiprocessing
DevOps
DevOps
Apr 3, 2016 · Fundamentals

The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks

A metaphorical story follows a newly created thread as it learns about extracting request parameters, performing login, handling CPU scheduling, using caches, encountering deadlocks, and ultimately witnessing a system reboot, illustrating core concepts of multithreading, concurrency control, and thread‑pool lifecycle.

CPU schedulingConcurrencyLocks
0 likes · 12 min read
The Life of a Thread: A Narrative on Thread Pools, Locks, and Deadlocks
21CTO
21CTO
Mar 20, 2016 · Backend Development

Mastering Thread Safety in Java: When and How to Use synchronized

Thread safety issues arise when multiple threads access shared resources like variables, objects, or databases, potentially causing duplicate data or errors; this article explains when such problems occur and demonstrates how Java’s synchronized methods, synchronized blocks, and lock mechanisms can ensure safe, serialized access.

JavaThread Safetymultithreading
0 likes · 12 min read
Mastering Thread Safety in Java: When and How to Use synchronized
Java High-Performance Architecture
Java High-Performance Architecture
Feb 6, 2016 · Frontend Development

How Web Workers Unblock JavaScript: Solving the Single‑Threaded Bottleneck

This article explains why JavaScript’s single‑threaded nature can freeze the UI during heavy calculations like recursive Fibonacci, and demonstrates how using HTML5 Web Workers moves such tasks to background threads, keeping the interface responsive and allowing multiple workers for intensive operations.

JavaScriptWeb Workersasynchronous
0 likes · 3 min read
How Web Workers Unblock JavaScript: Solving the Single‑Threaded Bottleneck
21CTO
21CTO
Sep 19, 2015 · Backend Development

Can PHP + Swoole Compete with C++ for High‑Concurrency Servers?

The article examines why PHP’s lack of native multithreading isn’t a fatal flaw for high‑concurrency servers when paired with Swoole, compares process‑based and thread‑based models, debunks performance myths, and highlights the productivity benefits of using PHP over C++.

ConcurrencyPHPSwoole
0 likes · 5 min read
Can PHP + Swoole Compete with C++ for High‑Concurrency Servers?
21CTO
21CTO
Sep 8, 2015 · Backend Development

Can PHP + Swoole Rival C++ for High‑Concurrency Servers? Myths Explained

Although many claim PHP with Swoole is unsuitable for high‑concurrency servers compared to C++, this article explains how PHP’s process model, Swoole’s Table and Atomic features, and careful design can achieve comparable performance while offering faster development, and discusses the trade‑offs of multithreading versus multiprocessing.

ConcurrencyPHPSwoole
0 likes · 6 min read
Can PHP + Swoole Rival C++ for High‑Concurrency Servers? Myths Explained
Art of Distributed System Architecture Design
Art of Distributed System Architecture Design
Jul 31, 2015 · Backend Development

Load Balancing Between Worker Threads in Multithreaded Server Programs

The article explains how kernel‑level load balancing works, why naïve thread‑pool wake‑up can cause CPU imbalance, and proposes using thread affinity, priority layers and a custom layered condition variable to achieve better performance in multithreaded server applications on Linux.

kernel schedulingload balancingmultithreading
0 likes · 21 min read
Load Balancing Between Worker Threads in Multithreaded Server Programs
Qunar Tech Salon
Qunar Tech Salon
Jul 14, 2015 · Fundamentals

Understanding Java volatile: Principles, Usage, and Best Practices

This article explains the Java volatile keyword, covering its definition, lightweight nature compared to synchronized, visibility guarantees, usage conditions, and practical patterns such as state flags, safe publication, volatile beans, and low‑cost read‑write lock strategies, illustrated with code examples.

ConcurrencyJavamemory model
0 likes · 9 min read
Understanding Java volatile: Principles, Usage, and Best Practices
MaGe Linux Operations
MaGe Linux Operations
May 22, 2015 · Backend Development

Why Multithreading, Blocking, and IOCP/Epoll Matter for High‑Performance Servers

The article explores the evolution from single‑core processors to multi‑core systems, explains threading, blocking, and synchronization concepts, and compares high‑performance communication models such as asynchronous I/O, IOCP on Windows and epoll on Linux, highlighting their trade‑offs for backend server scalability.

BackendEpollIOCP
0 likes · 15 min read
Why Multithreading, Blocking, and IOCP/Epoll Matter for High‑Performance Servers
Baidu Tech Salon
Baidu Tech Salon
Jan 7, 2015 · Frontend Development

Front‑End vs iOS Development: Languages, Threads, Storage & Performance Compared

This article analytically compares web front‑end development and iOS mobile development, covering language choices, threading models, data storage strategies, framework ecosystems, compatibility challenges, performance optimization, compilation processes, security considerations, and the impact on user interaction and development workflow.

JavaScriptObjective-C++Performance
0 likes · 13 min read
Front‑End vs iOS Development: Languages, Threads, Storage & Performance Compared
MaGe Linux Operations
MaGe Linux Operations
Jul 1, 2014 · Backend Development

Master Python Web Scraping: Proxies, Login, Multithreading, and Captcha Hacks

This guide walks through practical Python web‑scraping techniques using urllib2, covering basic page fetching, proxy usage, cookie handling for logins, form submission, header spoofing, anti‑hotlink tricks, multithreaded crawling, and strategies for bypassing simple captchas, all illustrated with code snippets.

CAPTCHAProxyWeb Scraping
0 likes · 7 min read
Master Python Web Scraping: Proxies, Login, Multithreading, and Captcha Hacks