BestHub
Sign in
Tagged articles
633 articles
Page 6 of 7
Java Backend Technology
Java Backend Technology
Nov 14, 2019 · Backend Development

Master Java Debugging: Conditional Breakpoints, Drop Frame, Remote Debug & More

This guide explains essential Java debugging techniques—including conditional breakpoints, dropping to a previous stack frame, handling multithreaded breakpoints, remote debugging setup, and evaluating or modifying expressions on the fly—providing clear steps and visual examples to help developers debug more efficiently.

DebuggingIDEbreakpoints
0 likes · 6 min read
Master Java Debugging: Conditional Breakpoints, Drop Frame, Remote Debug & More
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 6, 2019 · Backend Development

Why Your Java Service Breaks When Scaling and How to Fix It

This article examines five common Java backend pitfalls that startups face—single‑machine locking, improper multithreading, poorly defined workflows, unsafe system interactions, and non‑paginated queries—explains why they cause failures in distributed environments, and provides practical solutions such as distributed locks, message queues, state‑machine redesign, RPC interfaces, and pagination techniques.

JavaMessage QueueState Machine
0 likes · 22 min read
Why Your Java Service Breaks When Scaling and How to Fix It
Liangxu Linux
Liangxu Linux
Nov 4, 2019 · Fundamentals

How CPUs Execute Programs: From Fetch‑Decode‑Execute to Multicore & Cache

This article explains the core principles of CPU operation, covering the fetch‑decode‑execute cycle, instruction sets, registers, pipeline and superscalar designs, multithreading and multicore behavior, as well as cache hierarchy from registers through L1‑L3, illustrating how these mechanisms affect program execution.

CPUCacheInstruction Set
0 likes · 14 min read
How CPUs Execute Programs: From Fetch‑Decode‑Execute to Multicore & Cache
MaGe Linux Operations
MaGe Linux Operations
Oct 30, 2019 · Backend Development

How a Midnight Migration Tested a Programmer’s Problem‑Solving Skills

A senior developer recounts a high‑pressure midnight migration from an aging monolithic platform to a new micro‑service system, describing the technical challenges, ad‑hoc multithreading solutions, and the crucial problem‑solving mindset required to keep millions of transactions running smoothly.

backend-migrationmultithreadingproblem solving
0 likes · 15 min read
How a Midnight Migration Tested a Programmer’s Problem‑Solving Skills
Architect's Tech Stack
Architect's Tech Stack
Oct 27, 2019 · Databases

Optimizing MySQL Inserts with Multithreading, Prepared Statements, Batch and Transaction Techniques

This article explains how multithreaded inserts, prepared statements, multi‑value SQL, and batch transaction commits can dramatically improve MySQL insert performance by reducing connection overhead, parsing time, and network I/O, achieving insertion of 100 000 rows in roughly ten seconds.

Batch InsertPerformance OptimizationPreparedStatement
0 likes · 5 min read
Optimizing MySQL Inserts with Multithreading, Prepared Statements, Batch and Transaction Techniques
Big Data Technology & Architecture
Big Data Technology & Architecture
Oct 26, 2019 · Databases

KeyDB Multithreaded Architecture and Design Overview

KeyDB is a high‑performance, multithreaded fork of Redis that retains full Redis compatibility while delivering up to twice the query throughput and 60 % lower latency, and the article explains its thread model, connection management, fastlock mechanism, and active‑replica features in detail.

DatabaseKeyDBLock
0 likes · 7 min read
KeyDB Multithreaded Architecture and Design Overview
Python Crawling & Data Mining
Python Crawling & Data Mining
Oct 21, 2019 · Fundamentals

Why Python Threads Can’t Fully Utilize Multi‑Core CPUs and How to Use Them Effectively

This tutorial explains Python's multithreading model, its advantages and limitations—including the Global Interpreter Lock—demonstrates thread creation with the threading module, shows race conditions and lock usage, compares processes and threads, and discusses when to choose threads, processes, or asynchronous I/O for different workloads.

GILLockPython
0 likes · 17 min read
Why Python Threads Can’t Fully Utilize Multi‑Core CPUs and How to Use Them Effectively
Programmer DD
Programmer DD
Sep 23, 2019 · Databases

Why Multi‑Threaded Inserts Outperform Single Thread in MySQL

This article explains how multithreaded inserts into a MySQL table can be faster than single‑threaded inserts by reducing connection and parsing overhead, and it details techniques such as prepared statements, multi‑value inserts, and batch transaction commits to boost performance.

Batch InsertPerformancePrepared Statements
0 likes · 5 min read
Why Multi‑Threaded Inserts Outperform Single Thread in MySQL
FunTester
FunTester
Sep 17, 2019 · Backend Development

Building a Multithreaded Java Web Scraper to Harvest 100k Records

After uncovering an unprotected API that allowed unlimited resource access, the author created a rough Java program that uses a fixed-size thread pool and CountDownLatch to fetch 100 000 items in parallel, retrieving 10 000 records per thread via HTTP GET requests.

HTTPJavaWeb Scraping
0 likes · 6 min read
Building a Multithreaded Java Web Scraper to Harvest 100k Records
Programmer DD
Programmer DD
Sep 15, 2019 · Fundamentals

Mastering Concurrency: The Three Core Pillars of Multithreaded Programming

Explore how concurrency can be broken down into three essential problems—division of work, synchronization/coordination, and mutual exclusion—using real‑world analogies and Java examples, and learn practical strategies like appropriate task sizing, thread communication, and locking mechanisms to write efficient, safe multithreaded code.

JavaSynchronizationconcurrency
0 likes · 7 min read
Mastering Concurrency: The Three Core Pillars of Multithreaded Programming
Amap Tech
Amap Tech
Sep 12, 2019 · Backend Development

Common Java Backend Issues and Solutions: Distributed Systems, Multithreading, and Data Access

The article distills years of Java backend experience into a concise checklist, showing how to replace JVM‑local locks with distributed locks, move thread‑blocked work to reliable message queues, model workflows with finite‑state machines, choose suitable inter‑service protocols, and always paginate queries to avoid memory and consistency problems.

Databasedesign-patternsdistributed-systems
0 likes · 25 min read
Common Java Backend Issues and Solutions: Distributed Systems, Multithreading, and Data Access
FunTester
FunTester
Sep 1, 2019 · Mobile Development

Stabilizing Android Home‑Page Refresh with UiAutomator and Multithreading

This article explains how to use UiAutomator scripts combined with Java multithreading to continuously refresh an Android app’s home page while capturing logs and performance metrics, including full code examples for command execution, timestamp handling, and test loops.

ADBAndroidJava
0 likes · 6 min read
Stabilizing Android Home‑Page Refresh with UiAutomator and Multithreading
FunTester
FunTester
Aug 23, 2019 · Mobile Development

Collect Android App FPS with ADB and a Multithreaded Java Helper

This guide shows how to use the adb shell dumpsys gfxinfo command to capture frame‑per‑second metrics for an Android app and provides a reusable Java class that runs in a separate thread, parses the output, and stores the results for performance analysis.

ADBAndroidJava
0 likes · 6 min read
Collect Android App FPS with ADB and a Multithreaded Java Helper
Java Backend Technology
Java Backend Technology
Aug 23, 2019 · Backend Development

How I Cut a 2‑Month Data Migration to 4 Hours: A Backend Performance Journey

This article chronicles a Java backend data‑migration project where the author transformed a two‑month, 2000‑million‑record process into a four‑hour job by iteratively redesigning the architecture from a monolithic procedural approach to a fully decoupled, multithreaded, queue‑driven system, highlighting key performance bottlenecks and solutions.

Data MigrationJavaarchitecture
0 likes · 14 min read
How I Cut a 2‑Month Data Migration to 4 Hours: A Backend Performance Journey
FunTester
FunTester
Aug 19, 2019 · Backend Development

Simulating Multiple Simultaneous Logins with Apache HttpClient

This guide shows how to disable HttpClient's automatic cookie handling, manually extract and store Set‑Cookie headers, and bind cookies to individual user objects so that multi‑user, multi‑threaded API tests can simulate concurrent logins reliably.

API testingCookieHttpClient
0 likes · 7 min read
Simulating Multiple Simultaneous Logins with Apache HttpClient
21CTO
21CTO
Aug 16, 2019 · Backend Development

Master Scrapy: Build, Deploy, and Scale a Python Web Crawler Platform

This guide walks through designing a full‑featured web‑crawler platform, covering rule maintenance, job scheduling, async and real‑time crawling with Scrapy, project setup, item pipelines, settings, local execution, custom parameters, server deployment via Scrapyd, API usage, and fast real‑time crawling with Requests, BeautifulSoup, Flask, and multithreading.

AsyncFlaskPython
0 likes · 16 min read
Master Scrapy: Build, Deploy, and Scale a Python Web Crawler Platform
ITPUB
ITPUB
Aug 14, 2019 · Fundamentals

How CPUs Execute Programs: From Fetch to Cache and Multithreading Explained

This article explains the core principles of CPU operation, covering instruction fetching, decoding, execution cycles, register types, pipeline and superscalar architectures, multi‑core and hyper‑threading designs, as well as the hierarchy of caches from registers to L3, providing a comprehensive overview of modern processor fundamentals.

CPUInstruction CycleRegisters
0 likes · 13 min read
How CPUs Execute Programs: From Fetch to Cache and Multithreading Explained
FunTester
FunTester
Aug 12, 2019 · Backend Development

Detecting Double-Spend Bugs in API Exchanges Using Multithreaded Tests

This article explains the concept of a “double‑spend” bug encountered during a coin‑exchange API, describes a multithreaded testing approach in Java to reproduce the issue, analyzes the root cause of non‑atomic balance checks, and provides sample code illustrating the detection and prevention method.

API testingJavabackend
0 likes · 8 min read
Detecting Double-Spend Bugs in API Exchanges Using Multithreaded Tests
FunTester
FunTester
Aug 10, 2019 · Mobile Development

Measure Android App Launch Time Using Logcat and Multithreading

This article presents a Java‑based solution that repeatedly launches and closes an Android app while capturing logcat output to automatically calculate splash‑screen and home‑screen launch times, providing a reproducible method for accurate performance testing.

AndroidJavaLaunch Time
0 likes · 8 min read
Measure Android App Launch Time Using Logcat and Multithreading
ITPUB
ITPUB
Aug 5, 2019 · Operations

How a Midnight Migration Saved Millions: Lessons in Problem‑Solving for Developers

A senior engineer recounts a high‑pressure, overnight data‑migration from an overloaded legacy platform to a new micro‑service system, detailing the technical challenges, rapid troubleshooting, multithreaded workarounds, and the broader lessons on what truly makes a programmer great.

Operationsbackendmultithreading
0 likes · 16 min read
How a Midnight Migration Saved Millions: Lessons in Problem‑Solving for Developers
FunTester
FunTester
Jul 29, 2019 · Backend Development

Testing Probabilistic API Interfaces: Methodology and Java Implementation

This article describes how to test probability‑based API features such as lotteries by statistically validating expected odds, detecting bugs through extreme probability cases, and accelerating execution with Java multithreading, illustrated with a complete Java test code example.

API testingJavamultithreading
0 likes · 8 min read
Testing Probabilistic API Interfaces: Methodology and Java Implementation
FunTester
FunTester
Jul 22, 2019 · Fundamentals

Why i++ Is Not Thread‑Safe: A Hands‑On Demo with vmlens

This article demonstrates how the non‑atomic i++ operation can cause race conditions in Java by using the vmlens tool to visualize thread interleavings, providing sample test code, Maven configuration, and an analysis of the resulting report.

Javaconcurrencymultithreading
0 likes · 6 min read
Why i++ Is Not Thread‑Safe: A Hands‑On Demo with vmlens
FunTester
FunTester
Jul 22, 2019 · Fundamentals

Why a Simple Increment Isn’t Thread‑Safe: A Java Concurrency Demo

This article explains atomicity, thread safety, and race conditions in Java by showing how a volatile counter increment can produce nondeterministic results when accessed concurrently, complete with sample code and console output analysis.

atomicityconcurrencyexample
0 likes · 4 min read
Why a Simple Increment Isn’t Thread‑Safe: A Java Concurrency Demo
FunTester
FunTester
Jul 19, 2019 · Fundamentals

Why i++ Is Not Thread‑Safe: A Hands‑On Demo with vmlens

This article demonstrates how the non‑atomic i++ operation can cause race conditions in Java, using a simple multithreaded test and the vmlens tool to visualize the conflicting accesses and explain the underlying thread‑safety issue.

JavaMavenmultithreading
0 likes · 7 min read
Why i++ Is Not Thread‑Safe: A Hands‑On Demo with vmlens
FunTester
FunTester
Jul 16, 2019 · Fundamentals

Why Incrementing a Counter Isn’t Thread‑Safe in Java: A Hands‑On Demo

This article explains atomicity, thread safety, and thread‑unsafe behavior in Java, demonstrates a simple class with a volatile counter, runs two concurrent threads that increment it, shows the non‑atomic nature of i++, and analyzes why the final value may remain 1.

Javaatomicityconcurrency
0 likes · 4 min read
Why Incrementing a Counter Isn’t Thread‑Safe in Java: A Hands‑On Demo
FunTester
FunTester
Jul 14, 2019 · Fundamentals

Why a Simple Increment Fails in Multithreaded Java: A Concurrency Demo

This article explains atomicity, thread safety, and race conditions in Java by walking through a concrete example where multiple threads increment a shared volatile variable, showing why the non‑atomic i++ operation leads to inconsistent results.

Javaatomicityconcurrency
0 likes · 4 min read
Why a Simple Increment Fails in Multithreaded Java: A Concurrency Demo
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Jul 4, 2019 · Backend Development

Java Multithreading: Creation Methods, Lifecycle, Communication, Thread Pools, Locks, and Concurrent Containers

This article introduces Java multithreading fundamentals, covering four thread creation techniques, the five-stage thread lifecycle, communication methods, thread‑pool usage, common synchronization locks, and the main concurrent container classes for building high‑performance backend applications.

ConcurrentContainersJavaLocks
0 likes · 2 min read
Java Multithreading: Creation Methods, Lifecycle, Communication, Thread Pools, Locks, and Concurrent Containers
Java Captain
Java Captain
Jun 16, 2019 · Fundamentals

Thread Coordination in Java: Analogies, Scenarios, and Classic Concurrency Patterns

This article uses everyday analogies to explain thread coordination, then demonstrates practical Java examples for stopping threads with flags, pausing/resuming, joining, barrier synchronization, exchanging tools, and phaser control, and finally ties them together with the classic producer‑consumer problem using locks and conditions.

JavaProducer ConsumerThread Coordination
0 likes · 21 min read
Thread Coordination in Java: Analogies, Scenarios, and Classic Concurrency Patterns
Programmer DD
Programmer DD
Jun 16, 2019 · Backend Development

From Two‑Month Crawl to Four‑Hour Sprint: Optimizing a 20M‑Record Data Migration

This article chronicles a step‑by‑step performance overhaul of a 20‑million‑record migration project, detailing four architectural revisions—from a single‑threaded procedural script to a fully decoupled, multithreaded, interface‑driven solution—that reduced processing time from two months to just four hours while ensuring data consistency, recoverability, and scalability.

Batch ProcessingData MigrationJava
0 likes · 15 min read
From Two‑Month Crawl to Four‑Hour Sprint: Optimizing a 20M‑Record Data Migration
Wukong Talks Architecture
Wukong Talks Architecture
Apr 30, 2019 · Fundamentals

C# Multithreading Journey (4): Introduction to the Asynchronous Programming Model (APM)

This article introduces the Asynchronous Programming Model (APM) in C#, demonstrating how to use delegates and BeginInvoke/EndInvoke to run time‑consuming operations concurrently, includes sample code, explains delegate generation, and discusses practical considerations such as IAsyncResult handling and callback execution.

APMAsynchronousC
0 likes · 8 min read
C# Multithreading Journey (4): Introduction to the Asynchronous Programming Model (APM)
Wukong Talks Architecture
Wukong Talks Architecture
Apr 28, 2019 · Fundamentals

C# Multithreading Journey (3) – Using the Thread Pool

This article explains how C# thread pools reduce thread‑creation overhead, describes several ways to enqueue work (Task Parallel Library, ThreadPool.QueueUserWorkItem, asynchronous delegates, BackgroundWorker), provides practical code examples, and outlines important considerations such as thread naming, priority, and exception handling.

CTask Parallel LibraryThreadPool
0 likes · 9 min read
C# Multithreading Journey (3) – Using the Thread Pool
Wukong Talks Architecture
Wukong Talks Architecture
Apr 27, 2019 · Fundamentals

C# Multithreading Journey (2) – Creating and Starting Threads

This article explains how to create and start threads in C#, covering ThreadStart delegates, lambda expressions, passing parameters, naming threads, foreground/background distinctions, thread priority, and exception handling, with clear code examples and best‑practice recommendations.

CException HandlingLambda
0 likes · 13 min read
C# Multithreading Journey (2) – Creating and Starting Threads
MaGe Linux Operations
MaGe Linux Operations
Apr 4, 2019 · Backend Development

Build a Python Crawler to Auto‑Collect TV Drama Download Links

This article describes how the author built a Python web crawler to automatically generate numeric URLs, fetch TV drama pages from the 天天美剧 site, extract ed2k download links using regular expressions, and save them into organized text files, streamlining the download process with Thunder.

Crawlerdata collectionmultithreading
0 likes · 6 min read
Build a Python Crawler to Auto‑Collect TV Drama Download Links
Java Captain
Java Captain
Mar 30, 2019 · Backend Development

Understanding Java ThreadPoolExecutor: States, Key Parameters, and Workflow

This article explains why thread pools are essential for efficient resource utilization, describes the five lifecycle states of a ThreadPoolExecutor, details its most important parameters such as core and maximum pool sizes, work queue, keep‑alive time and rejection policies, and walks through the complete task execution workflow.

JavaThreadPoolThreadPoolExecutor
0 likes · 16 min read
Understanding Java ThreadPoolExecutor: States, Key Parameters, and Workflow
Java Captain
Java Captain
Mar 16, 2019 · Fundamentals

Java Multithreading: Concepts, Thread Creation, Synchronization, Thread Pools, and Deadlock Prevention

This article explains core Java multithreading concepts, covering the differences between parallel and concurrent execution, thread vs process, daemon threads, various ways to create threads, thread states, synchronization mechanisms, thread‑pool types, lock escalation, deadlock causes and prevention, as well as ThreadLocal and atomic utilities.

JavaThreadPooldeadlock
0 likes · 16 min read
Java Multithreading: Concepts, Thread Creation, Synchronization, Thread Pools, and Deadlock Prevention
Architects' Tech Alliance
Architects' Tech Alliance
Mar 14, 2019 · Backend Development

Understanding Distributed Systems, High Concurrency, and Multithreading in Java

This article explains the distinct concepts of distributed systems, high concurrency, and multithreading, clarifies their relationships, describes horizontal scaling and vertical splitting, and outlines how these techniques are applied in Java backend development while also promoting a free Java interview series.

Backend DevelopmentJavahigh concurrency
0 likes · 5 min read
Understanding Distributed Systems, High Concurrency, and Multithreading in Java
21CTO
21CTO
Mar 3, 2019 · Fundamentals

Why Java Still Dominates: Multithreading, Memory Management, and Cross‑Platform Power

This article explains Java's enduring popularity by highlighting its write‑once‑run‑anywhere philosophy, built‑in multithreading, automatic memory management, scalability, cross‑platform capabilities, security features, and its strong presence in enterprise, IoT, mobile, and big‑data applications.

JavaMemory ManagementProgramming Language
0 likes · 8 min read
Why Java Still Dominates: Multithreading, Memory Management, and Cross‑Platform Power
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 14, 2019 · Fundamentals

Java Lock Types and Their Implementation Details

This article provides a comprehensive overview of various Java lock mechanisms—including fair, non‑fair, reentrant, read/write, biased, lightweight, heavyweight, and spin locks—explaining their classifications, usage, underlying AQS implementation, and includes illustrative code snippets for each type.

AQSJavaLocks
0 likes · 22 min read
Java Lock Types and Their Implementation Details
MaGe Linux Operations
MaGe Linux Operations
Jan 13, 2019 · Backend Development

How to Build a High‑Performance Novel Site Crawler with MongoDB

This article walks through building a novel‑site crawler using MongoDB, detailing how to extract category links, manage URL states across multiple processes, and handle deduplication, while sharing screenshots of the framework, database logic, and final results.

MongoDBWeb Crawlingmultithreading
0 likes · 3 min read
How to Build a High‑Performance Novel Site Crawler with MongoDB
Tencent Database Technology
Tencent Database Technology
Jan 8, 2019 · Databases

Performance Optimization of TXRocks Sum Operation: Pushdown, Record Conversion, and Multithreaded Concurrency

This article analyzes the high space efficiency but poor sum performance of TXRocks compared to InnoDB, identifies three main bottlenecks, and details three optimizations—sum push‑down, selective record conversion, and multithreaded execution—that together reduce query latency to less than 5% of InnoDB’s original time.

Performance OptimizationRocksDBSum Pushdown
0 likes · 12 min read
Performance Optimization of TXRocks Sum Operation: Pushdown, Record Conversion, and Multithreaded Concurrency
360 Quality & Efficiency
360 Quality & Efficiency
Jan 4, 2019 · Backend Development

Improving addComment API Performance with Asynchronous Email Sending Using PHP pthreads

The article explains how a slow addComment API caused by a synchronous email‑sending step was optimized by converting the email operation to an asynchronous task using PHP's pthreads extension, detailing the problem analysis, installation of pthreads on Windows, configuration changes, and a working test example.

multithreadingpthreads
0 likes · 6 min read
Improving addComment API Performance with Asynchronous Email Sending Using PHP pthreads
MaGe Linux Operations
MaGe Linux Operations
Dec 31, 2018 · Backend Development

Master Python Web Scraping: 8 Essential urllib2 Techniques

This guide walks through eight practical Python urllib2 techniques for web crawling, covering basic GET/POST requests, proxy usage, cookie management, header spoofing, page parsing with regex and BeautifulSoup, captcha handling, gzip compression, and multithreaded fetching with a simple thread pool.

ProxyPythoncookies
0 likes · 8 min read
Master Python Web Scraping: 8 Essential urllib2 Techniques
Architects' Tech Alliance
Architects' Tech Alliance
Dec 25, 2018 · Backend Development

Understanding Distributed Systems, High Concurrency, and Multithreading in Java

This article explains the differences and relationships among distributed systems, high‑concurrency architectures, and multithreading, outlines their key concepts and implementation strategies, and then promotes a free five‑day Java advanced live course series covering databases, multithreading, Spring MVC, high‑concurrency patterns, and distributed transaction practice.

Javahigh concurrencymultithreading
0 likes · 6 min read
Understanding Distributed Systems, High Concurrency, and Multithreading in Java
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Nov 20, 2018 · Backend Development

Comprehensive Java Multithreading and Concurrency Interview Questions and Answers

This article compiles 46 essential Java multithreading and concurrency interview questions with detailed answers, covering fundamentals such as atomicity, visibility, ordering, thread creation methods, thread pools, synchronization mechanisms, lock types, AQS, deadlocks, and performance considerations for high‑performance backend development.

InterviewJavaSynchronization
0 likes · 24 min read
Comprehensive Java Multithreading and Concurrency Interview Questions and Answers
MaGe Linux Operations
MaGe Linux Operations
Nov 17, 2018 · Fundamentals

Master Python Multithreading: Processes, GIL, and Threading Modules Explained

This article explains the fundamentals of Python concurrency, covering the differences between processes and threads, the role of the Global Interpreter Lock (GIL), how to use the low‑level thread module and the high‑level threading module, synchronization primitives such as Lock, RLock, Event, Condition, and the Queue module for producer‑consumer patterns.

GILconcurrencymultithreading
0 likes · 19 min read
Master Python Multithreading: Processes, GIL, and Threading Modules Explained
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Nov 9, 2018 · Frontend Development

Unlock Smooth UI: Master Web Workers and superWorker for Multithreaded JavaScript

This article explains how JavaScript’s single‑threaded nature can cause UI jank, introduces Web Workers as a standard HTML5 solution for off‑loading heavy computations, details their API, limitations, practical use cases, and presents superWorker—a lightweight wrapper that simplifies worker creation and management.

FrontendPerformancemultithreading
0 likes · 12 min read
Unlock Smooth UI: Master Web Workers and superWorker for Multithreaded JavaScript
Programmer DD
Programmer DD
Oct 16, 2018 · Backend Development

Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools

This article provides a comprehensive analysis of Java's ThreadPoolExecutor source code, covering class relationships, core interfaces, abstract implementations, internal fields, constructors, the Worker class, and detailed walkthroughs of key methods such as execute, addWorker, runWorker, getTask, processWorkerExit, tryTerminate, and idle thread interruption, plus monitoring techniques.

Backend DevelopmentExecutorServiceJava
0 likes · 19 min read
Deep Dive into ThreadPoolExecutor: Uncover How Java Manages Thread Pools
Java Captain
Java Captain
Sep 14, 2018 · Fundamentals

Java Thread States: Overview of the Six Lifecycle States

This article explains Java's six thread states—NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, and TERMINATED—detailing their meanings, transitions, related waiting and synchronization queues, and comparing key thread-control methods such as sleep, yield, join, wait, and notify.

JavaThreadmultithreading
0 likes · 9 min read
Java Thread States: Overview of the Six Lifecycle States
Java Captain
Java Captain
Sep 12, 2018 · Fundamentals

Understanding Processes, Threads, Multithreading, and Thread Safety in Java

This article explains the fundamentals of processes, threads, and multithreading in Java, illustrates common thread‑safety problems with example code, and demonstrates how to achieve safe concurrent execution using synchronized blocks and the Lock API, including tryLock with timeout.

JavaLockmultithreading
0 likes · 11 min read
Understanding Processes, Threads, Multithreading, and Thread Safety in Java
Java Captain
Java Captain
Aug 28, 2018 · Databases

Design and Implementation of a Mini Database Connection Pool

This article explains the concept, design considerations, and step‑by‑step implementation of a lightweight database connection pool in Java, covering its core components, thread‑safe management, configuration handling, and a test demonstration of its functionality.

Connection PoolDatabaseDesign Patterns
0 likes · 5 min read
Design and Implementation of a Mini Database Connection Pool
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Aug 26, 2018 · Backend Development

Top 15 Java Thread Interview Questions Every Developer Must Master

This article compiles the most frequently asked Java multithreading and concurrency interview questions—covering thread ordering, locks, wait/sleep differences, blocking queues, producer‑consumer patterns, deadlocks, atomic operations, volatile, race conditions, thread dumps, and more—providing concise explanations and code hints to help candidates ace banking and high‑frequency trading developer interviews.

Interviewmultithreadingthreading
0 likes · 12 min read
Top 15 Java Thread Interview Questions Every Developer Must Master
Architecture Digest
Architecture Digest
Aug 18, 2018 · Fundamentals

A Curated Reading List of Essential Java Programming Books

This article presents a comprehensive, stage‑by‑stage recommendation of Java books covering fundamentals, advanced topics, architecture, software development processes, databases, networking, multithreading, and design patterns, helping developers navigate the overwhelming literature and deepen their expertise.

Javadatabasesmultithreading
0 likes · 27 min read
A Curated Reading List of Essential Java Programming Books
Architecture Digest
Architecture Digest
Aug 10, 2018 · Backend Development

Essential Skills for a Java Developer with Three Years of Experience

This article outlines the key Java knowledge areas—including syntax, collections, frameworks, databases, web concepts, data structures, JVM internals, design patterns, multithreading, and JDK source code—that a developer with three years of experience should master to excel in interviews and increase earning potential.

CollectionsInterviewJVM
0 likes · 11 min read
Essential Skills for a Java Developer with Three Years of Experience
Architect's Tech Stack
Architect's Tech Stack
Aug 8, 2018 · Backend Development

Deep Dive into Java AQS Shared‑Lock Implementation

This article explains the execution flow, source‑code details, and wake‑up logic of Java's AbstractQueuedSynchronizer shared‑lock mode, covering acquireShared, doAcquireShared, setHeadAndPropagate, doReleaseShared, and releaseShared methods with full code snippets and practical guidance.

AQSJavaSharedLock
0 likes · 11 min read
Deep Dive into Java AQS Shared‑Lock Implementation
MaGe Linux Operations
MaGe Linux Operations
Jul 30, 2018 · Backend Development

Build a Python Crawler to Automatically Grab Drama Download Links

This article explains how to create a Python web‑scraper that automatically generates URLs, fetches drama pages from a download site, extracts ed2k links with regular expressions, saves them to text files, and handles missing pages and filename restrictions efficiently.

CrawlerPythondrama-download
0 likes · 7 min read
Build a Python Crawler to Automatically Grab Drama Download Links
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.

JavaState Machinedata race
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 fundamentalsThread
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.

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

IO MultiplexingReactor Patternepoll
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.

Memory ManagementModel CompressionNEON SIMD
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.

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

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

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

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

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

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

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

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

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

PythonWeb Scrapinggzip
0 likes · 17 min read
Master Python Web Scraping: From Basic Requests to Multithreaded Crawlers