OS - 进程间通信

进程间通信的方式：

* 管道

* FIFO（命名管道）

* 信号量

* 消息队列

* 共享内存

* socket

通常把一个进程的输出通过管道连接到另一个进程的输入。

Linux系统中的进程通信方式主要以下几种:

同一主机上的进程通信方式

* UNIX进程间通信方式: 包括管道(PIPE), 命名管道(FIFO), 和信号(Signal)

* System V进程通信方式：包括信号量(Semaphore), 消息队列(Message Queue), 和共享内存(Shared Memory)

网络主机间的进程通信方式

* RPC: Remote Procedure Call 远程过程调用

* Socket: 当前最流行的网络通信方式, 基于TCP/IP协议的通信方式.

各自的特点:

管道(PIPE)：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系(父子进程)的进程间使用。另外管道传送的是无格式的字节流，并且管道缓冲区的大小是有限的（管道缓冲区存在于内存中，在管道创建时，为缓冲区分配一个页面大小）。
有名管道 (FIFO)：有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。
信号(Signal)：信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。
信号量(Semaphore)：信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。
消息队列(Message Queue)：消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。
共享内存(Shared Memory )：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号量，配合使用，来实现进程间的同步和通信。
套接字(Socket)：套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同主机间的进程通信。

Linux系统中的线程通信方式主要以下几种:

* 锁机制：包括互斥锁、条件变量、读写锁

互斥锁提供了以排他方式防止数据结构被并发修改的方法。

使用条件变量可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件的测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

读写锁允许多个线程同时读共享数据，而对写操作是互斥的。

* 信号量机制(Semaphore)：包括无名线程信号量和命名线程信号量

* 信号机制(Signal)：类似进程间的信号处理

线程间的通信目的主要是用于线程同步。所以线程没有像进程通信中的用于数据交换的通信机制。

一、进程管道

特性

* 半双工

* 只能在公共祖先的进程间使用

管道由一个进程创建，然后该进程调用fork，此后父子进程之间就可用该管道通信。

1. popen调用

#include <stdio.h>

FILE *popen(const char *command, const char *open_mode);
参数解释：
command 字符串是要运行的程序名和相应的参数。
open_mode 必须是r或者w
成功返回指向文件指针的流，失败返回NULL。

int pclose(FILE *stream_to_close);

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

int main()
{
    FILE *read_fp;
    char buffer[BUFSIZ + 1];
    int chars_read;
    
    // 第一步：清空内存缓存
    memset(buffer, '\0', sizeof(buffer));
    
    // 第二步：popen函数打开
    read_fp = popen("uname -a", "r");
    if (read_fp != NULL) {
        // 第三步：打开文件，读取buffer
        chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
        if (chars_read > 0) {
            printf("Output was:-\n%s\n", buffer);
        }
        // 第四步：关闭
        pclose(read_fp);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

程序示例2：写

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

int main()
{
    FILE *write_fp;
    char buffer[BUFSIZ + 1];

    sprintf(buffer, "Once upon a time, there was...\n");
    write_fp = popen("od -c", "w");
    if (write_fp != NULL) {
        fwrite(buffer, sizeof(char), strlen(buffer), write_fp);
        pclose(write_fp);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

/*
[root@localhost ch13]# ./popen2 
0000000   O   n   c   e       u   p   o   n       a       t   i   m   e
0000020   ,       t   h   e   r   e       w   a   s   .   .   .  \n
0000037
[root@localhost ch13]# 
*/

示例3 使用分段方式获取数据

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

int main()
{
    FILE *read_fp;
    char buffer[BUFSIZ + 1];
    int chars_read;

    memset(buffer, '\0', sizeof(buffer));
    read_fp = popen("ps ax", "r");
    if (read_fp != NULL) {
        chars_read = fread(buffer, sizeof(char), BUFSIZ/10, read_fp);
        while (chars_read > 0) {
            buffer[chars_read - 1] = '\0';
            printf("Reading %d:-\n %s\n", BUFSIZ/10, buffer);
            chars_read = fread(buffer, sizeof(char), BUFSIZ/10, read_fp);
        }
        pclose(read_fp);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

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

int main()
{
    FILE *read_fp;
    char buffer[BUFSIZ + 1];
    int chars_read;

    memset(buffer, '\0', sizeof(buffer));
    read_fp = popen("cat popen*.c | wc -l", "r");
    if (read_fp != NULL) {
        chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
        while (chars_read > 0) {
            buffer[chars_read - 1] = '\0';
            printf("Reading:-\n %s\n", buffer);
            chars_read = fread(buffer, sizeof(char), BUFSIZ, read_fp);
        }
        pclose(read_fp);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

2. pipe调用

#include <unistd.h>

int pipe(int file_descriptor[2]);
成功返回0，失败返回-1

写到file_descriptor[1]的所有数据都可以从file_descriptor[0]读回来
数据基于FIFO进行处理。

示例程序：

创建一个从父进程到子进程的管道，并且父进程经由该管道向子进程传送数据。

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

int main()
{
    int data_processed;
    int file_pipes[2];
    const char some_data[] = "123";
    char buffer[BUFSIZ + 1];
    memset(buffer, '\0', sizeof(buffer));
    if (pipe(file_pipes) == 0) {
        data_processed = write(file_pipes[1], some_data, strlen(some_data));
        printf("Wrote %d bytes\n", data_processed);
        data_processed = read(file_pipes[0], buffer, BUFSIZ);
        printf("Read %d bytes: %s\n", data_processed, buffer);
        exit(EXIT_SUCCESS);
    }
    exit(EXIT_FAILURE);
}

[root@localhost ch13]# ./pipe1

Wrote 3 bytes

Read 3 bytes: 123

[root@localhost ch13]#

二、命名管道

FIFO 不相关的进程也能交换数据。

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);
成功返回0， 失败返回-1

posted @ 2017-12-31 15:27 elewei 阅读(547) 评论(0) 收藏举报

刷新页面返回顶部

David

OS - 进程间通信

一、进程管道

2. pipe调用

二、命名管道