Impara Inter-Process Communication: Pipes and Shared Memory

Inter-process communication (IPC) is essential when you need multiple processes to exchange data or synchronize their actions. In Linux, several IPC mechanisms exist, each suited for different scenarios. Two of the most commonly used are pipes and shared memory.

A pipe provides a unidirectional communication channel between processes, typically related by a parent-child relationship. Data written to one end of the pipe can be read from the other. Pipes are simple to use and do not require explicit synchronization primitives, but they only allow a one-way flow and work best for small, transient data.

Shared memory allows processes to map the same region of physical memory into their address spaces, enabling them to exchange data rapidly. However, since both processes can access the same memory at any time, you must implement your own synchronization to avoid race conditions or data corruption.

Understanding when to use pipes versus shared memory depends on your needs for speed, complexity, and synchronization.

pipe_example.c


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    int fd[2];
    pid_t pid;
    char write_msg[] = "Hello from parent!";
    char read_msg[100];

    // Create a pipe
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    // Fork a child process
    pid = fork();

    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // Child process
        close(fd[1]); // Close write end
        ssize_t n = read(fd[0], read_msg, sizeof(read_msg) - 1);
        if (n >= 0) {
            read_msg[n] = '\0';
            printf("Child read: %s\n", read_msg);
        } else {
            perror("read");
        }
        close(fd[0]);
    } else {
        // Parent process
        close(fd[0]); // Close read end
        write(fd[1], write_msg, strlen(write_msg));
        close(fd[1]);
        wait(NULL); // Wait for child to finish
    }
    return 0;
}

The previous example demonstrates how a parent process can create a pipe and use it to send data to its child. When you call the pipe system call, it returns two file descriptors: one for reading and one for writing. Both the parent and child inherit these file descriptors after fork, which means either can read or write unless you explicitly close the unused ends.

Properly closing unused file descriptors is crucial to prevent deadlocks and resource leaks. In the example, the parent closes the read end and writes a message, while the child closes the write end and reads the message. This ensures that each process only uses the end of the pipe it needs.

Synchronization issues can arise if, for example, both processes attempt to read or write simultaneously, or if a process reads before data is written. Pipes provide some built-in synchronization—read will block until data is available—but for more complex communication, especially with shared memory, you must implement your own locking or signaling mechanisms to avoid race conditions.

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 1

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Scorri per mostrare il menu

Understanding when to use pipes versus shared memory depends on your needs for speed, complexity, and synchronization.

pipe_example.c


              1234567891011121314151617181920212223242526272829303132333435363738394041424344
            
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

int main() {
    int fd[2];
    pid_t pid;
    char write_msg[] = "Hello from parent!";
    char read_msg[100];

    // Create a pipe
    if (pipe(fd) == -1) {
        perror("pipe");
        return 1;
    }

    // Fork a child process
    pid = fork();

    if (pid < 0) {
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // Child process
        close(fd[1]); // Close write end
        ssize_t n = read(fd[0], read_msg, sizeof(read_msg) - 1);
        if (n >= 0) {
            read_msg[n] = '\0';
            printf("Child read: %s\n", read_msg);
        } else {
            perror("read");
        }
        close(fd[0]);
    } else {
        // Parent process
        close(fd[0]); // Close read end
        write(fd[1], write_msg, strlen(write_msg));
        close(fd[1]);
        wait(NULL); // Wait for child to finish
    }
    return 0;
}

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 3. Capitolo 1