UNIX编程(15)-进程间通信

最新推荐文章于 2024-07-12 16:39:24 发布
最新推荐文章于 2024-07-12 16:39:24 发布
阅读量138 收藏
点赞数
分类专栏： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/onlinebrx/article/details/83982227
版权

. 管道

 

#include <unistd.h>

int pipe(int filedes[2]);

 

Returns: 0 if OK, 1 on error


参数filedes返回两个文件描述符：filedes[0]为读而打开，filedes[1]为写而打开。

 

例：经由管道父进程向子进程传递数据

#include "apue.h"

int
main(void)
{
    int     n;
    int     fd[2];
    pid_t   pid;
    char    line[MAXLINE];

    if (pipe(fd) < 0)
        err_sys("pipe error");
    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {       /* parent */
        close(fd[0]);
        write(fd[1], "hello world\n", 12);
    } else {                /* child */
        close(fd[1]);
        n = read(fd[0], line, MAXLINE);
        write(STDOUT_FILENO, line, n);
    }
    exit(0);
}


例：将文件复制到分页程序

 

#include "apue.h"
#include <sys/wait.h>

#define DEF_PAGER   "/bin/more"     /* default pager program */

int
main(int argc, char *argv[])
{
    int    n;
    int    fd[2];
    pid_t  pid;
    char   *pager, *argv0;
    char   line[MAXLINE];
    FILE   *fp;

    if (argc != 2)
        err_quit("usage: a.out <pathname>");

    if ((fp = fopen(argv[1], "r")) == NULL)
        err_sys("can't open %s", argv[1]);
    if (pipe(fd) < 0)
        err_sys("pipe error");

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {                              /* parent */
        close(fd[0]);       /* close read end */

        /* parent copies argv[1] to pipe */
        while (fgets(line, MAXLINE, fp) != NULL) {
            n = strlen(line);
            if (write(fd[1], line, n) != n)
                err_sys("write error to pipe");
        }
        if (ferror(fp))
            err_sys("fgets error");

        close(fd[1]);   /* close write end of pipe for reader */

        if (waitpid(pid, NULL, 0) < 0)
            err_sys("waitpid error");
        exit(0);
    } else {                                        /* child */
        close(fd[1]);   /* close write end */
        if (fd[0] != STDIN_FILENO) {
            if (dup2(fd[0], STDIN_FILENO) != STDIN_FILENO)
                err_sys("dup2 error to stdin");
            close(fd[0]);   /* don't need this after dup2 */
        }

        /* get arguments for execl() */
        if ((pager = getenv("PAGER")) == NULL)
            pager = DEF_PAGER;
        if ((argv0 = strrchr(pager, '/')) != NULL)
            argv0++;        /* step past rightmost slash */
        else
            argv0 = pager;  /* no slash in pager */

        if (execl(pager, argv0, (char *)0) < 0)
            err_sys("execl error for %s", pager);
    }
    exit(0);
}


使父子进程同步的例程

#include "apue.h"

static int  pfd1[2], pfd2[2];

void
TELL_WAIT(void)
{
    if (pipe(pfd1) < 0 || pipe(pfd2) < 0)
        err_sys("pipe error");
}

void
TELL_PARENT(pid_t pid)
{
    if (write(pfd2[1], "c", 1) != 1)
        err_sys("write error");
}

void
WAIT_PARENT(void)
{
    char    c;

    if (read(pfd1[0], &c, 1) != 1)
        err_sys("read error");

    if (c != 'p')
        err_quit("WAIT_PARENT: incorrect data");
}

void
TELL_CHILD(pid_t pid)
{
    if (write(pfd1[1], "p", 1) != 1)
        err_sys("write error");
}

void
WAIT_CHILD(void)
{
    char    c;

    if (read(pfd2[0], &c, 1) != 1)
        err_sys("read error");

    if (c != 'c')
        err_quit("WAIT_CHILD: incorrect data");
}

2.popen和pclose函数

 

#include <stdio.h>

FILE *popen(const char *cmdstring, const char *type);

 

Returns: file pointer if OK, NULL on error

 

int pclose(FILE *fp);

 

Returns: termination status of cmdstring, or 1 on error


例：用popen向分页程序传递文件

 

#include "apue.h"
#include <sys/wait.h>

#define PAGER   "${PAGER:-more}" /* environment variable, or default */

int
main(int argc, char *argv[])
{
    char    line[MAXLINE];
    FILE    *fpin, *fpout;

    if (argc != 2)
        err_quit("usage: a.out <pathname>");
    if ((fpin = fopen(argv[1], "r")) == NULL)
        err_sys("can't open %s", argv[1]);

    if ((fpout = popen(PAGER, "w")) == NULL)
        err_sys("popen error");

    /* copy argv[1] to pager */
    while (fgets(line, MAXLINE, fpin) != NULL) {
        if (fputs(line, fpout) == EOF)
            err_sys("fputs error to pipe");
    }
    if (ferror(fpin))
        err_sys("fgets error");
    if (pclose(fpout) == -1)
        err_sys("pclose error");

    exit(0);
}


大小写过滤程序

#include "apue.h"
#include <ctype.h>

int
main(void)
{
    int     c;

    while ((c = getchar()) != EOF) {
        if (isupper(c))
            c = tolower(c);
        if (putchar(c) == EOF)
            err_sys("output error");
        if (c == '\n')
            fflush(stdout);
    }
    exit(0);
}


 

#include "apue.h"
#include <sys/wait.h>

int
main(void)
{
    char    line[MAXLINE];
    FILE    *fpin;

    if ((fpin = popen("myuclc", "r")) == NULL)
        err_sys("popen error");
    for ( ; ; ) {
        fputs("prompt> ", stdout);
        fflush(stdout);
        if (fgets(line, MAXLINE, fpin) == NULL) /* read from pipe */
            break;
        if (fputs(line, stdout) == EOF)
            err_sys("fputs error to pipe");
    }
    if (pclose(fpin) == -1)
        err_sys("pclose error");
    putchar('\n');
    exit(0);
}


3.协同进程

 

对两个数求和的简单过滤程序

#include "apue.h"

int
main(void)
{
    int     n,  int1,  int2;
    char    line[MAXLINE];

    while ((n = read(STDIN_FILENO, line, MAXLINE)) > 0) {
        line[n] = 0;        /* null terminate */
        if (sscanf(line, "%d%d", &int1, &int2) == 2) {
            sprintf(line, "%d\n", int1 + int2);
            n = strlen(line);
            if (write(STDOUT_FILENO, line, n) != n)
                err_sys("write error");
        } else {
            if (write(STDOUT_FILENO, "invalid args\n", 13) != 13)
                err_sys("write error");
        }
    }
    exit(0);
}


 

include "apue.h"

static void sig_pipe(int);      /* our signal handler */

int
main(void)
{
    int     n, fd1[2], fd2[2];
    pid_t   pid;
    char    line[MAXLINE];

    if (signal(SIGPIPE, sig_pipe) == SIG_ERR)
        err_sys("signal error");

    if (pipe(fd1) < 0 || pipe(fd2) < 0)
        err_sys("pipe error");

    if ((pid = fork()) < 0) {
        err_sys("fork error");
    } else if (pid > 0) {                         /* parent */
        close(fd1[0]);
        close(fd2[1]);
        while (fgets(line, MAXLINE, stdin) != NULL) {
            n = strlen(line);
            if (write(fd1[1], line, n) != n)
                err_sys("write error to pipe");
            if ((n = read(fd2[0], line, MAXLINE)) < 0)
                err_sys("read error from pipe");
            if (n == 0) {
                err_msg("child closed pipe");
                break;
            }
            line[n] = 0;    /* null terminate */
            if (fputs(line, stdout) == EOF)
                err_sys("fputs error");
        }
        if (ferror(stdin))
            err_sys("fgets error on stdin");
        exit(0);
    } else {                                  /* child */
        close(fd1[1]);
        close(fd2[0]);
        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO)
                err_sys("dup2 error to stdin");
            close(fd1[0]);
        }

        if (fd2[1] != STDOUT_FILENO) {
            if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO)
                err_sys("dup2 error to stdout");
            close(fd2[1]);
        }
        if (execl("./add2", "add2", (char *)0) < 0)
            err_sys("execl error");
    }
    exit(0);
}

static void
sig_pipe(int signo)
{
    printf("SIGPIPE caught\n");
    exit(1);
}

4.FIFO

 

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

 

Returns: 0 if OK, 1 on error


5.XSI IPC

消息队列，信号量，共享存储称作XSI IPC

1)标识符和键

标识符是IPC对象的内部名

键是IPC对象的外部名

 

2）权限结构

XSI IPC 为每一个IPC结构设置了一个ipc_perm结构

struct ipc_perm {
     uid_t  uid;  /* owner's effective user id */
     gid_t  gid;  /* owner's effective group id */
     uid_t  cuid; /* creator's effective user id */
     gid_t  cgid; /* creator's effective group id */
     mode_t mode; /* access modes */
     .
     .
     .
   };

6.消息队列

每个队列都有一个msq_ds与其相关联

struct msqid_ds {
     struct ipc_perm  msg_perm;     /* see Section 15.6.2 */
     msgqnum_t        msg_qnum;     /* # of messages on queue */
     msglen_t         msg_qbytes;   /* max # of bytes on queue */
     pid_t            msg_lspid;    /* pid of last msgsnd() */
     pid_t            msg_lrpid;    /* pid of last msgrcv() */
     time_t           msg_stime;    /* last-msgsnd() time */
     time_t           msg_rtime;    /* last-msgrcv() time */
     time_t           msg_ctime;    /* last-change time */
     .
     .
     .
   };

#include <sys/msg.h>

int msgget(key_t key, int flag);

 

Returns: message queue ID if OK, 1 on error

 

 

#include <sys/msg.h>

int msgctl(int msqid, int cmd, struct msqid_ds *buf );

 

Returns: 0 if OK, 1 on error

 

[View full width] 
#include <sys/msg.h>

int msgsnd(int msqid, const void *ptr, size_t
nbytes, int flag);

 

Returns: 0 if OK, 1 on error


[View full width] 
#include <sys/msg.h>

ssize_t msgrcv(int msqid, void *ptr, size_t nbytes
, long type, int flag);

 

Returns: size of data portion of message if OK, 1 on error


7.信号量

 

struct semid_ds {
     struct ipc_perm  sem_perm;  /* see Section 15.6.2 */
     unsigned short   sem_nsems; /* # of semaphores in set */
     time_t           sem_otime; /* last-semop() time */
     time_t           sem_ctime; /* last-change time */
     .
     .
     .
   };

 

#include <sys/sem.h>

int semget(key_t key, int nsems, int flag);

 

Returns: semaphore ID if OK, 1 on error

 

 

#include <sys/sem.h>

int semctl(int semid, int semnum, int  cmd,
           ... /* union semun arg */);

 

Returns: (see following)

 

[View full width] 
#include <sys/sem.h>

int semop(int semid, struct sembuf semoparray[],
 size_t nops);

 

Returns: 0 if OK, 1 on error


8.共享存储

struct shmid_ds {
     struct ipc_perm  shm_perm;    /* see Section 15.6.2 */
     size_t           shm_segsz;   /* size of segment in bytes */
     pid_t            shm_lpid;    /* pid of last shmop() */
     pid_t            shm_cpid;    /* pid of creator */
     shmatt_t         shm_nattch;  /* number of current attaches */
     time_t           shm_atime;   /* last-attach time */
     time_t           shm_dtime;   /* last-detach time */
     time_t           shm_ctime;   /* last-change time */
     .
     .
     .
   };

 

#include <sys/shm.h>

int shmget(key_t key, size_t size, int flag);

 

Returns: shared memory ID if OK, 1 on error

 

 

#include <sys/shm.h>

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

 

Returns: 0 if OK, 1 on error

#include <sys/shm.h>

void *shmat(int shmid, const void *addr, int flag);

 

Returns: pointer to shared memory segment if OK, 1 on error

 

 

#include <sys/shm.h>

int shmdt(void *addr);

 

Returns: 0 if OK, 1 on error


打印不同数据所存放的区域

#include "apue.h"
#include <sys/shm.h>

#define ARRAY_SIZE  40000
#define MALLOC_SIZE 100000
#define SHM_SIZE    100000
#define SHM_MODE    0600    /* user read/write */

char    array[ARRAY_SIZE];  /* uninitialized data = bss */

int
main(void)
{
    int     shmid;
    char    *ptr, *shmptr;

    printf("array[] from %lx to %lx\n", (unsigned long)&array[0],
      (unsigned long)&array[ARRAY_SIZE]);
    printf("stack around %lx\n", (unsigned long)&shmid);

    if ((ptr = malloc(MALLOC_SIZE)) == NULL)
        err_sys("malloc error");
    printf("malloced from %lx to %lx\n", (unsigned long)ptr,
      (unsigned long)ptr+MALLOC_SIZE);

    if ((shmid = shmget(IPC_PRIVATE, SHM_SIZE, SHM_MODE)) < 0)
        err_sys("shmget error");
    if ((shmptr = shmat(shmid, 0, 0)) == (void *)-1)
        err_sys("shmat error");
    printf("shared memory attached from %lx to %lx\n",
      (unsigned long)shmptr, (unsigned long)shmptr+SHM_SIZE);

    if (shmctl(shmid, IPC_RMID, 0) < 0)
        err_sys("shmctl error");

    exit(0);
}


onlinebrx
关注
专栏目录
unix环境编程 第十五章 15.3 函数popen和pclose
weixin_43873960的博客
11-29 547
常见的操作是创建一个连接到另一个进程的管道，然后读其输出或向其输入端发送数据，为此，标准I/O库提供了两个函数popen和函数pclose。 #include <stdio.h> FILE *popen(const char *cmdsring,const char *type); //成功返回文件指针，出错返回NULL int pclose(FILE *fp); //成功返回cmdstring的终止状态，失败返回-1 函数popen先执行fork，然后调用exec执行cmdstring，
笔记_UNIX环境网络编程卷二进程间通信_中文第二版.pdf
06-16
笔记_UNIX环境网络编程卷二进程间通信_中文第二版
Unix中Signal信号的不同
连城
12-09 195
Unix系统signal函数的不同 （1）函数说明 在signal函数中，有两个形参，分别代表需要处理的信号编号值和处理信号函数的指针。它主要是用于前32种非实时信号的处理，不支持信号的传递信息。但是由于使用简单，易于理解，因此在许多场合被程序员使用。 对于Unix系统来说，使用signal函数时，自定义处理信号函数执行一次后失效，对该信号的处理回到默认处理方式。下面以一个例子进行说明...
UNIX环境高级编程---进程间通信总结
qq_41683305的博客
04-01 1587
进程间通信1 管道匿名管道命名管道2 消息队列3 信号量4 共享内存5 信号6 套接字总结 Linux下的进程通信机制叫做IPC（InterProcess Communication），在Linux下有6大通信的方法，分别是：Socket、管道、信号、信号量、消息队列、共享内存。 每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。 1 管道 匿名管道 匿名管道是在内核中申请一块固定大小的缓冲区，程序拥有写入和读取的权利。匿名管道是半双
Unix环境高级编程-进程间通信
NINE_world的博客
03-28 1833
进程间通信 同一台主机上的进程通信 – 不同主机上的通信 1、管道 内核提供，单工，自同步机制：管道永远是迁就慢的那一方 在使用管道的时候，一般一个进程的一个管道只使用read或者write， 最好把另一端关闭。 绝对不会一根管道双工通信，只能用两根管道 匿名管道： pipe(); #include <unistd.h> int pipe(int pipefd[2]); #define _GNU_SOURCE /* See feature
Unix网络编程--进程间通信--管道通信
张勤一
08-28 2260
所有式样的Unix都提供管道，它由 pipe 函数创建，提供一个单路（单向）数据流。      原型如下：#include int pipe(int fd[2]);      该函数返回两个文件描述符：fd[0] fd[1]。前者打开用于读，后者打开来写。（都是站在进程的角度上来看读和写）      管道的典型用途是以下述方式为两个不同的进程（一个是父进程，一个是子进程）提供进程间的通信手段。首
15.UNIX 环境高级编程--进程间的通信
enlyhua的专栏
02-18 305
1.引言2.管道3.函数 popen 和 pclose4.协同进程5.FIFO6.IPC7.消息队列8.信号量9.共享存储10. POSIX 信号量11.客户进程-服务器进程属性
unix系统之进程间通信
h295928126的博客
02-17 3659
unix系统的进程间通信方式解释以及例子。
Linux应用开发-进程间通信-Socket
小白的学习笔记
04-19 938
Socket 起源于 Unix，原意是，在计算机通信领域，Socket 被翻译为，它是计算机之间进行通信的一种约定或一种方式。通过 Socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据。套接字有和两种。本地套接字的名字是Linux文件系统中的文件名，一般中；网络套接字的名字是与客户连接的特定网络有关的服务标识符（端口号或访问点）。这个标识符允许Linux将进入的针对特定端口号的连接转到正确的服务器进程。
Linux系统编程-进程间通信（IPC）常用方式详解
qq_42037383的博客
07-12 3167
进程间通信（IPC，Inter-Process Communication）是指在操作系统中，不同进程之间进行数据交换和信息传递的机制。这种通信允许正在运行的多个进程能够相互协作、共享数据或者进行同步操作，以实现更复杂的任务和功能。Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。
Linux系统编程2-进程间的通信
L1643319918的博客
08-16 356
LINUX 进程间的通信从UNIX 平台继承过来。而对UNIX做出比较大贡献：AT&T的贝尔实验室 UNIX 进程间的通信：无名管道、FIFO（有名管道） 、信号 SYTETM V进程间的通信 ：system v 消息队列 、system v 信号量 、信号 POSIX 进程间的通信：POSIX 消息队列 、POSIX信号量 、内存映射 、共享内存 Internet 网络(socket): 套接字 –网络编程 一 管道 管道文件也有两个端口，分别是读端和写端。 特点： （1）管道通信是单向的，
UNIX网络编程卷2进程间通信--部分源代码
11-22
《UNIX网络编程卷2：进程间通信》是网络编程领域中的经典著作，深入探讨了在UNIX操作系统环境下如何实现进程间的高效通信。这部分源代码包含了书中多个章节的关键示例，可以帮助读者更好地理解和应用书中的理论知识...
UNIX网络编程第2卷（第2版-中文-高清-进程间通信-带目录）
07-27
UNIX网络编程第2卷（第2版-中文-高清-进程间通信-带目录） Linux经典书之一，UNP第2卷，必看！
UNIX网络编程第二卷-进程间通信-源代码
04-12
UNIX网络编程第二卷-进程间通信-源代码 不同平台可能会遇到一些小问题 毕竟这些源代码有些年头了 关于我在fedora 11环境下编译出现的问题及解决办法见： ...
UNIX网络编程第二卷 进程间通信
09-15
UNIX网络编程第二卷 进程间通信
数据挖掘（三）相关数据集资源
最新发布
10-27
数据挖掘（三）相关数据集资源
《GNU_Linux环境高级编程》.pdf
10-27
《GNU_Linux环境高级编程》.pdf
人工智能-基于kinect的人体动作识别系统源码（毕业设计）
10-27
人工智能-基于kinect的人体动作识别系统源码（毕业设计），该项目是个人毕设项目，答辩评审分达到98分，代码都经过调试测试，确保可以运行！欢迎下载使用，可用于小白学习、进阶。该资源主要针对计算机、通信、人工智能、自动化等相关专业的学生、老师或从业者下载使用，亦可作为期末课程设计、课程大作业、毕业设计等。项目整体具有较高的学习借鉴价值！基础能力强的可以在此基础上修改调整，以实现不同的功能。 人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人工智能-基于kinect的人体动作识别系统源码（毕业设计）人
福建农林大学在陕西2020-2024各专业最低录取分数及位次表.pdf
10-27
那些年，与你同分同位次的同学都去了哪里？全国各大学在陕西2020-2024年各专业最低录取分数及录取位次数据，高考志愿必备参考数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值