This article demystifies processes and threads with everyday analogies, outlines their core differences, explains why multithreading speeds up programs, and highlights common pitfalls such as thread‑safety issues, excessive threads, and crashes, providing interview‑ready knowledge for developers.
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.
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.
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.
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.
This article explains the differences and relationships between processes, threads, coroutines, and virtual threads, provides detailed Java code examples, compares their characteristics and performance, and offers practical guidance on choosing the right concurrency model for various scenarios.
This article explains the fundamental differences between processes, threads, coroutines, and virtual threads, shows how they are implemented in Java with code examples, compares their performance, and provides practical guidance on choosing the right concurrency model for various workloads.
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.
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.
The article analyzes why relying solely on operating‑system threads cannot easily achieve single‑machine million‑level concurrency, examining thread stack memory misconceptions, kernel‑level context‑switch costs, and how user‑space coroutine scheduling overcomes these limits.
The article explains why the Java JVM throws java.lang.OutOfMemoryError: Unable to create new native threads, outlines common causes such as thread leaks, insufficient RAM, other processes, and kernel limits, and provides practical solutions and troubleshooting steps to resolve the issue.
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.
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.
Using cooking metaphors, the article explains how CPUs execute instructions as threads, the role of operating systems in multitasking, the distinction between processes and threads, the relevance of core counts, and best practices for thread usage in single‑core and multi‑core environments.
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.
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.
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.
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.
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.
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.
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.
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.
This article explains the fundamentals of Java threading, covering process vs thread differences, context switching, daemon and user threads, thread states, synchronization mechanisms, interruption handling, and deadlock detection with concrete code examples and visual illustrations.
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.
This article explains the concepts of daemon and non‑daemon (user) threads in Java, outlines their differences, and provides clear code demonstrations showing how daemon threads terminate with the main thread while user threads continue running independently after the main thread ends.
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.
This article explains the fundamentals of operating‑system processes and threads, how the OS scheduler enables concurrent execution, the cost of context switches, and why Go implements lightweight user‑level goroutines to achieve efficient concurrency in modern applications.
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.
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.
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.
This article provides a comprehensive overview of Linux fundamentals, covering process and thread concepts, various inter‑process communication mechanisms, essential system calls, process descriptors, scheduling algorithms such as O(1) and CFS, synchronization primitives, and the operating system boot sequence.
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.
This article clarifies core operating‑system concepts such as tasks, jobs, hyper‑threading, threads, processes, fibers, monitors, and coroutines, explaining their differences, relationships, and how they enable efficient concurrent execution.
This article provides a comprehensive overview of operating system concepts including processes, threads, interprocess communication, synchronization mechanisms such as mutexes and semaphores, and various scheduling algorithms for batch, interactive, and real‑time systems.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
This article explores Linux process and thread fundamentals, traditional network service models, the C10K challenge, and advanced techniques such as epoll, event‑driven designs, and coroutine‑based asynchronous programming to improve scalability and performance.
