APUE函数笔记十三: 进程间通信

最新推荐文章于 2022-07-12 14:36:40 发布
最新推荐文章于 2022-07-12 14:36:40 发布
阅读量603 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c unix 笔记 文章标签： null fp signal struct file cmd
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/cxxmaker/article/details/7427331
本文深入探讨了多种进程间通信机制，包括管道、命名管道、消息队列、信号量、共享内存等，并通过示例代码展示了如何使用这些机制进行进程间的通信。

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

第十五章  进程间通信:

#include <unistd.h>
int pipe(int filedes[2]);
    if success return 0, else error return -1

#include <stdio.h>
FILE * popen(const char * cmdstring, const char * type);
int pclose(FILE * fp);
    if success return exit-status, else error return -1

#include <sys/stat.h>
int mkfifo(const char * pathname, mode_t mode);
    after mkfifo, we can open/read/write/close/unlink it
    if success return 0, else error return -1

#include <sys/ipc.h>
key_t ftok(const char * path, int id);
    if error return (key_t)-1

#include <sys/msg.h>
int msgget(key_t key, int flag);
    if success return msg-id, else error return -1

#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds * buf);
    cmd:
        IPC_STAT, IPC_SET, IPC_RMID
    if success return 0, else error return -1

#include <sys/msg.h>
int msgsnd(int msqid, const void * ptr, size_t nbytes, int flag);
    if success return 0, else error return -1

#include <sys/msg.h>
ssize_t msgrcv(int msqid, void * ptr, size_t nbytes, long type, int flag);
    if success return msg-data-length, else error return -1

#include <sys/sem.h>
int semget(key_t key, int nsems, int flag);
    if success return 0, else error return -1

#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ... /* union semun arg */ );
    cmd:
        IPC_STAT, IPC_SET, IPC_RMID, 
        GETVAL,   SETVAL,  GETPID, 
        GETNCNT,  GETZCNT, GETALL, SETALL
    union semun {
        int               val;   /* for SETVAL */
        struct semid_ds * buf;   /* for IPC_STAT and IPC_SET */
        unsigned short  * array; /* for GETALL and SETALL */
    };

#include <sys/sem.h>
int semop(int semid, struct sembuf semoparray[], size_t nops);
    if success return 0, else error return -1
    struct sembuf {
        unsigned short  sem_num; /* member # in set (0, 1, ..., nsems-1) */
        short           sem_op;  /* operation (negative, 0, or positive) */
        short           sem_flg; /* IPC_NOWAIT, SEM_UNDO */
    };
    if sem_op > 0 free source, else if sem_op < 0 get source

#include <sys/shm.h>
int shmget(key_t key, size_t size, int flag);
    if success return shared-id, else error return -1

#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds * buf);
    cmd:
        IPC_STAT, IPC_SET, IPC_RMID, 
        SHM_LOCK, SHM_UNLOCK /* only for Linux and Solaris */
    if success return 0, else error return -1

#include <sys/shm.h>
void * shmat(int shmid, const void * addr, int flag);
    if error return (void *)-1

#include <sys/shm.h>
int shmdt(void * addr);
    if success return 0, else error return -1

示例: 

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

#define MAXLINE 1024

int 
main(void)
{
    int     n;
    int     int1;
    int     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) {
                printf("write error\n");
                exit(1);
            }
        }
        else {
            if (write(STDOUT_FILENO, "invalid args\n", 13) != 13) {
                printf("write error\n");
                exit(1);
            }
        }
    }
    exit(0);
}


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

#define MAXLINE 1024

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

    if (setvbuf(stdin, NULL, _IOLBF, 0) != 0) {   /* pipe is _IOFBF */
        printf("setvbuf error\n");
        exit(1);
    }
    if (setvbuf(stdout, NULL, _IOLBF, 0) != 0) {  /* pipe is _IOFBF */
        printf("setvbuf error\n");
        exit(1);
    }
    while (fgets(line, MAXLINE, stdin) != NULL) {
        if (sscanf(line, "%d%d", &int1, &int2) == 2) {
            if (printf("%d\n", int1 + int2) == EOF) {
                printf("printf error\n");
                exit(1);
            }
        }
        else {
            if (printf("invalid args\n") == EOF) {
                printf("printf error\n");
                exit(1);
            }
        }
    }
    exit(0);
}


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

int 
main(void)
{
    int     c;

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

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

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

void 
TELL_WAIT(void)
{
    if (pipe(pfd1) < 0 || pipe(pfd2) < 0) {
        printf("pipe error\n");
        exit(1);
    }
}

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

void 
WAIT_PARENT(void)
{
    char    c;

    if (read(pfd1[0], &c, 1) != 1) {
        printf("read error\n");
        exit(1);
    }

    if (c != 'p') {
        printf("WAIT_PARENT: incorrent data\n");
        exit(1);
    }
}

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

void 
WAIT_CHILD(void)
{
    char    c;

    if (read(pfd2[0], &c, 1) != 1) {
        printf("read error\n");
        exit(1);
    }

    if (c != 'c') {
        printf("WAIT_CHILD: incorrect data\n");
        exit(1);
    }
}


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

#define MAXLINE 1024

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

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


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

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

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

    if (argc != 2) {
        printf("usage: %s <pathname>\n", argv[0]);
        exit(1);
    }

    if ((fp = fopen(argv[1], "r")) == NULL) {
        printf("cannot open %s\n", argv[1]);
        exit(1);
    }
    if (pipe(fd) < 0) {
        printf("pipe error\n");
        exit(1);
    }

    if ((pid = fork()) < 0) {
        printf("fork error\n");
        exit(1);
    }
    else if (pid > 0) {
        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) {
                printf("write error\n");
                exit(1);
            }
        }
        if (ferror(fp)) {
            printf("fgets error\n");
            exit(1);
        }

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

        if (waitpid(pid, NULL, 0) < 0) {
            printf("waitpid error\n");
            exit(1);
        }
        exit(0);
    }
    else {
        close(fd[1]); /* close write end */
        if (fd[0] != STDIN_FILENO) {
            if (dup2(fd[0], STDIN_FILENO) != STDIN_FILENO) {
                printf("dup2 error to stdin\n");
                exit(1);
            }
            close(fd[0]); /* donnot 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) {
            printf("execl error for %s\n", pager);
        }
    }
    exit(0);
}


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

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

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

    if (argc != 2) {
        printf("usage: %s <pathname>\n", argv[0]);
        exit(1);
    }
    if ((fpin = fopen(argv[1], "r")) == NULL) {
        printf("cannot open %s\n", argv[1]);
        exit(1);
    }

    if ((fpout = popen(PAGER, "w")) == NULL) {
        printf("popen error\n");
        exit(1);
    }

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


#include <stdio.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>

/*
 * pointer to array allocated at run-time
 */
pid_t * childpid = NULL;

/*
 * from our open_max()
 */
int maxfd;

FILE * 
popen(const char * cmdstring, const char * type)
{
    int     i;
    int     pfd[2];
    pid_t   pid;
    FILE  * fp;

    /* only allow "r" or "w" */
    if ((type[0] != 'r' && type[0] != 'w') || type[1] != '\0') {
        errno = EINVAL; /* required by POSIX */
        return(NULL);
    }

    if (childpid == NULL) { /* first time through */
        /* allocate zeroed out array for child pids */
        maxfd = open_max();
        if ((childpid = calloc(maxfd, sizeof(pid_t))) == NULL) {
            return(NULL);
        }
    }

    if (pipe(pfd) < 0) {
        return(NULL); /* error set by pipe() */
    }

    if ((pid = fork()) < 0) {
        return(NULL); /* error set by fork() */
    }
    else if (pid == 0) {
        if (*type == 'r') {
            close(pfd[0]);
            if (pfd[1] != STDOUT_FILENO) {
                dup2(pfd[1], STDOUT_FILENO);
                close(pfd[1]);
            }
        }
        else {
            close(pfd[1]);
            if (pfd[0] != STDIN_FILENO) {
                dup2(pfd[0], STDIN_FILENO);
                close(pfd[0]);
            }
        }

        /* close all descriptors in childpid[] */
        for (i = 0; i < maxfd; ++i) {
            if (childpid[i] > 0) {
                close(i);
            }
        }

        execl("/bin/sh", "sh", "-c", cmdstring, (char *)0);
        _exit(127);
    }

    /* parent continues */
    if (*type == 'r') {
        close(pfd[1]);
        if ((fp = fdopen(pfd[0], type)) == NULL) {
            return(NULL);
        }
    }
    else {
        close(pfd[0]);
        if ((fp = fdopen(pfd[1], type)) == NULL) {
            return(NULL);
        }
    }

    childpid[fileno(fp)] = pid; /* remember child pid for this fd */
    return(fp);
}

int 
pclose(FILE * fp)
{
    int     fd;
    int     stat;
    pid_t   pid;

    if (childpid == NULL) {
        errno = EINVAL;
        return(-1); /* popen() has never been called */
    }

    fd = fileno(fp);
    if ((pid = childpid[fd]) == 0) {
        errno = EINVAL;
        return(-1); /* fp was not opened by popen() */
    }

    childpid[fd] = 0;
    if (fclose(fp) == EOF) {
        return(-1);
    }

    while (waitpid(pid, &stat, 0) < 0) {
        if (errno != EINTR) {
            return(-1); /* error other than EINTR from waitpid() */
        }
    }

    return(stat); /* return child's termination status */
}


#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>

#define MAXLINE 1024

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

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


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

#define MAXLINE 1024

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

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

    if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
        printf("signal error\n");
        exit(0);
    }

    if (pipe(fd1) < 0 || pipe(fd2) < 0) {
        printf("pipe error\n");
        exit(0);
    }

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

        if (ferror(stdin)) {
            printf("fgets error on stdin");
            exit(1);
        }
        exit(0);
    }
    else {
        close(fd1[1]);
        close(fd2[0]);
        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) {
                printf("dup2 error to stdin\n");
                exit(1);
            }
            close(fd1[0]);
        }
        if (fd2[1] != STDOUT_FILENO) {
            if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO) {
                printf("dup2 error to stdin\n");
                exit(1);
            }
            close(fd2[1]);
        }
        if (execl("./add", "add", (char *)0) < 0) {
            printf("execl error\n");
            exit(1);
        }
    }
    exit(0);
}


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

#include "changefileflag.h"

#define FIFO  "temp.fifo"

int 
main(void)
{
    int     fdread;
    int     fdwrite;

    unlink(FIFO);
    if (mkfifo(FIFO, 0622) < 0) {
        printf("mkfifo error\n");
        exit(1);
    }
    if ((fdread = open(FIFO, O_RDONLY | O_NONBLOCK)) < 0) {
        printf("open error for reading\n");
        exit(1);
    }
    if ((fdwrite = open(FIFO, O_WRONLY)) < 0) {
        printf("open error for writing\n");
        exit(1);
    }
    clr_fl(fdread, O_NONBLOCK);
    exit(0);
}


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

#define MAXLINE 1024

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

int 
main(void)
{
    int     n;
    int     fd1[2];
    int     fd2[2];
    pid_t   pid;
    char    line[MAXLINE];
    FILE *  fpin;
    FILE *  fpout;

    if (signal(SIGPIPE, sig_pipe) == SIG_ERR) {
        printf("signal error\n");
        exit(0);
    }

    if (pipe(fd1) < 0 || pipe(fd2) < 0) {
        printf("pipe error\n");
        exit(0);
    }

    if ((pid = fork()) < 0) {
        printf("fork error\n");
        exit(0);
    }
    else if (pid > 0) {
        close(fd1[0]);
        close(fd2[1]);
        if ((fpin = fdopen(fd2[0], "r")) == NULL) {
            printf("fdopen error\n");
            exit(1);
        }
        if ((fpout = fdopen(fd1[1], "w")) == NULL) {
            printf("fdopen error\n");
            exit(1);
        }
        if (setvbuf(fpin, NULL, _IOLBF, 0) < 0) {
            printf("setvbuf error\n");
            exit(1);
        }
        if (setvbuf(fpout, NULL, _IOLBF, 0) < 0) {
            printf("setvbuf error\n");
            exit(1);
        }
        while (fgets(line, MAXLINE, stdin) != NULL) {
            n = strlen(line);
            if (fputs(line, fpout) == EOF) {
                printf("write error to pipe\n");
                exit(1);
            }
            if (fgets(line, MAXLINE, fpin) == NULL) {
                printf("read error from pipe\n");
                exit(1);
            }
            if (n == 0) {
                printf("child closed pipe\n");
                break;
            }
            line[n] = '\0'; /* null terminate */
            if (fputs(line, stdout) == EOF) {
                printf("fputs error\n");
                exit(1);
            }
        }

        if (ferror(stdin)) {
            printf("fgets error on stdin");
            exit(1);
        }
        exit(0);
    }
    else {
        close(fd1[1]);
        close(fd2[0]);
        if (fd1[0] != STDIN_FILENO) {
            if (dup2(fd1[0], STDIN_FILENO) != STDIN_FILENO) {
                printf("dup2 error to stdin\n");
                exit(1);
            }
            close(fd1[0]);
        }
        if (fd2[1] != STDOUT_FILENO) {
            if (dup2(fd2[1], STDOUT_FILENO) != STDOUT_FILENO) {
                printf("dup2 error to stdin\n");
                exit(1);
            }
            close(fd2[1]);
        }
        if (execl("./add", "add", (char *)0) < 0) {
            printf("execl error\n");
            exit(1);
        }
    }
    exit(0);
}


#include <stdio.h>
#include <stdlib.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;
    char  * 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) {
        printf("malloc error\n");
        exit(1);
    }
    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) {
        printf("shmget error\n");
        exit(1);
    }
    if ((shmptr = shmat(shmid, 0, 0)) == (void *)-1) {
        printf("shmat error\n");
        exit(1);
    }
    printf("shared momory attached from %lx to %lx\n", 
           (unsigned long)shmptr, (unsigned long)shmptr+SHM_SIZE);

    if (shmctl(shmid, IPC_RMID, 0) < 0) {
        printf("shmctl error\n");
        exit(1);
    }

    exit(0);
}


#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/mman.h>

#include "waitfor.h"

#define NLOOPS  1000
#define SIZE    sizeof(long)  /* size of shared memory area */

int 
updata(long * ptr)
{
    return((*ptr)++);
}

int 
main(void)
{
    int      fd;
    int      i;
    int      counter;
    pid_t    pid;
    void   * area;

    if ((fd = open("/dev/zero", O_RDWR)) < 0) {
        printf("open error\n");
        exit(1);
    }
    if ((area = mmap(0, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, 
                     fd, 0)) == MAP_FAILED) { /* will init area with 0 */
        printf("mmap error\n");
        exit(1);
    }
    close(fd); /* can close /dev/zero now that it is mapped */

    TELL_WAIT();

    if ((pid = fork()) < 0) {
        printf("fork error\n");
        exit(1);
    }
    else if (pid > 0) {
        for (i = 0; i < NLOOPS; i += 2) {
            if ((counter = updata((long *)area)) != i) {
                printf("parent: excepted %d, got %d\n", i, counter);
                exit(1);
            }

            TELL_CHILD(pid);
            WAIT_CHILD();
        }
    }
    else {
        for (i = 1; i < NLOOPS + 1; i += 2) {
            WAIT_PARENT();

            if ((counter = updata((long *)area)) != i) {
                printf("child: excepted %d, got %d\n", i, counter);
                exit(1);
            }

            TELL_PARENT(getppid());
        }
    }

    exit(0);
}


#include <stdio.h>
#include <stdlib.h>
#include <sys/shm.h>

#include "waitfor.h"

#define NLOOPS    1000
#define SIZE      sizeof(long)  /* size of shared memory area */
#define SHM_MODE  0600

int 
updata(long * ptr)
{
    return((*ptr)++);
}

int 
main(void)
{
    int      i;
    int      shmid;
    int      counter;
    pid_t    pid;
    void   * area;

    if ((shmid = shmget(IPC_PRIVATE, SIZE, SHM_MODE)) < 0) {
        printf("shmget error\n");
        exit(1);
    }
    if ((area = shmat(shmid, 0, 0)) == (void *)-1) {
        printf("shmat error\n");
        exit(1);
    }

    TELL_WAIT();

    if ((pid = fork()) < 0) {
        printf("fork error\n");
        exit(1);
    }
    else if (pid > 0) {
        for (i = 0; i < NLOOPS; i += 2) {
            if ((counter = updata((long *)area)) != i) {
                printf("parent: excepted %d, got %d\n", i, counter);
                exit(1);
            }

            TELL_CHILD(pid);
            WAIT_CHILD();
        }

        if (waitpid(pid, NULL, 0) != pid) {
            printf("waitpid error\n");
            exit(1);
        }

        if (shmctl(shmid, IPC_RMID, 0) < 0) {
            printf("shmctl error\n");
            exit(1);
        }
    }
    else {
        for (i = 1; i < NLOOPS + 1; i += 2) {
            WAIT_PARENT();

            if ((counter = updata((long *)area)) != i) {
                printf("child: excepted %d, got %d\n", i, counter);
                exit(1);
            }

            TELL_PARENT(getppid());
        }
    }

    exit(0);
}


system popen -> exec fork waitpid
07-02 840
应用程序执行shell命令一般使用popen或者system系统调用函数，看看他们的代码可以搞清楚他们的区别。 popen /* * popen.c Written by W. Richard Stevens */ #include #include #include #include "ourhdr.h"
管道之popen,pclose函数
u014325402的博客
01-03 755
欢迎拍砖。 编辑工具不会用，没对齐，难受。
popen函数的实现
weixin_34037173的博客
10-20 346
popen函数的实现包括一下几步：   1、使用pipe()建立管道 2、使用fork()创建子进程 3、在子进程中调用exec族函数执行命令，通过管道将结果传送至父进程 4、在主进程中等待子进程执行，子进程执行完成后将接收其结果，返回结果的文件指针   类似与system（fork与exec函数的组合），popen在启动另外一个线程时，该线程有可能启动失败或者popen执行shel...
Signal 13 was raised（SIGPIPE管道破裂）
热门推荐
jia12216的专栏
03-10 1万+
管道另一端没有进程接收数据，导致管道破裂而崩溃。 socket或管道，当自己主动关闭，资源被苹果系统回收，对方关闭时，当再次通过socket或pipe的文件描述符发送消息会出现系统级别的崩溃（管道破裂，signal 13。它的级别和内存使用或释放异常一直，由于是系统级别崩溃，所以不能通过@try{}@catch (NSException *exception) { }捕获到异常，而是直接ap
APUE学习笔记-15章进程间通信
CrazyRabbitttt
07-12 476
本文主要是学习圣经apue进程间通信章节的笔记，对部分重点知识进行了概述与部分例子的演示，希望能够帮助到大家
APUE函数笔记十五: 高级进程间通信(部分)
二斗墨汁
04-07 709
第十七章  高级进程间通信(部分): #include int fattach(int filedes, const char * path); if success return 0, else error return -1 #include int fdetach(const char * path); if success return 0, else error
【APUE笔记】第十四章 进程间通信
T_zty_Y的博客
03-19 367
文章目录1.管道 IPC进程间通信（InterProcess Communication） 1.管道 尽管有以下这两种限制，半双工管道仍是最常用的IPC形式： (1) 它们是半双工的。数据只能在一个方向上流动。 (2) 它们只能在具有公共祖先的进程之间使用。通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。   管道是由pipe()函数创建的。fstat()函数对管道的每一端都返回一个FIFO类型的文件描述符，可以用S_ISFIFO宏来测试管道。   单个进程中的管道几
APUE笔记之15章_进程间通信
FinixLei的专栏 (https://github.com/FinixLei)
03-09 383
第15章 进程间通信 进程间通信主要有： 管道（pipe） 有名管道（FIFO） XSI之消息队列 XSI之信号量 XSI之共享存储 POSIX信号量 Socket（16章） UNIX域SOCKET（17章） 1. 管道 管道有2种局限性： 历史上，它们是半双工的 只能在具有公共祖先的2个进程之间使用。 通常，一个管道由一个进程创建，在进程调用fork之后，这个管道就...
学习《高级Linux环境编程》读书笔记(APUE读书笔记)
04-23
15. 进程间通信：详细讨论了几种UNIX进程间通信的机制，如管道、协同进程、命名管道（FIFO）、XSIIPC（包括消息队列、共享内存和信号量）以及这些机制在C/S模型中的应用比较。 16. 网络IPC：套接字：最后一章介绍了...
APUE读书笔记（Unix高级环境编程）
07-06
#### 第十五章 进程间通信 - **管道**：通过管道实现进程间的数据传输。 - **无名管道**：仅限于亲缘关系的进程之间通信。 - **命名管道**：可以在没有亲缘关系的进程间使用。 - **消息队列**：使用消息队列实现...
APUE读书笔记：Unix系统编程深度解析
10. **信号**：进程间通信的一种方式，用于通知事件或请求进程执行特定操作。 11. **Unix系统时间**：系统时间的管理，包括时间戳、定时器等。 **第二章 Unix标准化及实现** 本章探讨了UNIX的标准化进程，如POSIX...
APUE全书精华总结：Unix系统编程深度解析
7. **异步、并发、通信**：讨论Unix中的并发执行模型和进程间通信机制，如管道、消息队列、共享内存等。 8. **出错处理**：如何正确处理运行时错误，如错误检测、错误码、异常处理等。 9. **Unix用户和用户标识**：...
APUE全书精华：Unix系统编程关键点解析
程序与进程的概念是理解Unix系统运行的基础，包括进程创建、进程间通信等。程序线程允许在一个进程中执行多个并发线程。异步、并发和通信涉及了Unix中的多任务处理和同步机制，如信号量、管道、套接字等。出错处理是...
浮点运算转换成整数运算
二斗墨汁
06-02 4926
相比整数运算，浮点运算是很慢的，在效率要求很高的情形下，有时我们得转换成整数运算 如下面的表达式: void get_gray(int red, int green, int blue, int & gray) { gray = static_cast(red * 0.123 + green * 0.456 + blue * 0.421 + 0.5); } 可以转换为:
linux下静态库的依赖顺序
二斗墨汁
04-28 3759
贴下结论： LD在链接生成目标文件时, 会从左到有扫描输入的依赖库, 但是, 当依赖库之间也有依赖关系时,必须将”依赖别人的库”放在 “被别人依赖的库”的前面. 否则,会链接失败!
试题:两个基类有同名的虚函数要实现, 怎么办?
二斗墨汁
01-06 3496
先把问题陈述一下: 有两个类A, B, 它们可能是别人实现的(或是别人提供的库中的类), 很复杂且已经在用, 你不能修改他们, 你想写一个类C同时具有这两个类的特性, 因为自己实现它代价实在是太大, 所以你想到用C继承A, B以达到效果, 但是有一个问题, A, B具有一个同名的虚函数, 你在C中怎么重新实现这个虚函数呢? 先看下面的代码: #include #include usin
【笔记】Qt程序在Windows、OS X、CentOS、Ubuntu下的打包处理
二斗墨汁
08-28 3407
主程序名 web_transmit_adapter Windows： 打包主目录windows：包含子目录web_transmit_adapter和两个打包文件web_transmit_adapter.nsi、和packing.bat 而在web_transmit_adapter子目录中包含了Qt程序web_transmit_adapter.exe以及一些依赖的第三方库文件等 发布
UNP函数笔记七: 基本SCTP套接字编程
二斗墨汁
04-14 2790
第九章  基本SCTP套接字编程: #include int sctp_bindx(int sockfd, const struct sockaddr * addrs, int addrcnt, int flags); flags: SCTP_BINDX_ADD_ADDR, SCTP_BINDX_REM_ADDR success
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值