BestHub
Sign in
Tagged articles
56 articles
Page 1 of 1
Deepin Linux
Deepin Linux
May 1, 2026 · Fundamentals

Mastering Linux Kernel Threads: Core Mechanisms and Scheduling

This article explains Linux kernel threads from basic concepts to deep internals, covering their data structures, creation, execution flow, scheduling strategies, context‑switch overhead, synchronization primitives, interrupt handling, and a practical kswapd memory‑reclaim case study, providing concrete code examples and step‑by‑step analysis.

LinuxMemory ManagementScheduling
0 likes · 42 min read
Mastering Linux Kernel Threads: Core Mechanisms and Scheduling
Linux Tech Enthusiast
Linux Tech Enthusiast
Dec 23, 2025 · Fundamentals

How Many Threads Can a Single Linux Process Create?

The article explains Linux virtual memory layout, shows that a 32‑bit process can create roughly 380 threads due to an 8 MB default stack, while a 64‑bit process can theoretically spawn millions of threads but is constrained by kernel parameters such as threads‑max, pid_max and max_map_count.

LinuxProcess LimitsStack Size
0 likes · 7 min read
How Many Threads Can a Single Linux Process Create?
Liangxu Linux
Liangxu Linux
Oct 25, 2025 · Fundamentals

Master Linux Threads: Creation, Control, and Scheduling Explained

This guide explains Linux thread fundamentals, covering definitions, differences from processes, user‑level vs kernel‑level models, creation and termination with pthread APIs, attribute settings, cancellation, cleanup, detaching, and scheduling policies, all illustrated with complete code examples.

LinuxPOSIXScheduling
0 likes · 18 min read
Master Linux Threads: Creation, Control, and Scheduling Explained
Liangxu Linux
Liangxu Linux
Oct 19, 2025 · Fundamentals

Master Linux Thread Programming: From Basics to Advanced Control

This article provides a comprehensive guide to Linux threads, covering fundamental concepts, the distinction between processes and threads, user‑level vs kernel‑level threading, thread creation and termination with POSIX APIs, attribute settings, cancellation, cleanup, detachment, scheduling policies, and practical code examples.

LinuxPOSIXThreads
0 likes · 17 min read
Master Linux Thread Programming: From Basics to Advanced Control
Deepin Linux
Deepin Linux
Jul 1, 2025 · Backend Development

Master C++ Concurrency: Processes, Threads, and IO Multiplexing Explained

This article explores C++ concurrent programming techniques, covering multi‑process fundamentals, process creation with fork(), inter‑process communication methods, multi‑threading using std::thread, synchronization tools like mutexes and condition variables, and efficient I/O handling through select, poll, and epoll multiplexing, with practical code examples.

IO MultiplexingLinuxThreads
0 likes · 26 min read
Master C++ Concurrency: Processes, Threads, and IO Multiplexing Explained
Java Tech Enthusiast
Java Tech Enthusiast
May 31, 2025 · Fundamentals

Why Threads Alone Struggle to Achieve Million‑Scale Concurrency and How Coroutines Provide a Better Solution

The article examines why relying solely on threads cannot achieve single‑machine million‑level concurrency, analyzing thread resource consumption, context‑switch overhead, and contrasting it with user‑space coroutine scheduling that offers predictable, low‑cost switches, making coroutines better suited for IO‑intensive high‑concurrency scenarios.

CoroutinesSchedulingThreads
0 likes · 6 min read
Why Threads Alone Struggle to Achieve Million‑Scale Concurrency and How Coroutines Provide a Better Solution
Ops Development & AI Practice
Ops Development & AI Practice
Mar 1, 2025 · Fundamentals

Understanding Concurrency Scheduling Models: From User Threads to Go’s M:P:G Scheduler

This article explains the main concurrency scheduling models—including user‑level, kernel‑level, two‑level (M:N), and coroutine approaches—covers common scheduling algorithms, and details Go’s unique M:P:G scheduler, highlighting its principles, workflow, and advantages for high‑performance parallel execution.

GoroutineSchedulingThreads
0 likes · 9 min read
Understanding Concurrency Scheduling Models: From User Threads to Go’s M:P:G Scheduler
JD Cloud Developers
JD Cloud Developers
Nov 19, 2024 · Fundamentals

When to Choose Coroutines Over Threads: A Deep Dive into Java/Kotlin Concurrency

This article compares coroutines and threads for high‑concurrency and I/O‑intensive workloads versus CPU‑bound tasks, discusses Kotlin coroutine adoption, presents multithreading fundamentals, highlights performance pitfalls like System.currentTimeMillis, and offers code examples and optimization strategies for backend developers.

CoroutinesKotlinThreads
0 likes · 8 min read
When to Choose Coroutines Over Threads: A Deep Dive into Java/Kotlin Concurrency
Liangxu Linux
Liangxu Linux
Apr 9, 2024 · Fundamentals

How to Handle Signals in Multithreaded Linux Programs (C Example)

This article explains the differences between threads and processes in Linux, introduces the concept of POSIX signals, describes how signals are delivered and handled in multithreaded programs, and provides a complete C example demonstrating proper signal handling across threads.

LinuxPOSIXThreads
0 likes · 5 min read
How to Handle Signals in Multithreaded Linux Programs (C Example)
IT Services Circle
IT Services Circle
Dec 23, 2023 · Fundamentals

Java Multithreading: Processes, Threads, Creation Methods, and Common Controls

This article explains the fundamental concepts of processes and threads, uses a gaming analogy to illustrate their relationship, and details three ways to create threads in Java—extending Thread, implementing Runnable, and implementing Callable—along with common thread control methods such as sleep, join, and setDaemon.

CallableRunnableThreads
0 likes · 9 min read
Java Multithreading: Processes, Threads, Creation Methods, and Common Controls
政采云技术
政采云技术
Oct 31, 2023 · Fundamentals

Understanding Java Threads, Thread Models, and Scheduling

This article explains what threads are, how Java maps its threads to operating‑system thread models (1:1, N:1, N:M), the differences between kernel and user threads, thread scheduling, context switching, priority handling, and includes sample Java code to compare serial and multithreaded execution.

Operating SystemThreadsconcurrency
0 likes · 19 min read
Understanding Java Threads, Thread Models, and Scheduling
政采云技术
政采云技术
Sep 6, 2023 · Fundamentals

Understanding Threads, Multithreading, and Virtual Threads in Java

This article explains the concept of threads in computer science, demonstrates how Java encapsulates threads with the Thread class, shows basic and multithreaded examples, introduces thread pools and their management, and details the new virtual thread model introduced by Project Loom for high‑throughput, low‑overhead concurrency.

JDKThreadsVirtual Threads
0 likes · 15 min read
Understanding Threads, Multithreading, and Virtual Threads in Java
Selected Java Interview Questions
Selected Java Interview Questions
Aug 20, 2023 · Backend Development

Understanding Daemon and User Threads in Java

This article explains the concepts of daemon and user threads in Java, how to set a thread as daemon or user using Thread.setDaemon, the differences in lifecycle behavior, appropriate use cases, and includes example code demonstrating each type and their impact on JVM termination.

Daemon ThreadThreadsUser Thread
0 likes · 5 min read
Understanding Daemon and User Threads in Java
Programmer DD
Programmer DD
Jul 13, 2023 · Mobile Development

Inside Meta’s Threads: How the Viral App Was Built for Mobile and Backend

The article dissects Meta's Threads app, detailing its explosive user growth, the mobile engineering choices for Android and iOS—including universal APKs, Jetpack Compose UI, and large share extensions—while also revealing the Python‑based Cinder backend, performance optimizations, startup profiling, and the extensive code sharing with Instagram.

App ArchitectureCinderMobile Development
0 likes · 10 min read
Inside Meta’s Threads: How the Viral App Was Built for Mobile and Backend
21CTO
21CTO
Jul 10, 2023 · Backend Development

Inside Threads: How Meta Built Its New Social App’s Backend Stack

The article examines Meta’s Threads app, comparing its features and user experience with Twitter, and dives deep into the backend technologies—including Python 3.10, a custom Cinder JIT, Django customizations, and supporting services—that power the rapidly growing platform.

BackendCinderDjango
0 likes · 9 min read
Inside Threads: How Meta Built Its New Social App’s Backend Stack
Liangxu Linux
Liangxu Linux
Apr 18, 2023 · Fundamentals

How to Monitor Every Thread of an Embedded Linux Process with top -H

This guide shows how to create a multi‑threaded C program on embedded Linux, set thread names with pthread_setname_np, and use the top command with the -H option to display each thread’s status, illustrating the difference when thread names are omitted.

LinuxThreadsdebugging
0 likes · 6 min read
How to Monitor Every Thread of an Embedded Linux Process with top -H
IT Services Circle
IT Services Circle
Jun 2, 2022 · Fundamentals

Comprehensive Guide to Java Concurrency: Threads, Locks, Executors, and Synchronization Primitives

This article provides an in-depth overview of Java concurrency, covering thread creation, lifecycle, synchronization mechanisms such as locks, semaphores, barriers, atomic classes, concurrent collections, executor frameworks, fork/join, CompletableFuture, and various blocking queues, with code examples and implementation details.

BlockingQueueExecutorServiceLocks
0 likes · 52 min read
Comprehensive Guide to Java Concurrency: Threads, Locks, Executors, and Synchronization Primitives
Open Source Linux
Open Source Linux
Feb 15, 2022 · Fundamentals

Understanding Processes, Threads, Memory & File Management in Operating Systems

This article explains the differences between processes and threads, outlines process states, describes inter‑process communication methods, details memory allocation strategies and page‑replacement algorithms, covers file allocation techniques, disk I/O scheduling, and outlines deadlock conditions and prevention methods.

File SystemsMemory ManagementThreads
0 likes · 20 min read
Understanding Processes, Threads, Memory & File Management in Operating Systems
Liangxu Linux
Liangxu Linux
Mar 28, 2021 · Fundamentals

How Linux Schedules Processes and Threads: From Tasks to CFS and Real‑Time

This article explains Linux's scheduling subsystem in depth, covering process definitions, memory layout, state machines, context switches, priority and timeslice handling, the modular scheduler framework, various scheduler classes such as CFS, real‑time and deadline, group scheduling, signal processing, and the differences between kernel and user threads, providing a comprehensive guide for developers and system engineers.

CFSLinuxReal-Time
0 likes · 35 min read
How Linux Schedules Processes and Threads: From Tasks to CFS and Real‑Time
Liangxu Linux
Liangxu Linux
Dec 30, 2020 · Backend Development

How Servers Serve Millions: Processes, Threads, and Event Loops Explained

This article explains how servers handle massive concurrent requests by evolving from simple multi‑process models to lightweight threads, then to event‑driven architectures with I/O multiplexing, highlighting the trade‑offs of blocking versus non‑blocking I/O and the role of coroutines.

IO MultiplexingNon-blocking IOThreads
0 likes · 12 min read
How Servers Serve Millions: Processes, Threads, and Event Loops Explained
Code Ape Tech Column
Code Ape Tech Column
Aug 21, 2020 · Fundamentals

Mastering Java Threads: From Basics to Priority and State Management

This article explains the fundamentals of Java threads, contrasting them with processes, demonstrates thread creation via extending Thread and implementing Runnable, discusses the benefits of multithreading, covers thread priority settings, and details the lifecycle states and transitions with practical code examples.

BackendThreadsconcurrency
0 likes · 9 min read
Mastering Java Threads: From Basics to Priority and State Management
Liangxu Linux
Liangxu Linux
Jul 16, 2020 · Fundamentals

Demystifying Linux Processes, Threads, IPC, and Scheduling

This article provides a comprehensive overview of Linux fundamentals, covering process and thread concepts, the fork and exec system calls, various inter‑process communication mechanisms, memory layout, scheduling algorithms such as O(1) and CFS, synchronization primitives, and the boot sequence, all illustrated with code snippets and diagrams.

IPCLinuxScheduling
0 likes · 34 min read
Demystifying Linux Processes, Threads, IPC, and Scheduling
Architecture Digest
Architecture Digest
Feb 11, 2020 · Backend Development

Improving Server Concurrency and Performance: Methods and Strategies

This article explains what server concurrency means, how to measure it with throughput and stress testing, and presents practical techniques such as CPU parallelism, reducing context switches and lock contention, using persistent connections, optimizing I/O models, and scaling hardware to boost overall server performance.

I/O ModelsThreadsbackend-development
0 likes · 15 min read
Improving Server Concurrency and Performance: Methods and Strategies
Programmer DD
Programmer DD
Nov 13, 2019 · Fundamentals

Understanding Processes and Threads: A Factory Analogy Explained

This article uses a factory analogy to demystify operating‑system concepts such as processes, threads, mutual‑exclusion locks, and semaphores, illustrating how CPUs, workspaces, workers, and access controls interact to enable concurrent execution while preventing conflicts.

Operating SystemThreadsconcurrency
0 likes · 5 min read
Understanding Processes and Threads: A Factory Analogy Explained
Programmer DD
Programmer DD
Oct 7, 2019 · Backend Development

How Many Threads Can a Java JVM Actually Handle? Limits, Experiments, and Tips

This article explores the maximum number of threads a Java Virtual Machine can support, examining factors such as CPU, operating system, JVM version, and memory, and presents real‑world experiments, code examples, and theoretical calculations to help developers understand and manage thread limits effectively.

JVMMemoryStack
0 likes · 6 min read
How Many Threads Can a Java JVM Actually Handle? Limits, Experiments, and Tips
Node Underground
Node Underground
Jul 10, 2019 · Backend Development

Mastering Processes and Threads in Node.js: From Basics to Multi‑Process Architecture

This comprehensive guide explains the fundamentals of processes and threads, demonstrates practical Node.js demos for single‑threaded and multi‑threaded scenarios, and walks through creating child processes, multi‑process architectures, and daemon services, providing clear code examples and performance insights for backend developers.

BackendNode.jsThreads
0 likes · 19 min read
Mastering Processes and Threads in Node.js: From Basics to Multi‑Process Architecture
21CTO
21CTO
May 24, 2019 · Backend Development

How Many Threads Can a JVM Actually Support? Limits, Factors, and Real-World Tests

The maximum number of Java Virtual Machine threads depends on CPU, operating system, JVM version, memory allocation, and configuration, with practical limits ranging from a few thousand on modest hardware to over ten thousand on high‑end systems, as demonstrated by several real‑world experiments.

JVMMemoryThreads
0 likes · 5 min read
How Many Threads Can a JVM Actually Support? Limits, Factors, and Real-World Tests
21CTO
21CTO
Apr 11, 2019 · Backend Development

Mastering Java Concurrency: Threads, Locks, ThreadPools, and More

This comprehensive guide explores Java concurrency fundamentals—including processes, threads, daemon threads, thread states, synchronization methods, scheduling algorithms, wait vs. sleep, ThreadLocal, locks, volatile, CAS, Unsafe, thread pools, executor policies, blocking queues, Fork/Join, atomic classes, barriers, semaphores, deadlock, IPC, and interruption—providing essential knowledge for building high‑performance backend systems.

LockSynchronizationThreadPool
0 likes · 26 min read
Mastering Java Concurrency: Threads, Locks, ThreadPools, and More
MaGe Linux Operations
MaGe Linux Operations
Mar 1, 2019 · Fundamentals

Understanding Linux Process Management: From Fork to Scheduling

This article explains Linux process management fundamentals, covering process concepts, lifecycle, threads, priorities, context switches, interrupt handling, process states, memory layout, and the O(1) CPU scheduler, providing clear diagrams and practical insights for developers and system engineers.

LinuxOperating SystemScheduling
0 likes · 14 min read
Understanding Linux Process Management: From Fork to Scheduling
MaGe Linux Operations
MaGe Linux Operations
Feb 17, 2019 · Fundamentals

Understanding Linux Processes, Threads, and Zombie Processes: A Deep Dive

This article explains how Linux manages processes and threads, describes the creation and lifecycle of processes, the role of the process control block, the causes and handling of zombie processes, and compares multi‑process and multi‑threaded designs, providing practical tips for avoiding common pitfalls.

LinuxOS fundamentalsThreads
0 likes · 13 min read
Understanding Linux Processes, Threads, and Zombie Processes: A Deep Dive
MaGe Linux Operations
MaGe Linux Operations
Jan 31, 2019 · Fundamentals

Master Linux Process Management: From Fork to Scheduler

This article explains Linux process management fundamentals, covering process concepts, lifecycle, threads, priorities, context switches, interrupts, process states, memory layout, and the O(1) scheduler, with clear diagrams to help readers understand kernel behavior and performance impact.

Operating SystemSchedulingThreads
0 likes · 14 min read
Master Linux Process Management: From Fork to Scheduler
UC Tech Team
UC Tech Team
Oct 30, 2018 · Frontend Development

Enabling WebAssembly Threads with Pthreads in Chrome via Origin Trials

This article explains how to compile C/C++ code to WebAssembly with pthread support, run multithreaded WebAssembly modules in Chrome using Origin Trials, and provides step‑by‑step instructions, example code, and configuration details for developers.

ChromeEmscriptenThreads
0 likes · 8 min read
Enabling WebAssembly Threads with Pthreads in Chrome via Origin Trials
360 Tech Engineering
360 Tech Engineering
Sep 28, 2018 · Fundamentals

Fundamentals of Application Programming: OS Concepts, System Calls, Processes, Threads, and Coroutines

This article introduces essential programming fundamentals, covering Unix system architecture, the distinction between system calls and library functions, user and kernel modes, the execution flow of a simple hello‑world program, and core concepts such as processes, threads, coroutines, and parent‑child process sharing.

CoroutinesOperating SystemSystem Calls
0 likes · 7 min read
Fundamentals of Application Programming: OS Concepts, System Calls, Processes, Threads, and Coroutines
MaGe Linux Operations
MaGe Linux Operations
Apr 7, 2018 · Fundamentals

Master Linux Process Management: From Fork to Scheduling and Memory

An in‑depth guide to Linux process management covering process concepts, lifecycle, threads, priority, context switching, interrupt handling, process states, memory layout, and the O(1) scheduler, illustrated with diagrams to help readers understand kernel behavior and performance implications.

LinuxOperating SystemScheduling
0 likes · 16 min read
Master Linux Process Management: From Fork to Scheduling and Memory
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.

RunnableThreadSubclassThreads
0 likes · 7 min read
Creating and Starting Java Threads: Subclassing Thread and Implementing Runnable
360 Quality & Efficiency
360 Quality & Efficiency
Nov 23, 2017 · Operations

Ten Micro‑Metrics to Strengthen Performance Testing Reports

This article explains why traditional macro performance metrics are insufficient, introduces ten essential micro‑metrics covering memory, thread, and network aspects, and shows how to capture them using GC logs, thread dumps, and tools like netstat or open‑source APM solutions.

APMMemoryThreads
0 likes · 8 min read
Ten Micro‑Metrics to Strengthen Performance Testing Reports
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.

JMMSynchronizationThreads
0 likes · 24 min read
Understanding Java Thread Concurrency: Concepts, Lifecycle, and the Java Memory Model
Architecture Digest
Architecture Digest
Dec 4, 2016 · Fundamentals

Understanding Asynchronous and Concurrent Programming Models on the JVM

The article explains why asynchronous programming improves resource utilization, compares synchronous and asynchronous styles, and reviews common JVM concurrency models—including threads, thread pools, futures, reactive extensions, async‑await, fibers, and actors—while discussing their trade‑offs and suitability for distributed systems.

ActorsAsynchronousFutures
0 likes · 16 min read
Understanding Asynchronous and Concurrent Programming Models on the JVM
ITPUB
ITPUB
Oct 25, 2016 · Fundamentals

How Linux Implements Signals Across Threads and Thread Groups

This article explains the POSIX requirements for signals in multithreaded Linux programs, details the kernel structures such as task_struct and signal_struct that enable shared signal handling, and walks through the key code paths—including copy_signal, copy_sighand, __send_signal, tkill/tgkill, and group exit—that manage signal delivery and thread‑group termination.

LinuxPOSIXThreads
0 likes · 12 min read
How Linux Implements Signals Across Threads and Thread Groups
MaGe Linux Operations
MaGe Linux Operations
Oct 18, 2016 · Fundamentals

Unraveling Linux Threads: From Classic Processes to NPTL and Beyond

This article explains how Linux implements threads, contrasting traditional process definitions with lightweight processes, detailing the evolution from the early linuxthreads library to the modern NPTL implementation, and exploring POSIX requirements, thread groups, signal handling, and the experimental NGPT model.

LinuxNPTLOperating System
0 likes · 10 min read
Unraveling Linux Threads: From Classic Processes to NPTL and Beyond
ITPUB
ITPUB
Jul 8, 2016 · Fundamentals

How Linux Threads Share Signals: Inside task_struct and Signal Handling

This article explains how Linux implements POSIX signal handling in multithreaded applications, detailing the relationship between signals and threads, the kernel structures like task_struct, signal_struct, and how signals are delivered, blocked, and cause group exits within a thread group.

LinuxPOSIXThreads
0 likes · 15 min read
How Linux Threads Share Signals: Inside task_struct and Signal Handling
MaGe Linux Operations
MaGe Linux Operations
May 19, 2016 · Fundamentals

Master Linux Process Management: From Fork to O(1) Scheduler

This article, translated from IBM’s RedBook, explains Linux process management fundamentals—including process lifecycle, threads, priorities, context switching, interrupt handling, process states, memory layout, and the O(1) scheduler—providing clear insights into how the kernel handles processes and impacts system performance.

LinuxOS fundamentalsScheduling
0 likes · 16 min read
Master Linux Process Management: From Fork to O(1) Scheduler
High Availability Architecture
High Availability Architecture
Mar 2, 2016 · Fundamentals

Understanding Concurrency: Threads, Goroutine, Actor Model, and Thread‑Pool Strategies

This article explores the fundamentals of concurrency versus parallelism, the challenges of writing correct concurrent programs, the evolution from OS threads to green threads, Goroutine scheduling, actor‑model concepts, and modern strategies such as thread pools, async callbacks, and Rust's ownership model.

GoroutineParallelismThreads
0 likes · 20 min read
Understanding Concurrency: Threads, Goroutine, Actor Model, and Thread‑Pool Strategies
21CTO
21CTO
Oct 24, 2015 · Fundamentals

Understanding Threads and Processes: Scheduling, Models, and Multicore Basics

This article demystifies threads and processes, explaining OS task scheduling, the differences between them, various threading models (one-to-one, many-to-one, many-to-many), their relationship with multicore CPUs, and how to view thread and process information on Windows.

Operating SystemSchedulingThreads
0 likes · 16 min read
Understanding Threads and Processes: Scheduling, Models, and Multicore Basics
Qunar Tech Salon
Qunar Tech Salon
Jan 17, 2015 · Backend Development

Four Styles of Java Concurrency: Threads, Executors, ForkJoin, and Actors

This article compares four Java concurrency approaches—raw threads, the Executor framework, parallel streams backed by ForkJoinPool, and the Actor model—explaining their implementations, advantages, drawbacks, and typical pitfalls through concrete code examples and practical discussion.

ActorsExecutorsForkJoin
0 likes · 13 min read
Four Styles of Java Concurrency: Threads, Executors, ForkJoin, and Actors