Pipes, Anonymous Pipes, and Named Pipes

In modern operating systems, Inter-Process Communication (IPC) serves as the fundamental mechanism that allows multiple processes to coordinate, synchronize, and exchange data. Among the various IPC techniques available, the pipe remains one of the most classic and essential implementations.

Rooted in the Unix philosophy of "everything is a file" and the concept of "composing small tools to perform complex tasks," a pipe is essentially a kernel-managed buffer that facilitates a unidirectional data stream between processes.
Before diving into the specific types, it is crucial to understand the inherent properties that define a pipe:

• Half-Duplex Communication: Data flows in only one direction. If a bidirectional (full-duplex) conversation is required, two separate pipes must be established.
• Byte-Stream Service: Pipes treat data as a continuous stream of bytes. There are no inherent message boundaries; therefore, the reading process is responsible for parsing the data into meaningful formats.
• Lifecycle Management: A pipe's existence is typically tied to the processes using it. Once all file descriptors associated with the pipe are closed, the kernel automatically destroys the buffer.
• Lineage Constraints (for Anonymous Pipes): Certain types of pipes can only be accessed by processes that share a common ancestry.

In daily Linux operations, the most common encounter with pipes is through the shell command line using the | symbol. For instance, running cat file.txt | grep "error" creates a pipe that redirects the standard output of cat directly into the standard input of grep.

Anonymous Pipes

Anonymous pipes are the most basic form of pipe. They lack a name within the file system, which means they cannot be accessed by an arbitrary process via a file path.

Mechanism and Usage

An anonymous pipe is created entirely in memory. When a process requests a pipe, the operating system allocates a buffer and returns two File Descriptors (FDs): one specifically for reading (pipefd[0]) and one for writing (pipefd[1]).

Because these pipes have no "address" in the file system, they can only be shared through process inheritance. Typically, a parent process creates the pipe and then calls fork(). The child process inherits the parent's file descriptors, allowing the two to communicate.

Implementation Example (Python)

The following Python script demonstrates how to use os.pipe() and os.fork() to establish communication between a parent and a child process.

import os
import sys

def anonymous_pipe_demo():
    # Create an anonymous pipe: returns (read_fd, write_fd)
    r, w = os.pipe()

    # Create a child process
    pid = os.fork()

    if pid < 0:
        sys.exit("Fork failed")
    elif pid == 0:
        # --- Child Process: The Reader ---
        # Close the unused write end to prevent resource leaks
        os.close(w) 
        print("[Child] Ready to read from the pipe...")
        
        # Use fdopen to treat the file descriptor as a file object
        with os.fdopen(r, 'r') as f:
            data = f.read()
            print(f"[Child] Received: {data}")
    else:
        # --- Parent Process: The Writer ---
        # Close the unused read end
        os.close(r) 
        print("[Parent] Writing data to the pipe...")
        
        with os.fdopen(w, 'w') as f:
            f.write("Hello from the parent via an Anonymous Pipe!")
            
        # Wait for the child process to finish
        os.wait()

if __name__ == "__main__":
    anonymous_pipe_demo()

Named Pipes (FIFOs)

While anonymous pipes are efficient, their requirement for a shared lineage limits their utility. To enable communication between completely unrelated processes, the operating system provides Named Pipes, also known as FIFOs (First-In, First-Out).

Mechanism and Usage

Unlike anonymous pipes, a named pipe exists as a special file within the file system. Any process with the appropriate permissions can access the pipe simply by knowing its filename.

• File System Visibility: You can identify a named pipe using ls -l; its type is denoted by the letter p.
• Persistence: The "name" of the pipe remains in the file system even after the processes have finished communicating. It must be explicitly deleted (e.g., via rm or os.unlink()).
• Blocking Behavior: Named pipes implement a synchronization mechanism. If a process attempts to open a pipe for reading but no process has opened it for writing (or vice versa), the opening process will typically block until the other end is connected.

Command Line Demonstration

In a Linux terminal, you can create and use a named pipe using the mkfifo command:

# 1. Create the named pipe
mkfifo my_named_pipe

# 2. In Terminal A: Write data (this will block until a reader connects)
echo "Hello from the Named Pipe!" > my_named_pipe

# 3. In Terminal B: Read the data
cat < my_named_pipe

Implementation Example (Python)

The following code demonstrates how to create and manage a named pipe programmatically.

import os
import time

pipe_path = "/tmp/my_named_pipe"

# Clean up if the pipe already exists from a previous run
if os.path.exists(pipe_path):
    os.unlink(pipe_path)

# Create the named pipe (FIFO)
os.mkfifo(pipe_path)
print(f"Named pipe created at: {pipe_path}")

try:
    print("Waiting for a writer to connect...")
    # Open the pipe in read-only mode (this blocks until a writer connects)
    with open(pipe_path, 'r') as f:
        while True:
            data = f.read()
            if not data:
                break
            print(f"Data received: {data.strip()}")
finally:
    # Ensure the pipe is removed from the filesystem
    if os.path.exists(pipe_path):
        os.unlink(pipe_path)
    print("Named pipe destroyed.")

Summary and Selection Guide

Choosing between an anonymous pipe and a named pipe depends entirely on the relationship between your processes and the required level of persistence.

Decision Logic

1. Use Anonymous Pipes when: You are working within a single application that spawns child processes (e.g., a shell or a task runner) and you need a lightweight, high-speed way to pass data between them. Since they don't involve the file system, they carry less overhead.
2. Use Named Pipes when: You have two independent, standalone applications that need to exchange data locally. This is ideal for simple client-server models, local logging services, or any scenario where processes do not share a common ancestor but can agree on a file path.