BestHub
Sign in
Tagged articles
39 articles
Page 1 of 1
Deepin Linux
Deepin Linux
Feb 7, 2026 · Fundamentals

Mastering Linux Process Synchronization: Prevent Race Conditions with Mutexes, Semaphores, and More

This comprehensive guide explains why race conditions occur in Linux processes, explores the underlying concepts of critical sections and synchronization, and provides practical examples of atomic operations, mutexes, semaphores, condition variables, read‑write locks, and spinlocks to ensure safe concurrent programming.

POSIXc++condition variable
0 likes · 39 min read
Mastering Linux Process Synchronization: Prevent Race Conditions with Mutexes, Semaphores, and More
Deepin Linux
Deepin Linux
Dec 25, 2025 · Operations

How to Optimize Linux Thread Stack Memory for High‑Concurrency Services

This article explains the fundamentals of Linux thread stack memory, identifies why default stack sizes can cause waste or overflow in high‑concurrency scenarios, and provides practical techniques—including stack‑size tuning, code refactoring, and memory‑mapping—to reduce memory usage and improve service stability.

LinuxMemory OptimizationPOSIX
0 likes · 34 min read
How to Optimize Linux Thread Stack Memory for High‑Concurrency Services
IT Services Circle
IT Services Circle
Nov 3, 2025 · Fundamentals

Why POSIX Matters: Unlocking Unix Compatibility and Portability

This article explains what POSIX is, its history, the organizations behind it, how it shaped Linux's success, and why understanding system calls versus library functions is essential for writing portable software across Unix‑like operating systems.

LinuxOperating SystemsPOSIX
0 likes · 17 min read
Why POSIX Matters: Unlocking Unix Compatibility and Portability
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
Liangxu Linux
Liangxu Linux
Sep 2, 2025 · Fundamentals

Master Linux Timers: From alarm() to timerfd – Choose the Right One

This article walks through the evolution of Linux timers—from the simple alarm() function, through setitimer() and POSIX timer APIs, to the modern timerfd interface—explaining their APIs, code examples, advantages, limitations, performance trade‑offs, and practical selection guidance for different projects.

LinuxPOSIXTimers
0 likes · 16 min read
Master Linux Timers: From alarm() to timerfd – Choose the Right One
Liangxu Linux
Liangxu Linux
Jun 24, 2025 · Fundamentals

Why HarmonyOS’s Microkernel Isn’t Linux Yet Runs Linux Apps

The article explains how HarmonyOS’s microkernel differs from Linux’s monolithic design, why it can still run Linux binaries through POSIX, ABI shim, and HDF layers, and what architectural choices enable high‑performance IPC, distributed operation, and deterministic scheduling.

ABI shimHarmonyOSIPC
0 likes · 12 min read
Why HarmonyOS’s Microkernel Isn’t Linux Yet Runs Linux Apps
Linux Code Review Hub
Linux Code Review Hub
May 20, 2025 · Fundamentals

Why HarmonyOS Microkernel Can Run Linux and Emulate Linux Containers

Although HarmonyOS uses a microkernel rather than a monolithic Linux kernel, it achieves Linux compatibility and container emulation through a combination of POSIX support, an ABI shim layer, high‑performance IPC/RPC mechanisms, and the Hardware Driver Framework, which together translate Linux calls into microkernel services.

ABI shimHardware Driver FrameworkHarmonyOS
0 likes · 13 min read
Why HarmonyOS Microkernel Can Run Linux and Emulate Linux Containers
Deepin Linux
Deepin Linux
Apr 21, 2025 · Backend Development

POSIX Multithreading and Network Programming in C: Threads, Synchronization, and Socket APIs

This article introduces the POSIX standard for portable multithreaded and network programming in C, explains thread creation, lifecycle, and synchronization mechanisms such as mutexes, semaphores and condition variables, and provides complete server‑client socket examples together with practical multithreaded file‑processing code and debugging tips.

POSIXSocketSynchronization
0 likes · 23 min read
POSIX Multithreading and Network Programming in C: Threads, Synchronization, and Socket APIs
Deepin Linux
Deepin Linux
Oct 30, 2024 · Fundamentals

An Introduction to POSIX Threads (Pthread) and Their Practical Usage in C/C++

This article provides a comprehensive overview of POSIX threads, covering their architecture, creation, synchronization, attributes, scheduling policies, advantages, drawbacks, and real‑world examples such as mutex protection, barrier synchronization, and a cross‑platform network server implementation.

C ProgrammingLinuxPOSIX
0 likes · 21 min read
An Introduction to POSIX Threads (Pthread) and Their Practical Usage in C/C++
21CTO
21CTO
Oct 11, 2024 · Fundamentals

Why macOS Sequoia’s UNIX Certification Matters for Developers

Apple’s macOS 15 Sequoia has become the latest officially certified UNIX® system, joining both Apple Silicon and x86‑64 entries, and the article explains the history of UNIX, POSIX standards, the XNU kernel’s BSD roots, and how these foundations shape modern macOS and iOS development.

Operating SystemPOSIXUNIX certification
0 likes · 8 min read
Why macOS Sequoia’s UNIX Certification Matters for Developers
Deepin Linux
Deepin Linux
Apr 13, 2024 · Fundamentals

Understanding POSIX: Concepts, Network APIs, and Semaphore Programming in C

This article explains the POSIX standards, their role in providing portable Unix-like system interfaces, demonstrates network client‑server programming with POSIX sockets, analyzes key socket functions and the TCP three‑way handshake, and introduces POSIX named and unnamed semaphores with example code for synchronization and producer‑consumer patterns.

Network programmingPOSIXUnix
0 likes · 26 min read
Understanding POSIX: Concepts, Network APIs, and Semaphore Programming in C
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)
Liangxu Linux
Liangxu Linux
Mar 17, 2024 · Fundamentals

Master Linux Synchronization: From Semaphores to Mutexes with Practical Code

Learn the core principles of synchronization and mutual exclusion in multi‑process or multi‑threaded Linux environments, explore design concepts such as atomic operations and deadlock avoidance, and see complete POSIX‑thread code examples using semaphores, condition variables, mutexes and spinlocks.

LinuxPOSIXSynchronization
0 likes · 8 min read
Master Linux Synchronization: From Semaphores to Mutexes with Practical Code
Linux Code Review Hub
Linux Code Review Hub
Jan 31, 2024 · Fundamentals

Is POSIX Coming to an End? A Historical Review and Future Outlook

The article surveys the evolution of POSIX abstractions from the 1970s to the present, explains why hardware trends and modern workloads expose limitations of the CPU‑centric model, and argues that a new set of higher‑level interfaces is needed for future systems.

I/O abstractionsOperating SystemsPOSIX
0 likes · 25 min read
Is POSIX Coming to an End? A Historical Review and Future Outlook
DataFunTalk
DataFunTalk
Sep 15, 2023 · Cloud Computing

Design and Architecture of Baidu CFS Large‑Scale Distributed File System and Metadata Service

The talk from DataFun Summit 2023 explains how Baidu's CFS storage builds a trillion‑file‑scale distributed file system by revisiting file system fundamentals, POSIX limitations, historical storage architectures, and introducing a lock‑free metadata service with single‑shard primitives, data‑layout optimizations, and a simplified client‑centric architecture that achieves high scalability and performance.

CFSDistributed File SystemPOSIX
0 likes · 31 min read
Design and Architecture of Baidu CFS Large‑Scale Distributed File System and Metadata Service
MaGe Linux Operations
MaGe Linux Operations
Jul 28, 2023 · Fundamentals

Mastering POSIX Threads in Linux: A Complete Guide to Pthreads

This article explains the limitations of the traditional Unix fork model, introduces POSIX threads as lightweight processes, details their data structures, core functions, creation, termination, synchronization primitives, attributes, and provides extensive C code examples for practical multithreaded programming on Linux.

C ProgrammingPOSIXpthreads
0 likes · 22 min read
Mastering POSIX Threads in Linux: A Complete Guide to Pthreads
Liangxu Linux
Liangxu Linux
Feb 4, 2023 · Fundamentals

Key Differences Between Unix and Linux Every Developer Should Know

Although Linux is often called a Unix‑like system, it differs in several fundamental ways such as the default shell, command‑line option styles, make utility capabilities, C compiler defaults, GNU tool availability, and the trademarked UNIX designation, all of which affect portability and script writing.

C CompilerGNULinux
0 likes · 6 min read
Key Differences Between Unix and Linux Every Developer Should Know
MaGe Linux Operations
MaGe Linux Operations
Jan 23, 2023 · Fundamentals

Key Differences Between Unix and Linux Every Developer Should Know

This article outlines the fundamental differences between Unix and Linux, covering shell defaults, option styles, make utilities, compiler conventions, GNU versus Linux distinctions, and the trademarked UNIX term, helping developers write portable scripts and build systems across various Unix-like platforms.

LinuxMakeOperating Systems
0 likes · 5 min read
Key Differences Between Unix and Linux Every Developer Should Know
MaGe Linux Operations
MaGe Linux Operations
Oct 13, 2022 · Fundamentals

Mastering POSIX Threads: From Basics to Advanced Synchronization

This article explains the limitations of the traditional Unix fork model, introduces lightweight POSIX threads as a faster alternative, and provides a comprehensive guide to thread creation, attributes, synchronization primitives, and cleanup functions using the pthread library in Linux.

LinuxPOSIXSynchronization
0 likes · 17 min read
Mastering POSIX Threads: From Basics to Advanced Synchronization
Open Source Linux
Open Source Linux
Sep 28, 2022 · Fundamentals

What Really Sets Linux Apart from Unix? Key Differences Explained

This article outlines the fundamental differences between Linux and Unix, covering topics such as the non‑standard Bash shell, the absence of long‑option support in Unix, variations in Make and C compilers, the distinction between GNU and Linux, and the trademarked UNIX name, providing a concise guide for developers navigating these operating systems.

C CompilerLinuxMake
0 likes · 6 min read
What Really Sets Linux Apart from Unix? Key Differences Explained
Liangxu Linux
Liangxu Linux
Apr 7, 2022 · Fundamentals

Master Linux File I/O: Open, Read, Write, and Advanced Flags Explained

This tutorial walks through Linux file programming fundamentals, covering how to open, create, read, write, and manipulate file descriptors and cursor positions with system calls like open, creat, read, write, lseek, and close, and demonstrates practical examples such as implementing a cp command, editing configuration files, and using both low‑level and standard C library I/O functions.

C ProgrammingFile I/OPOSIX
0 likes · 28 min read
Master Linux File I/O: Open, Read, Write, and Advanced Flags Explained
Laravel Tech Community
Laravel Tech Community
Aug 2, 2021 · Fundamentals

Wine 6.14 Release Highlights: Updated Mono Engine, 32‑to‑64‑Bit Thunk, GDI Enhancements, and Bug Fixes

Wine 6.14, the latest version of the open‑source compatibility layer that runs Windows applications on POSIX systems, introduces a Mono engine upgrade to 6.3.0, a new 32‑to‑64‑bit thunk in WOW64 DLLs, expanded GDI system call support, and resolves 30 known bugs affecting games and professional software.

Bug FixesCompatibility layerGDI
0 likes · 2 min read
Wine 6.14 Release Highlights: Updated Mono Engine, 32‑to‑64‑Bit Thunk, GDI Enhancements, and Bug Fixes
Liangxu Linux
Liangxu Linux
Mar 31, 2021 · Fundamentals

Understanding Linux I/O: From Application Buffers to Disk Writes

This article explains the Linux I/O stack, the flow of data from user‑space buffers through libc buffers, page cache, and kernel buffers to the physical disk, covering functions like fwrite, fflush, fsync, O_DIRECT, scheduling algorithms, consistency issues, and performance considerations.

FilesystemI/OLinux
0 likes · 12 min read
Understanding Linux I/O: From Application Buffers to Disk Writes
Programmer DD
Programmer DD
Mar 25, 2021 · Fundamentals

Why the Word “User” Is Killing Your Software Design (And How to Fix It)

The article warns that using the vague term “user” in software design creates security flaws and conceptual confusion, illustrated with ticket‑booking, Unix, and SaaS examples, and advises defining precise concepts like “team” and “member” early to avoid costly redesigns.

POSIXSaaSTerminology
0 likes · 7 min read
Why the Word “User” Is Killing Your Software Design (And How to Fix It)
Architects' Tech Alliance
Architects' Tech Alliance
Dec 7, 2020 · Fundamentals

Overview of Lustre Parallel File System Architecture and Performance Characteristics

The article provides a comprehensive overview of the Lustre parallel file system architecture, its core components, POSIX compliance, scalability, high‑performance networking, security features, data layout mechanisms, and performance considerations for large and small files, along with practical optimization tips for HPC environments.

HPCLustrePOSIX
0 likes · 17 min read
Overview of Lustre Parallel File System Architecture and Performance Characteristics
ITPUB
ITPUB
Jun 12, 2019 · Fundamentals

Mastering Linux Shared Memory IPC: Theory, API Calls, and a Complete Example

This article explains the principles of Linux shared memory interprocess communication, details the relevant data structures and system limits, walks through the essential API calls for creating, controlling, attaching, and detaching shared memory, and provides a full C program demonstrating parent‑child communication.

C ProgrammingIPCInterprocess Communication
0 likes · 7 min read
Mastering Linux Shared Memory IPC: Theory, API Calls, and a Complete Example
21CTO
21CTO
Jun 6, 2019 · Fundamentals

Unix vs Linux: Uncover the History and Key Differences Shaping Modern Computing

This article traces the origins of Unix from the 1960s AT&T Bell Labs project, explains how Linux emerged from the GNU initiative and Linus Torvalds' kernel, and compares their philosophies, licensing, ecosystem, and current relevance across servers, cloud, embedded devices, and modern development.

BSDLinuxOperating Systems
0 likes · 12 min read
Unix vs Linux: Uncover the History and Key Differences Shaping Modern Computing
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