Linux C 进程与进程间通信

最新推荐文章于 2025-06-09 00:39:02 发布
最新推荐文章于 2025-06-09 00:39:02 发布
阅读量1.1k 收藏 4
点赞数 1
CC 4.0 BY-SA版权
分类专栏： Linux C 文章标签： c语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liuxingbusi/article/details/53638736
本文介绍了 Linux 下的进程管理及进程间通信（IPC），包括 fork 创建子进程、wait 和 waitpid 函数等待子进程结束、exec 函数族执行外部程序、僵尸进程和孤儿进程的概念。同时详细讲解了 Linux 下的 IPC 方式，如共享内存、消息队列、管道、信号等，并提供了丰富的示例代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Linux C 进程与进程间通信

进程常用API

  • getpid 获取当前进程ID
  • getppid 获取当前进程的父进程ID
  • fork 创建一个进程, 子进程中返回0, 父进程中返回子进程pid.
  • wait函数族 等待子进程结束, 回收子进程资源.
    • wait 等待所有子进程结束
    • waitpid 等待特定子进程结束(也可所有)
  • exec函数族 执行外部程序, 完全替换当前进程内容, 后缀意义如下.
    l: 参数为可变长参数(NULL结尾)
    v: 参数为数组
    p: 在当前环境变量中搜索
    e: 传入环境变量再在其中搜索
    • execl, execlp, execle
    • execv, execvp, execve
  • exit函数族 退出程序
    • exit 标准库函数, 退出前进行缓冲区清理等操作.
    • _exit 直接退出, 不做任何处理.

创建进程

进程结束的顺序是不确定的, 用wait来保证子进程先结束.

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    int ret, chi_stat;

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        printf("child process running, pid: %d, ppid: %d .\n", getpid(), getppid());

        sleep(2);

        printf("child process finished, pid: %d, ppid: %d .\n", getpid(), getppid());
        exit(0);
    } else {
    /* parent process */
        printf("parent process running, pid: %d, ppid: %d .\n", getpid(), getppid());
        ret = wait(&chi_stat);
        if_error(ret, "wait");

        /* wait success */
        if (WIFEXITED(chi_stat)) {
            printf("wait success, status code: %d .\n", WEXITSTATUS(chi_stat));
        }

        /* wait failed */
        if (WIFSIGNALED(chi_stat)) {
            printf("wait failed, status code: %d .\n", WTERMSIG(chi_stat));
        }

        printf("parent process finished, pid: %d, ppid: %d .\n", getpid(), getppid());
    }
    printf("main exit.\n");
    return 0;
}

僵尸进程

僵尸进程: 已经执行结束, 但是资源还未被回收的进程.
利用system函数执行shell脚本, 发现进程状态为Z的僵尸进程.

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXLINE 80

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    char shell_cmd[MAXLINE];

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        exit(0);
    } else {
    /* parent process */
        sleep(2);
    }

    sprintf(shell_cmd, "ps aux | grep %d", chi_pid);
    system(shell_cmd);

    printf("main exit.\n");
    return 0;
}

孤儿进程

孤儿进程: 父进程执行结束, 子进程还在运行的进程.(会被init进程接管)
执行结束后查看对应子进程的PPID, 是init进程.

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

#define MAXLINE 80

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    char shell_cmd[MAXLINE];

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        printf("before parent exit, pid: %d, ppid:%d\n", getpid(), getppid());
        sleep(2);
        printf("after parent exit, pid: %d, ppid:%d\n", getpid(), getppid());
        sleep(2);
        exit(0);
    } else {
    /* parent process */
        printf("parent exit, child pid: %d .\n", chi_pid);
        exit(0);
    }
}

两次fork避免僵尸进程

第二次fork产生孙子进程, 让子进程直接结束, 孙子进程变成孤儿进程被init接管.

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid, grand_chi_pid;
    int ret;

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        grand_chi_pid = fork();
        if_error(grand_chi_pid, "fork");

        if (grand_chi_pid == 0) {
        /* grand child process */
            sleep(2);
            printf("grand child process pid: %d, ppid: %d .\n", getpid(), getppid());
            exit(0);
        } else {
        /* child process */
            printf("child process pid: %d, ppid: %d .\n", getpid(), getppid());
            exit(0);
        }
    } else {
    /* parent process */
        ret = waitpid(chi_pid, NULL, 0);
        printf("parent process pid: %d, ppid: %d .\n", getpid(), getppid());
    }
    printf("main exit.\n");
    return 0;
}

exec执行shell命令

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define MAXLINE 80
#define MAXCNT 20

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

char* cmd_parse(char *buf, char **args)
{
    int cnt = 0;
    char *cmd;

    args[cnt++] = cmd = strtok(buf, " ");

    do {
        args[cnt] = strtok(NULL, " ");
    } while (args[cnt++] != NULL);

    return cmd;
}

int main(int argc, char **argv)
{
    int chi_pid, ret;
    char buf[MAXLINE], cmd_exit[MAXLINE];
    char *cmd, *args[MAXCNT];

    while (1) {
        chi_pid = fork();
        if_error(chi_pid, "fork");

        if (chi_pid == 0) {
        /* child process */
            printf("input cmd: ");
            fgets(buf, MAXLINE, stdin);
            buf[strlen(buf)-1] = '\0';

            /* parse cmd */
            cmd = cmd_parse(buf, args);
            ret = execvp(cmd, args);
            if_error(ret, "execvp");
        } else {
        /* parent process */
            chi_pid = wait(NULL);
            if_error(chi_pid, "wait");
        }
    }
    return 0;
}

进程间通信(IPC)

Linux下的IPC方式有共享内存, 消息队列, 管道, 信号等.
共享内存和消息队列需要root权限才能执行

  • 共享内存
    • shmget 创建/访问 共享内存对象
    • shmat 把共享内存区对象映射到调用进程的地址空间
    • shmdt 断开共享内存连接
    • shmctl 对共享内存提供控制
  • 消息队列
    • msgget 创建/访问 消息队列
    • msgrcv 从消息队列中获取消息
    • msgsnd 把消息添加到消息队列中
    • msgctl 对消息队列提供控制
  • 管道
    • pipe 为文件描述符数组建立无名管道
    • mkfifo 创建命名管道(FIFO)文件
  • 信号
    • signal 设置信号捕捉句柄
    • kill 发送信号

共享内存

利用内存进行通信的方式

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <sys/ipc.h>
#include <sys/shm.h>

#define IPC_KEY 2048
#define MAXLINE 80
#define MAXSIZE MAXLINE*100

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    int shm_id, ret;
    char *shm_ptr;
    struct shmid_ds shm_stat;

    char buf[MAXLINE];
    char output[MAXSIZE], content[MAXSIZE];

    memset(content, 0, sizeof(content));

    shm_id = shmget(IPC_KEY, MAXSIZE, IPC_CREAT);
    if_error(shm_id, "shmget");

    shm_ptr = shmat(shm_id, NULL, 0);
    if_error(*(int*)shm_ptr, "shmat");

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        printf("input msg:\n");
        while (1) {
            /* input msg */
            fgets(buf, MAXLINE, stdin);
            buf[strlen(buf)-1] = '\0';
            /* finish input msg */
            if (strncmp(buf, "exit", 4) == 0) break;
            strcat(content, buf);
        }
        /* cp content to shm_ptr */
        memcpy(shm_ptr, content, MAXSIZE);
    } else {
    /* parent process */
        chi_pid = wait(NULL);
        if_error(chi_pid, "wait");

        /* get content from shm_ptr */
        memcpy(output, shm_ptr, MAXSIZE);
        printf("%s\n", output);
        /* get shm info */
        shmctl(shm_id, IPC_STAT, &shm_stat);
        printf("PID: %d, shared memory size is %ld\n", getpid(), shm_stat.shm_segsz);
        /* disconnect */
        ret = shmdt(shm_ptr);
        if_error(ret, "shmdt");
    }
    return 0;
}

管道

半双工通信

无名管道

用于子进程和父进程的简单通信方式

#include <unistd.h>

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>

#define MAXLINE 80

void if_error(int stat_code, char* err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    int fd[2], ret;
    pid_t chi_pid;
    int rd_n, wr_n;
    char input[MAXLINE], buf[MAXLINE];
    /*  setup pipe
        fd[0] read pipe
        fd[1] write pipe
    */
    ret = pipe(fd);
    if_error(ret, "pipe");

    chi_pid = fork();
    if_error(chi_pid, "fork");

    if (chi_pid == 0) {
    /* child process */
        close(fd[0]);
        printf("child process send msg:\n");
        while (1) {
            /* send msg to parent process */
            fgets(input, MAXLINE, stdin);
            input[strlen(input)-1] = '\0';

            wr_n = write(fd[1], input, strlen(input));
            if_error(wr_n, "read");

            /* child process exit */
            if (strncmp(input, "exit", 4) == 0) {
                printf("child process exit .\n");
                exit(0);
            }
        }
    } else {
    /* parent process */
        close(fd[1]);
        while (1) {
            /* recv msg from child process */
            rd_n = read(fd[0], buf, MAXLINE);
            if_error(rd_n, "read");
            buf[rd_n] = '\0';

            /* if recv exit msg */
            if (strncmp(buf, "exit", 4) == 0) {
                ret = wait(NULL);
                if_error(ret, "wait");
                printf("parent process exit .\n");
                break;
            }
            printf("parent process recv msg: %s\n", buf);
        }
    }
    return 0;
}
命名管道

用于两个进程间的简单通信
read.c

#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define MAXLINE 80

void if_error(int stat_code, char* err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    int fd, rd_n, ret;
    char *fifo_path = "./fifo";
    char buf[MAXLINE];

    /* setup fifo file */
    ret = mkfifo(fifo_path, 0664);
    if (ret < 0 && errno!=EEXIST) return -1;

    /* open fifo file */
    fd = open(fifo_path, O_RDONLY);
    if_error(fd, "open");

    printf("process %d opening FIFO with read-only .\n", getpid());

    while (1) {
        /* read pipe msg */
        rd_n = read(fd, buf, MAXLINE);
        if_error(rd_n, "read");
        buf[rd_n] = '\0';

        /* recv exit msg */
        if (strncmp(buf, "exit", 4) == 0) break;
        printf("recv pipe msg: %s\n", buf);
    }
    printf("read finished\n");
    /* remove fifo file */
    unlink(fifo_path);
    close(fd);
    return 0;
}

write.c

#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>

#define MAXLINE 80

void if_error(int stat_code, char* err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int main(int argc, char **argv)
{
    int fd, ret, wr_n;
    char *fifo_path = "./fifo";
    char buf[MAXLINE];

    /* setup fifo file */
    ret = mkfifo(fifo_path, 0664);
    if (ret < 0 && errno!=EEXIST) return -1;

    /* open fifo file */
    fd = open(fifo_path, O_WRONLY);
    if_error(fd, "open");

    printf("process %d opening FIFO with write-only .\n", getpid());

    while (1) {
        /* send pipe msg */
        printf("send pipe msg:");
        fgets(buf, MAXLINE, stdin);
        buf[strlen(buf)-1] = '\0';
        wr_n = write(fd, buf, strlen(buf));
        if_error(wr_n, "write");

        /* exit msg */
        if (strncmp(buf, "exit", 4) == 0) break;
    }
    printf("write finished\n");
    /* remove fifo file */
    unlink(fifo_path);
    close(fd);
    return 0;
}

消息队列

与命名管道类似的一种通信机制, 可以发送数据块.
read.c

#include <unistd.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/types.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define IPC_KEY 1024
#define MAXLINE 80

void if_error(int stat_code, char* err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

struct msg_ds
{
    char data[MAXLINE];
};

int main(int argc, char **argv)
{
    int msq_id, rd_n;
    struct msg_ds msg;

    msq_id = msgget(IPC_KEY, IPC_CREAT);
    if_error(msq_id, "msgget");

    while (1) {
        /* recv msg */
        rd_n = msgrcv(msq_id, (void*)&msg, MAXLINE, 0, 0);
        if_error(rd_n, "msgrcv");
        msg.data[rd_n] = '\0';
        /* exit msg */
        if (strncmp(msg.data, "exit", 4) == 0) break;

        printf("recv msg: %s\n", msg.data);
    }
    msgctl(msq_id, IPC_RMID, 0);
    return 0;
}

write.c

#include <unistd.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <sys/types.h>

#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define IPC_KEY 1024
#define MAXLINE 80

void if_error(int stat_code, char* err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

struct msg_ds
{
    char data[MAXLINE];
};

int main(int argc, char **argv)
{
    int msq_id, wr_n;
    struct msg_ds msg;

    msq_id = msgget(IPC_KEY, IPC_CREAT);
    if_error(msq_id, "msgget");

    while (1) {
        /* send msg */
        printf("send msg: ");
        fgets(msg.data, MAXLINE, stdin);
        msg.data[strlen(msg.data)-1] = '\0';

        wr_n = msgsnd(msq_id, &msg, MAXLINE, 0);
        if_error(wr_n, "msgsnd");
        /* exit msg */
        if (strncmp(msg.data, "exit", 4) == 0) break;
    }
    msgctl(msq_id, IPC_RMID, 0);
    return 0;
}

信号

发送信号和捕捉信号的通信方式

#include <unistd.h>
#include <sys/types.h>
#include <signal.h>

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

void if_error(int stat_code, char *err_msg)
{
    if (stat_code < 0) {
        perror(err_msg);
        exit(errno);
    }
}

int get_sig = 0;

void sig_alarm_handler(int sig)
{
    get_sig = 1;
}

int main(int argc, char **argv)
{
    pid_t chi_pid;
    chi_pid = fork();
    if_error(chi_pid, "fork");
    /* setup signal handler */
    signal(SIGALRM, sig_alarm_handler);

    if (chi_pid == 0) {
    /* child process */
        sleep(5);
        kill(getppid(), SIGALRM);
        exit(0);
    } else {
    /* parent process */
        while (1) {
            sleep(1);
            /* check if recv sig */
            if (get_sig) {
                printf("get signal SIGALRM(%d)\n", SIGALRM);
                break;
            } else {
                printf("not get signal\n");
            }
        }
    }
    return 0;
}
[Linux C编程]进程间的通信（二）
三月，有人呼唤你的名字
10-23 1028
共享内存实现分为两个步骤: 1、创建共享、打开共享内存，使用shmget函数 2、映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数 3. 分离共享内存 4. 控制、删除共享内存 创建shmget： 函数的作用：在内核中创建共享内存 函数的原型：int shmget(key_t key,int size,int shmflag); 函数的参数：key:键值，IPC_PRIVATE：私有的键值 size:创建的内存大小 shmf
C语言-Linux进程间通信方式
qq_55869380的博客
09-29 1409
进程间通信方法，管道、信号、信号集、消息队列、共享内存
LinuxC 进程之间通信
qq_53580962的博客
09-19 426
Linux C进程之间通信
【Linux】Linux进程间通讯-信号
最新发布
Antonio915的博客
06-09 747
函数功能：设置某一信号的对应动作参数说明：第一个参数signum：指明了所要处理的信号类型，它可以取除了SIGKILL（9号信号）和SIGSTOP（19号信号）外的任何一种信号。第二个参数handle关联动作含义SIG_DFL执行该信号的默认处理动作SIG_IGN忽略该信号提供一个信号处理函数，要求内核在处理该信号时切换到用户态执行这个处理函数，这种方式称为捕捉（catch）一个信号signal函数可以自定义回调函数，来处理特定的信号这里我们自定义的回调函数，然后打印对应的信号。
Linux C 进程间通信
林夕的博客
11-15 781
为什么进程间需要通信？为了传输数据、共享资源、通知事件、控制进程等。那么进程间通信的原理是什么呢？进程在内核中开辟一块缓冲区,进程1把数据从用户空间拷到内核缓冲区,进程2再从内核缓冲区把数据读走,内核提供的这种机制称为进程间通信机制。无名管道只能用于父子进程或兄弟进程之间的通信，而有名管道可用于任意两进程之间通信。在Linux中使用 kill -l 命令可以查看到x 系统中有下 62 个信号，每一个信号都有自己独特的含义。
linux c进程间通信
我喜欢你快乐
11-13 1000
进程间通信 一. 实验目的 1.了解Linux操作系统用户进程的编程。 2.了解Linux操作系统中进程间通信系统调用的使用方法。 二. 实验内容 编写一个生产者－消费者程序组，支持多个生产者和消费者，生产者进程数为2， 消费者进程数为3。 生产者与消费者之间使用共享内存进行数据传递，并使用信号量对数据的内容进行保护。 具体要求如下： 共享
Linux C之进程间通讯
IT探险者-returningprodigal
12-04 325
一.管道 无名管道 创建无名管道 int pipe(int pipides[2]); 　　参数pipides为一个整形数组，下表为2。如果函数执行成功，pipe将存储两个文件描述符于pipedes[0]和pipedes[1]中，它们分别指向管道的两端。如果系统调用失败，将返回-1。 　　无名管道是单工的，一个管道只能实现从一个进程向另外一个进程发送消息，pipedes[0]是读...
Linux进程间通信方式之socket使用实例
09-15
### Linux进程间通信方式之socket使用实例详解 #### 一、引言 在现代操作系统中，进程间的通信（IPC）是实现多进程协同工作的重要手段之一。Linux提供了多种进程间通信的方法，包括信号量、消息队列、共享内存以及...
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc
09-23
本文将深入探讨标题“ipc.rar_IPC_linux 进程_进程间通信_进程间通信ipc”所涉及的知识点，包括Linux下的管道（pipe）、进程以及进程间通信的基本概念、工作原理和应用实例。 首先，让我们理解什么是进程。在Linux...
操作系统Linux消息队列详解：进程间通信的关键技术与应用实例
04-12
适合人群：对Linux系统编程、进程间通信感兴趣的开发者，尤其是有一定C语言基础的程序员。 使用场景及目标：①理解消息队列在进程间通信中的作用和优势；②掌握消息队列的创建、消息的发送与接收、队列的控制与删除...
linux C 进程间通信
Cav4ever
09-27 266
进程间通信：在用户空间实现进程通信是不可能的，通过linux内核通信 线程间通信：可以在用户空间就可以实现，可以通过全局变量通信 共享内存： mmap成功返回后，fd参数可以关闭。该操作对由于mmap建立的映射关系没有影响。 ...
Linux c 进程间通信（管道）
weixin_45715405的博客
11-05 332
文章目录1、pipe函数实现有血缘关系进程通信2、mkfifo函数实现无血缘关系进程通信 1、pipe函数实现有血缘关系进程通信 管道原理：内核使用环形机制，借助缓冲区实现 不可重复读取，数据填满就会覆盖 不可自己读自己写 双向半双工 数据只能单向流通 pipe函数介绍 int pipe(int pipefd[2]); 参数： fd[0]: 读端 fd[1]: 写端 返回值: 成功 0 失败 -1 通过管道实现父子进程通信 #include <unistd.h&g
Linux C编程之进程间通信
qq_53003541的博客
08-06 1302
linux进程通信
Linux C 进程间通信（无名管道、有名管道、信号）
TheBlob的博客
09-11 725
欢迎再次来到TheBlob博客！这里是继多进程基础后的进程间通信基础，包括：无名管道、有名管道、信号的基础。希望能帮助到大家!
Linux环境C 进程及进程间通信
xiaoqiudao的博客
06-07 301
进程基本概念： 1、进程与程序 ​ 程序就是储存在磁盘上的可执行文件，程序被加载到内存中开始运行进程。 ​ 一个程序被多次加载时就生成了多个进程 ​ 进程就是处于活动状态的计算机程序 2、进程的分类 ​ 进程一般分为三种类型：交互进程、批处理进程、守护进程 ​ 守护进程一般处于活跃状态，运行在后台，由系统在开机时通过启动脚本来自动创建 3、 查看进程 ​ 简单方式 ps 显示当前用户有控制终端的进程信息 ​ 列表方式 ps auxw 显示所有进程详细信息 ​ a 所有用户的有控制终端的进程
linux C语言编程----进程间通信
cgm88s的专栏
06-07 3749
转载来源：http://book.51cto.com/art/200912/169555.htm 进程间通信 一个大型的应用软件往往需要众多进程协作，进程间通信（IPC）的重要性显而易见。Linux系统下的进程通信机制基本上是从UNIX平台上的进程通信机制移植而来的。主要的进程间通信机制有以下几种。 无名管道（Pipe）及命名管道（Named pipe）：管道可用于具有父子关系进程间的通
LinuxC—进程通信
wait2023的博客
01-30 1411
定义匿名管道用来实现具有亲缘关系的进程之间的通信，匿名管道是由内核创建的一块内存区域，返回这块区域对应的文件描述符后，进程间可以通过这个文件描述符的操作来进行通信。特点相关函数1024。
【嵌入式】Linux C编程——进程间通信方式
a_qwq_a的博客
06-05 364
对进程间通信的总结
Linux C语言进程通信与消息管理详解
1. **POSIX无名信号量**：这是一种基础的进程间通信方式，在操作系统理论中，POSIX（Portable Operating System Interface）定义了一套跨平台的标准接口。无名信号量的核心是PV操作（P代表Pend或Wait，V代表Signal或...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值