多进程编程知识汇总

什么是进程

1、进程和线程的区别

进程是指正在运行的程序，它拥有独立的内存空间和系统资源，不同进程之间的数据不共享。进程是资源分配的基本单位。

线程是进程内的执行单元，它与同一进程内的其他线程共享进程的内存空间和系统资源。线程是调度的基本单位。

2、进程的创建和销毁

在Linux中启动一个进程有多种方法：

（1）通过system函数启动进程。（使用简单，效率较低）

#include 

/**
 * @brief 执行系统命令调用命令处理器来执行命令
 *
 * Detailed function description
 *
 * @param[in] command: 包含被请求变量名称的 C 字符串
 *
 * @return 如果发生错误，则返回值为 -1，否则返回命令的状态。
 */
int system(const char *command);

例子：通过system函数启动一个进程，列出当前目录下的文件及文件夹。

#include 
#include 

int main(void)
{
    system("ls");
    printf("ls end
");

    return 0;
}

（2）通过fork函数启动进程。（用于启动子进程）

#include 
#include 

/**
 * @brief fork系统调用用于创建一个子进程
 *
 * Detailed function description
 *
 * @param[in]
 *
 * @return 如果发生错误，则返回值为 -1，否则返回命令的状态。
 */
pid_t fork(void);

例子：通过fork函数启动子进程

#include 
#include 
#include 
#include 

int main(void) 
{
    pid_t res = fork();

    ///< 子进程
    if (res == 0) 
    {
        printf("res = %d, I am child process. pid = %d
", res, getpid());
        exit(EXIT_SUCCESS);   ///< 正常退出子进程
    } 
    ///< 父进程
    else if (res > 0) 
    {
        printf("res = %d, I am parent process. pid = %d
", res, getpid());

        int child_status = 0;
        pid_t child_pid = wait(&child_status);   ///< 父进程阻塞等待信号到来或子进程结束
        printf("Child process(pid = %d) has been terminated, child_status = %d
", child_pid, child_status);
    } 
    ///< 异常退出
    else 
    {
        printf("Fork failed.
");
        exit(EXIT_FAILURE);
    }
    return 0;
}

编译、运行：

我们使用了fork()系统调用来创建一个新进程。如果fork()返回值为0，则说明当前进程是子进程；如果返回值大于0，则说明当前进程是父进程。在父进程中，我们使用wait()系统调用来等待子进程结束。当子进程结束后，父进程会继续执行。

（3）通过exec系列函数启动进程。（用于启动新进程，新进程会覆盖旧进程）

#include 

/**
 * @brief 启动新进程，新进程会覆盖旧进程
 *
 * Detailed function description
 *
 * @param[in] path: 所执行文件的路径
 * @param[in] file: 所执行文件的名称
 * @param[in] arg: 传入的参数列表，以NULL作为结束
 * @param[in] envp: 传入的环境变量
 *
 * @return 如果发生错误，则返回值为 -1，否则返回命令的状态。
 */
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ..., char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);

例子：通过execl()函数的参数列表调用了ls命令程序

#include 
#include 

int main(void)
{
    execl("/bin/ls", "ls", "-la", NULL);
    printf("ls end
");
    return 0;
}

execl()函数的参数列表调用了ls命令程序，与在终端上运行”ls -la”产生的结果是一样的。

在Linux中终止一个进程有多种方法：

从main函数返回。（正常终止）

调用exit()函数终止。（正常终止）

调用_exit()函数终止。（正常终止）

调用abort()函数终止。（异常终止）

由系统信号终止。（异常终止）

进程间通信方式

进程间通信是指在不同进程之间传播或交换信息的一种机制。每个进程各自有不同的用户地址空间，任何一个进程的全局变量在另一个进程中都看不到，所以进程之间要交换数据必须通过内核，在内核中开辟一块缓冲区，进程A把数据从用户空间拷到内核缓冲区，进程B再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信。

进程间通信的目的：

传输数据。比如进程 A 负责生成数据，进程 B 负责处理数据，数据需要从 A 进程传输至 B 进程。

共享资源。比如进程 A 与进程 B 共享某一块内存资源。

模块化。将系统功能划分为多个进程模块进行开发，方便开发维护。

加速计算。多核处理器环境，一个特定进程划分为几个进程并行运行。

Linux IPC（Inter-process Comminication，进程间通信）的方式：

1、消息队列

内核中的一个优先级队列，多个进程通过访问同一个队列，进行添加结点或者获取结点实现通信。

POSIX消息队列头文件：

#include            /* For O_* constants */
#include         /* For mode constants */
#include

编译链接需要加上 -lrt 链接。

消息队列API接口：

/**
 * @brief 创建消息队列实例
 *
 * Detailed function description
 *
 * @param[in] name: 消息队列名称
 * @param[in] oflag：根据传入标识来创建或者打开一个已创建的消息队列
                    - O_CREAT: 创建一个消息队列
                    - O_EXCL: 检查消息队列是否存在，一般与O_CREAT一起使用
                    - O_CREAT|O_EXCL: 消息队列不存在则创建，已存在返回NULL
                    - O_NONBLOCK: 非阻塞模式打开，消息队列不存在返回NULL
                    - O_RDONLY: 只读模式打开
                    - O_WRONLY: 只写模式打开
                    - O_RDWR: 读写模式打开
 * @param[in] mode：访问权限
 * @param[in] attr：消息队列属性地址
 *
 * @return 成功返回消息队列描述符，失败返回-1，错误码存于error中
 */
mqd_t mq_open(const char *name, int oflag,  mode_t mode, struct mq_attr *attr);

/**
 * @brief 无限阻塞方式接收消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息队列描述符
 * @param[in] msg_ptr：消息体缓冲区地址
 * @param[in] msg_len：消息体长度，长度必须大于等于消息属性设定的最大值
 * @param[in] msg_prio：消息优先级
 *
 * @return 成功返回消息长度，失败返回-1，错误码存于error中
 */
mqd_t mq_receive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio);

/**
 * @brief 指定超时时间阻塞方式接收消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息队列描述符
 * @param[in] msg_ptr：消息体缓冲区地址
 * @param[in] msg_len：消息体长度，长度必须大于等于消息属性设定的最大值
 * @param[in] msg_prio：消息优先级
 * @param[in] abs_timeout：超时时间
 *
 * @return 成功返回消息长度，失败返回-1，错误码存于error中
 */
mqd_t mq_timedreceive(mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned *msg_prio, const struct timespec *abs_timeout);

/**
 * @brief 无限阻塞方式发送消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息队列描述符
 * @param[in] msg_ptr：待发送消息体缓冲区地址
 * @param[in] msg_len：消息体长度
 * @param[in] msg_prio：消息优先级
 *
 * @return 成功返回0，失败返回-1
 */
mqd_t mq_send(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio);

/**
 * @brief 指定超时时间阻塞方式发送消息
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息队列描述符
 * @param[in] msg_ptr：待发送消息体缓冲区地址
 * @param[in] msg_len：消息体长度
 * @param[in] msg_prio：消息优先级
 * @param[in] abs_timeout：超时时间
 *
 * @return 成功返回0，失败返回-1
 */
mqd_t mq_timedsend(mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned msg_prio, const struct timespec *abs_timeout);

/**
 * @brief 关闭消息队列
 *
 * Detailed function description
 *
 * @param[in] mqdes: 消息队列描述符
 *
 * @return 成功返回0，失败返回-1
 */
mqd_t mq_close(mqd_t mqdes);

/**
 * @brief 分离消息队列
 *
 * Detailed function description
 *
 * @param[in] name: 消息队列名称
 *
 * @return 成功返回0，失败返回-1
 */
mqd_t mq_unlink(const char *name);

消息队列基本API接口使用例子：发送进程给接收进程发送测试数据。

send.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 

#define MQ_MSG_MAX_SIZE    512  ///< 最大消息长度 
#define MQ_MSG_MAX_ITEM    5  ///< 最大消息数目

static mqd_t s_mq;

typedef struct _msg_data
{
    char buf[128];
    int cnt;
}msg_data_t;


void send_data(void)
{
    static int cnt = 0;
    msg_data_t send_data = {0};

    cnt++;
    strcpy(send_data.buf, "hello");
    send_data.cnt = cnt;
    int ret = mq_send(s_mq, (char*)&send_data, sizeof(send_data), 0);
    if (ret < 0)
    {
        perror("mq_send error");
        return;
    }
    printf("send msg = %s, cnt = %d
", send_data.buf, send_data.cnt);
}


int main(void)
{
    int ret = 0;
    struct mq_attr attr;

    ///< 创建消息队列
    memset(&attr, 0, sizeof(attr));
    attr.mq_maxmsg = MQ_MSG_MAX_ITEM;
    attr.mq_msgsize = MQ_MSG_MAX_SIZE;
    attr.mq_flags = 0;
    s_mq = mq_open("/mq", O_CREAT|O_RDWR, 0777, &attr);
 if(-1 == s_mq)
    {
        perror("mq_open error");
        return -1;
    }

    for (size_t i = 0; i < 10; i++)
    {
        send_data();
        sleep(1);
    }

    mq_close(s_mq);

    return 0;
}

recv.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 

#define MQ_MSG_MAX_SIZE    512  ///< 最大消息长度 
#define MQ_MSG_MAX_ITEM    5  ///< 最大消息数目

static mqd_t s_mq;

typedef struct _msg_data
{
    char buf[128];
    int cnt;
}msg_data_t;

int main(void)
{
    int ret = 0;
    struct mq_attr attr;
    char recv_msg[MQ_MSG_MAX_SIZE] = {0};
    msg_data_t recv_data = {0};
    int prio = 0;
    ssize_t len = 0;

    s_mq = mq_open("/mq", O_RDONLY);
 if(-1 == s_mq)
    {
        perror("mq_open error");
        return -1;
    }

    while (1)
    {
        if((len = mq_receive(s_mq, (char*)&recv_data, MQ_MSG_MAX_SIZE, &prio)) == -1)
        {
            perror("mq_receive error");
            return -1;
        }
        printf("recv_msg = %s, cnt = %d
", recv_data.buf, recv_data.cnt);
        sleep(1);
    }

    mq_close(s_mq);
    mq_unlink("/mq");

    return 0;
}

编译、运行：

gcc send.c -o send_process -lrt
gcc recv.c -o recv_process -lrt

2、共享内存

消息队列的读取和写入的过程，会有发生用户态与内核态之间的消息拷贝过程。而共享内存的方式则没有这个拷贝过程，进程间通信速度较快。

在物理内存上开辟一块内存空间，多个进程可以将同一块物理内存空间映射到自己的虚拟地址空间，通过自己的虚拟地址直接访问这块空间，通过这种方式实现数据共享。

POSIX共享内存头文件：

#include 
#include 
#include

共享内存API接口：

/**
 * @brief 创建共享内存实例
 *
 * Detailed function description
 *
 * @param[in] name: 要打开或创建的共享内存文件名
 * @param[in] oflag：打开的文件操作属性
                    - O_CREAT: 创建一个共享内存文件
                    - O_EXCL: 检查共享内存是否存在，一般与O_CREAT一起使用
                    - O_CREAT|O_EXCL: 共享内存不存在则创建，已存在返回NULL
                    - O_NONBLOCK: 非阻塞模式打开，共享内存不存在返回NULL
                    - O_RDONLY: 只读模式打开
                    - O_WRONLY: 只写模式打开
                    - O_RDWR: 读写模式打开
 * @param[in] mode：文件共享模式，例如 0777
 *
 * @return 成功返回共享内存描述符，失败返回-1，错误码存于error中
 */
int shm_open(const char *name, int oflag, mode_t mode);

/**
 * @brief 删除共享内存
 *
 * Detailed function description
 *
 * @param[in] name: 创建的共享内存文件名
 *
 * @return 成功返回0，失败返回-1
 */
int shm_unlink(const char *name);

/**
 * @brief 将打开的文件映射到内存
 *
 * Detailed function description
 *
 * @param[in] addr: 要将文件映射到的内存地址，一般应该传递NULL来由Linux内核指定
 * @param[in] length: 要映射的文件数据长度
 * @param[in] prot: 映射的内存区域的操作权限（保护属性），包括PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
 * @param[in] flags: 标志位参数，包括：MAP_SHARED、MAP_PRIVATE与MAP_ANONYMOUS。
 * @param[in] fd:  用来建立映射区的文件描述符，用 shm_open打开或者open打开的文件
 * @param[in] offset: 映射文件相对于文件头的偏移位置，应该按4096字节对齐
 *
 * @return 成功返回0，失败返回-1
 */
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
 
/**
 * @brief 取消内存映射
 *
 * Detailed function description
 *
 * @param[in] addr: 由mmap成功返回的地址
 * @param[in] length: 要取消的内存长度
 *
 * @return 成功返回0，失败返回-1
 */
int munmap(void *addr, size_t length);

/**
 * @brief 将参数fd指定的文件大小改为参数length指定的大小
 *
 * Detailed function description
 *
 * @param[in] fd: 已打开的文件描述符，以写入模式打开的文件
 * @param[in] length: 要设置的长度
 *
 * @return 成功返回0，失败返回-1
 */
int ftruncate(int fd,off_t length);

/**
 * @brief 获取文件相关的信息，将获取到的信息放入到statbuf结构体中
 *
 * Detailed function description
 *
 * @param[in] fd: 已打开的文件描述符
 * @param[out] statbuf: 文件的信息
 *
 * @return 成功返回0，失败返回-1
 */
int fstat(int fd, struct stat *statbuf);

共享内存基本API接口使用例子：发送进程给接收进程发送测试数据。

send.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 

#define SHM_NAME "/shm"

int main(void)
{
    int ret = 0;

    ///< 创建和读端相同的文件标识
    int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
    if (shm_fd == -1) 
    {
        printf("shm_open error
");
    }

    ///< 设置共享内存文件为8KB
    ftruncate(shm_fd , 8 * 1024);

    ///< 获取共享内存文件相关属性信息
    struct stat filestat = {0};
    fstat(shm_fd, &filestat);
    printf("st_size = %ld
",filestat.st_size);

    ///< 内存映射
    char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
    close(shm_fd);

    ///< 向共享内存中写入数据
    char buf[] = "hello world";
    memmove(shm_ptr,buf, sizeof(buf));
    printf("pid %d, %s
",getpid(), shm_ptr);

    ///< 写入完成后解除映射
    munmap(shm_ptr, filestat.st_size);

    return 0;
}

recv.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 

#define SHM_NAME "/shm"

int main(void)
{
    ///< 创建共享内存文件标识符
    int shm_fd = shm_open(SHM_NAME, O_RDWR | O_CREAT, 0666);
    if (shm_fd == -1) 
    {
        printf("shm_open failed
");
        exit(EXIT_FAILURE);
    }

    ///< 设置共享内存文件为8KB
    ftruncate(shm_fd , 8192);

    ///< 获取共享内存文件相关属性信息
    struct stat filestat;
    fstat(shm_fd, &filestat);
    printf("st_size = %ld
",filestat.st_size);

    ///< 映射共享内存，并获取共享内存的地址
    char *shm_ptr = (char*)mmap(NULL, filestat.st_size, PROT_READ|PROT_WRITE, MAP_SHARED, shm_fd, 0);
    close(shm_fd);
    
    ///< 获取共享内存地址中的内容并打印，最后再解除映射，删除共享内存
    printf("pid = %d， %s
", getpid(), shm_ptr);
    munmap(shm_ptr, filestat.st_size);
    shm_unlink(SHM_NAME);

    return 0;
}

编译、运行：

gcc send.c -o send_process -lrt
gcc recv.c -o recv_process -lrt

对具有多个处理核系统消息传递的性能要优于共享内存。共享内存会有高速缓存一致性问题，这是由共享数据在多个高速缓存之间迁移而引起的。随着系统的处理核的数量的日益增加，可能导致消息传递作为 IPC 的首选机制。

3、socket

UNIX域套接字与传统基于TCP/IP协议栈的socket不同，unix domain socket以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。

unix domain socket在进程间通信同样是基于“客户端—服务器”（C-S）模式。

UNIX域套接字基本API接口使用例子：基于UNIX域套接字客户端进程向服务端进程发送测试数据。

server.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 
#include 
#include 
#include 

#define SERVER_PATH "/tmp/server" 

int main(void)
{
 ///< 创建UNIX域字节流套接字
 int server_fd = socket(AF_LOCAL, SOCK_STREAM, 0);
 if(server_fd < 0)
 {
  printf("socket error
");
  exit(EXIT_FAILURE);
 }

 ///< 绑定服务端地址
 unlink(SERVER_PATH);
 struct sockaddr_un server_addr;
 memset((char*)&server_addr, 0, sizeof(server_addr));
 server_addr.sun_family = AF_LOCAL;
 strncpy(server_addr.sun_path, SERVER_PATH, sizeof(server_addr.sun_path)-1);
 if(bind(server_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) < 0)
 {
  printf("bind error
");
        close(server_fd);
  exit(EXIT_FAILURE);
 }

 ///< 监听
 if(listen(server_fd, 10) < 0) 
 {
  printf("listen error
");
        close(server_fd);
  exit(EXIT_FAILURE);
 }

    ///< 等待客户端连接
 int addr_len = sizeof(struct sockaddr);
    struct sockaddr_un client_addr;
 int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, (socklen_t *)&addr_len);
 if(client_fd < 0)
 {
  printf("accept error
");
  close(server_fd);
  unlink(SERVER_PATH);
  exit(1); 
 }
 else
 {
  printf("connected client: %s
", client_addr.sun_path);
 }

 while(1)
 {
        char buf[128] = {0};

        int recv_len = read(client_fd, buf, sizeof(buf)); 
        if(recv_len <= 0)
        {
            printf("recv error!
");
            close(client_fd);
            exit(EXIT_FAILURE);
        }

        printf("recv : %s
", buf);
 }

    unlink(SERVER_PATH);
 close(server_fd);
    close(client_fd);

    return 0;
}

client.c：

#include 
#include 
#include 
#include 
#include            /* For O_* constants */
#include         /* For mode constants */
#include 
#include 
#include 
#include 

#define SERVER_PATH "/tmp/server"
#define CLIENT_PATH "/tmp/client"

int main(void)
{
 ///< 创建UNIX域字节流套接字
 int client_fd = socket(AF_UNIX, SOCK_STREAM, 0);
 if(client_fd < 0)
 {
  printf("socket error
");
  exit(EXIT_FAILURE);
 }

 ///< 显式绑定客户端地址
    struct sockaddr_un client_addr;
 memset((char*)&client_addr, 0, sizeof(client_addr));
 client_addr.sun_family = AF_UNIX;
 strncpy(client_addr.sun_path, CLIENT_PATH, sizeof(client_addr.sun_path)-1);
 unlink(CLIENT_PATH);
 if(bind(client_fd, (struct sockaddr*)&client_addr, sizeof(client_addr)) < 0)
 {
  printf("bind error
");
  close(client_fd);
  exit(1); 
 }

 ///< 连接服务端
    struct sockaddr_un server_addr;
 server_addr.sun_family  = AF_UNIX;
 strncpy(server_addr.sun_path, SERVER_PATH, sizeof(server_addr.sun_path)-1);
 int ret = connect(client_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)); 
 if(ret < 0)
 {
  printf("connect error
");
  close(client_fd);
  unlink(CLIENT_PATH);
  exit(1);  
 } 
 printf("connect to server: %s
", server_addr.sun_path);

 while(1)
 {
        char buf[128] = {0};
        if (scanf("%s", buf))
        {
            int send_len = write(client_fd, buf, strlen(buf));
            if (send_len <= 0)
            {
                printf("write error!
");
                close(client_fd);
                exit(EXIT_FAILURE);  
            }
            else
            {
                printf("send success! send: %s, send_len: %d
", buf, send_len);
            }
        } 
 }

    unlink(SERVER_PATH);
    close(client_fd);

    return 0;
}

编译、运行：

gcc server.c -o server_process
gcc client.c -o client_process

类socket的其它进程间通信方式：

实用 | nanomsg通信库的简单使用分享

mqtt应用于进程间通信

4、管道

在内核中开辟一块缓冲区；若多个进程拿到同一个管道(缓冲区)的操作句柄，就可以访问同一个缓冲区，就可以进行通信。涉及到两次用户态与内核态之间的数据拷贝。

（1）匿名管道

内核中的缓冲区是没有具体的标识符的，匿名管道只能用于具有亲缘关系的进程间通信。

调用pipe接口可以创建一个匿名管道，并返回了两个描述符，一个是管道的读取端描述符 fd[0]，另一个是管道的写入端描述符 fd[1]。

管道是一个半双工通信(可以选择方向的单向传输)

匿名管道基本API接口使用例子：父进程通过管道发送测试数据给子进程。

#include 
#include 
#include 
#include 

int main()
{
    ///< 创建管道
 int pipefd[2] = {-1};
   int ret = pipe(pipefd);
    if (ret < 0)
    {
       printf("pipe error
");
       exit(EXIT_FAILURE);
    }

    int read_fd = pipefd[0];   ///< pipefd[0] 用于从管道中读取数据
    int write_fd = pipefd[1];  ///< pipefd[1] 用于向管道中写入数据

    ///< 创建子进程
    pid_t pid = fork();
    if (pid == 0)
    {
        ///< 子进程从管道读取数据  
  char buf[128] = {0};
  read(read_fd, buf, sizeof(buf));
        printf("child recv data from father: %s", buf);
 }
    else if (pid > 0)
   {
  ///< 父进程向管道写入数据
        char *ptr = "hello88888888
";
        write(write_fd, ptr, strlen(ptr));
    }
 return 0;
}

编译、运行：

如果需要双向通信，则应该创建两个管道。

（2）命名管道

命名管道也是内核中的一块缓冲区，并且这个缓冲区具有标识符；这个标识符是一个可见于文件系统的管道文件，能够被其他进程找到并打开管道文件，则可以获取管道的操作句柄，所以该命名管道可用于同一主机上的任意进程间通信。

创建命名管道的接口：

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

命名管道基本API接口使用例子：一个进程往管道中写入测试数据，另一个进程从管道中读取数据。

fifo_wr.c：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define FIFO_PATH  "./fifo_file"

typedef struct _msg_data
{
    char buf[128];
    int cnt;
}msg_data_t;

void send_data(int fd)
{
    static int cnt = 0;
    msg_data_t send_data = {0};

    cnt++;
    strcpy(send_data.buf, "hello");
    send_data.cnt = cnt;
    write(fd, &send_data, sizeof(send_data));
    printf("send msg = %s, cnt = %d
", send_data.buf, send_data.cnt);
}

int main(void)
{
    ///< 创建管道文件
    int ret = mkfifo(FIFO_PATH, 0664);
    if (ret < 0 && errno != EEXIST)
    {
        printf("mkfifo error
");
        exit(EXIT_FAILURE);
    }

    ///< 以只写的方式打开管道文件
    int fd = open(FIFO_PATH, O_WRONLY);
    if (fd < 0)
    {
        printf("open fifo error
");
        exit(EXIT_FAILURE);
    }
    printf("open fifo success
");
    
    ///< 写10次
    for (size_t i = 0; i < 10; i++)
    {
        send_data(fd);
        sleep(1);
    }
    
    close(fd);

    return 0;
}

fifo_rd.c：

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define FIFO_PATH  "./fifo_file"

typedef struct _msg_data
{
    char buf[128];
    int cnt;
}msg_data_t;

int main(void)
{
    umask(0);
    ///< 创建管道文件
    int ret = mkfifo(FIFO_PATH,0664 );
    if (ret < 0 && errno != EEXIST)
    {
        printf("mkfifo error
");
        exit(EXIT_FAILURE);
    }

    ///< 以只读方式获取管道文件的操作句柄
    int fd = open(FIFO_PATH, O_RDONLY);
    if (fd < 0)
    {
        printf("open error
");
        exit(EXIT_FAILURE);
    }
    printf("open fifo success
");

    while(1)
    {
        msg_data_t read_data = {0};
        ///< 将从管道读取的文件写到buf中
        int ret = read(fd, &read_data, sizeof(read_data));
        if (ret < 0)
        {
            printf("read error
");
            exit(EXIT_FAILURE);
        }
        else if (ret == 0)
        {
            printf("all write closed
d");
            exit(EXIT_FAILURE);
        }
        printf("read_data = %s, cnt = %d
", read_data.buf, read_data.cnt);
        sleep(1);
    }
    close(fd);

    return 0;
}

编译、运行：

gcc fifo_wr.c -o fifo_wr
gcc fifo_rd.c -o fifo_rd

5、信号量

信号量（Seamphore）是进程和线程间同步的一种机制。

信号量本质是一个非负的整型变量。增加一个可用资源执行加一，也称为V操作；获取一个资源资源后执行减一，也称为P操作。

信号量根据信号值不同可分为两类：

二值信号量，信号量值只有0和1，初始值为1，1表示资源可用，0表示资源不可用；二值信号量与互斥锁类似。

计数信号量，信号量的值在0到一个大于1的限制值之间，信号值表示可用的资源的数目。

信号量根据作用对象不同可分为两类：

有名信号量，信号值保存在文件中，用于进程间同步

无名信号量，又称为基于内存信号量，信号值保存在内存中，用于线程间同步

POSIX信号量头文件：

#include

编译链接需要加-lpthread参数。

信号量API接口：

/**
 * @brief 创建信号量
 *
 * Detailed function description
 *
 * @param[in] name: 信号量名称
 * @param[in] mode: 访问权限
 * @param[in] value: 信号量初始值
 *
 * @return 成功时返回指向信号量的指针，出错时为SEM_FAILED
 */
sem_t *sem_open(const char *name,int oflag, mode_t mode, unsigned int value);

/**
 * @brief 初始化信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 * @param[in] pshared: 信号量作用域，分为进程内作用域PTHREAD_PROCESS_PRIVATE和跨进程作用域PTHREAD_PROCESS_SHARED
 * @param[in] value: 信号量初始值
 *
 * @return 成功返回0，失败返回-1
 */
int sem_init(sem_t *sem, int pshared, unsigned int value);

/**
 * @brief 获取信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 * @param[out] sval: 保存返回信号值地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_getvalue(sem_t *sem, int *sval);

/**
 * @brief 阻塞方式等待信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_wait(sem_t *sem);

/**
 * @brief 指定超时时间阻塞方式等待信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 * @param[in] sem: 超时时间，单位为时钟节拍
 *
 * @return 成功返回0，失败返回-1
 */
int sem_timedwait(sem_t *sem, const struct timespec *abs_timeout);

/**
 * @brief 非阻塞方式等待信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_trywait(sem_t *sem);

/**
 * @brief 产生信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_post(sem_t *sem);

/**
 * @brief 销毁信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_destroy(sem_t *sem);

/**
 * @brief 关闭信号量
 *
 * Detailed function description
 *
 * @param[in] sem: 信号量实例地址
 *
 * @return 成功返回0，失败返回-1
 */
int sem_close(sem_t *sem);

/**
 * @brief 分离信号量
 *
 * Detailed function description
 *
 * @param[in] name: 信号量名称
 *
 * @return 成功返回0，失败返回-1
 */
int sem_unlink(const char *name);

信号量基本API接口使用例子：父子进程间通信

#include 
#include 
#include 
#include 
#include 

#define SEM_NAME "sem"

int main (void)
{
    int sem_val = 0;

    ///< 创建信号量
    sem_t *sem = sem_open(SEM_NAME, O_CREAT, 0666, 1);
    if (NULL == sem)
    {
       printf("sem_open error
");
       exit(EXIT_FAILURE); 
    }

    ///< 创建子进程
    pid_t pid = fork();
    if (pid == -1) 
    {
        printf("fork error
");
        sem_close(sem);
        sem_unlink(SEM_NAME);
        exit(EXIT_FAILURE);
    }
    else if(pid == 0) 
    {
        ///< 子进程进行5次P操作
        for (size_t i = 0; i < 5; i++)
        {
            sem_wait(sem);
            if (sem_getvalue(sem, &sem_val) != -1) 
            {
                printf("child process P operation, sem_val = %d
", sem_val);
                sleep(1);
            }
        }
        _exit(1);
    }
    else if (pid > 0)
    {
        ///< 父进程执行5次V操作
        for (size_t i = 0; i < 5; i++)
        {
            sem_post(sem);
            if (sem_getvalue(sem, &sem_val) != -1) 
            {
                printf("prarent process V operation, sem_val = %d
", sem_val);
                sleep(2);
            }
        }
    }

    ///< 删除sem信号量
    sem_close(sem);
    if (sem_unlink(SEM_NAME) != -1) 
    {
        printf("sem_unlink success
");
    }

    return 0;
}

编译、运行：

IPC总结

操作系统根据不同的场景提供了不同的方式，消息队列、共享内存、UNIX域套接字、管道、信号量。

消息队列： 内核中的一个优先级队列，多个进程通过访问同一个队列，在队列当中添加或者获取节点来实现进程间通信。

共享内存： 本质是一块物理内存，多个进程将同一块物理内存映射到自己的虚拟地址空间中，再通过页表映射到物理地址达到进程间通信，它是最快的进程间通信方式，相较其他通信方式少了两步数据拷贝操作。

UNIX域套接字： 与TCP/IP套接字使用方式相同，但UNIX域套接字以文件系统作为地址空间，不需经过TCP/IP的头部封装、报文ack确认、路由选择、数据校验与重传过程，因此传输速率上也不会受网卡带宽的限制。

管道： 内核中的一块缓冲区，分为匿名管道和命名管道。匿名管道只能用于具有亲缘关系的进程间；而命名管道可用于同一主机上任意进程间通信。

信号量： 本质是内核中的一个计数器，主要实现进程间的同步与互斥，对资源进行计数，有两种操作，分别是在访问资源之前进行的p操作，还有产生资源之后的v操作。

　审核编辑：汤梓红

阅读全文

Linux(206514) Linux(206514)
编程(92184) 编程(92184)
函数(61194) 函数(61194)
线程(19463) 线程(19463)
多进程(2584) 多进程(2584)

Linux开发_Linux下进程编程

介绍Linux下进程概念、进程信号捕获、进程管理相关的命令的使用等知识点。

2022-09-17 15:38:45

1057

***221+8位CC数码管的知识点汇总，绝对实用

DS1302+MAX7221+8位CC数码管的知识点汇总，绝对实用

2022-01-25 07:17:21

4412arm中断的知识点汇总，绝对实用

2022-02-07 07:06:42

进程有几种状态？

文章目录操作系统进程和线程什么是进程？什么是线程？进程和线程有什么区别？何时使用多进程，何时使用多线程？进程有几种状态？画一下进程状态转换图？创建进程有哪几种方式?进程间通信方式有哪些？有什么优缺点

2021-12-24 07:16:54

ARM Cortex的知识点汇总，不看肯定后悔

2021-11-05 07:04:03

ARM汇编基础知识点汇总，错过肯定后悔

2021-11-29 07:13:36

Cortex‐M3内核的知识点汇总，绝对实用

2022-01-26 06:30:58

DAC的知识点汇总，不看肯定后悔

2021-11-08 07:41:53

DAM串口发送/接收数据的知识点汇总，绝对实用

2021-12-14 07:10:38

DBC编辑的知识点汇总，绝对实用

2022-02-09 08:02:14

GDB的知识点汇总，绝对实用

2021-12-24 06:01:36

HT32F52352的知识点汇总，绝对实用

2022-01-27 06:06:35

IIC总线的知识点汇总，不看肯定后悔

2021-11-23 07:10:03

IIC的核心知识点汇总，绝对实用

2022-01-24 06:14:22

IO口的知识点汇总，错过绝对后悔

2021-12-15 06:52:48

JTAG调试的知识点汇总，绝对实用

2021-12-24 06:09:03

JVM的知识点汇总，不看肯定后悔

2021-11-30 06:13:53

LINUX关于进程的有关知识

我自己总结的关于进程的知识

2013-10-30 22:38:46

Linux Shell多进程并发以及并发数控制

Linux Shell多进程并发以及并发数控制1. 基础知识准备1.1. linux后台进程Unix是一个多任务系统，允许多用户同时运行多个程序。shell的元字符&提供了在后台运行不需要

2017-08-28 15:53:27

Linux下多进程编程之fork()函数语法

vfork()函数的实现方式，例如uClinux所有的多进程管理都通过vfork()来实现。本文选自华清远见嵌入式培训教材《从实践中学嵌入式Linux应用程序开发》

2013-08-19 09:28:29

Linux平台手册的知识点汇总，绝对实用

2022-03-07 06:35:13

Linux系统编程重点学习标准I/O库

Makefile脚本编写等知识，嵌入式开发环境的搭建。3Linux系统编程重点学习标准I/O库，Linux多任务编程中的多进程和多线程，以及进程间通信(pipe、FIFO、消息队列、共享内存、signal、信号量等)，同步与互斥对共享资源访问控制等重要知识，主要提升对L

2021-12-15 06:45:15

Linux系统进程的知识总结

我们先打个比方，多线程是十字路口多线程是平面交通系统，造价低，但是红绿灯多，老堵车，而多进程是则是立交桥，虽然造价高，上下坡多耗油，但是不堵车。这是一个抽象的概念。相信大家看完会有这种感觉。进程

2018-09-06 12:00:55

PS2通讯协议的知识点汇总，绝对实用

2022-02-07 07:50:11

RK3399 HDMI接口的知识点汇总，绝对实用

2022-03-07 06:53:34

RT-Thread的知识点汇总，不看肯定后悔

2021-11-08 08:11:53

SG90舵机的知识点汇总，绝对实用

舵机有哪些分类？SG90舵机的知识点汇总，绝对实用

2022-01-20 07:13:00

STM32 IIC和USART接口的基础知识点汇总，绝对实用

2022-02-22 08:00:56

STM32编程的C语言基础知识点汇总，不看肯定后悔

2021-11-25 07:34:34

STM32CubeMX的待机唤醒知识点汇总，看完你就懂了

2021-11-23 06:17:54

STM32F103固件库编程的知识点汇总，错过绝对后悔

2021-12-14 06:54:25

STM32F103的知识点汇总，错过绝对后悔

2021-12-17 06:37:30

STM32F10启动文件知识点汇总，绝对实用

2022-02-15 06:12:45

STM32L151固件库编程知识点汇总，不看肯定后悔

2021-11-23 07:39:09

STM32定时器中断的知识点汇总，绝对实用

2022-01-20 06:06:42

STM32库的相关知识点汇总，不看肯定后悔

2021-11-30 07:42:52

STM32时钟分频系数的知识点汇总，绝对实用

2021-12-15 07:01:54

STM32时钟树的基础知识点汇总，绝对实用

2022-02-14 07:49:04

STM32端口复用与串口通信得知识点汇总，错过绝对后悔

2021-12-15 06:59:29

Systick中断优先级的知识点汇总，绝对实用

2022-01-26 07:43:41

UART异步通信的知识点汇总，错过绝对后悔

2021-12-10 07:42:24

UART的知识点汇总，不看肯定后悔

2021-12-02 07:16:40

UCOSIII的基础知识点汇总，总结的太棒了

2021-11-30 07:22:33

labview有多进程吗？

labview有多进程吗？

2021-02-03 17:13:42

python多线程和多进程对比

电视边吃饭边聊天。这就是我们的 多进程 才能做的事了。2. 单线程VS多线程VS多进程文字总是苍白无力的，不如用代码直接来测试一下。开始对比之前，首先定义四种类型的场景 - CPU计算密集型 - 磁盘

2022-03-15 16:42:20

“多进程不同能对同一个对象进行赋值问题”如何解决？

进程的并行性决定了多进程不同能对同一个对象进行赋值，这个问题如何解决？代码如下////启动清屏//always @(negedge clk) begin //en脉冲到来且时钟下降沿时，启动输出初始化 if(en) begindisoff

2013-04-28 09:26:14

三极管的知识点汇总，绝对实用

2022-02-15 06:23:44

串口通信的知识点汇总，错过绝对后悔

2021-12-13 06:28:01

串口通信的基础知识点汇总，不看肯定后悔

2021-12-03 06:47:54

关于MDK下C语言的基础知识汇总

MDK5的使用技巧有哪些？关于MDK下C语言的基础知识汇总

2022-02-25 06:47:47

关于汇编语言的知识点汇总，绝对实用

2022-01-18 07:32:53

基础知识汇总！！！

基础知识汇总！

2012-11-07 18:14:18

外部中断的知识点汇总，绝对实用

2022-01-21 07:39:15

多线程和多进程的区别

6.你的数据库一会又500个连接数，一会有10个，你分析一下情况7.udp和tcp的区别8.多线程和多进程的区别9.有一台web服务器，你选择用多线程还是多进程，...

2021-07-19 07:21:24

如何学习嵌入式系统基础知识

,编写串口通信程序，编写多串口通信程序。7、系统中多进程程序设计Linux系统进程概述：系统的进程特点，进程操作，守护进程，相关的系统调用了解Linux系统中进程的概念，能够编写多进程程序编写多进程

2017-09-13 11:04:17

如何学习嵌入式系统基础知识

不同shell的区别，编写一个测试服务器是否连通的shell脚本程序，编写一个查看进程是否存在的shell脚本程序，编写一个带有循环语句的shell脚本程序。3、Linux下的 C 编程基础linux

2017-09-13 10:53:41

学习python人工智能，需要了解的Linux系统进程知识大汇总！

学习Python人工智能时，需要了解Linux系统进程知识，以下是对Linux系统进程知识的汇总：当一个程序开始执行后，在开始执行到执行完毕退出这段时间内，它在内存中的部分就叫称作一个进程

2018-07-03 18:04:44

实验：编写多进程程序

1．实验目的通过编写多进程程序，使读者熟练掌握fork()、exec()、wait()和waitpid()等函数的使用，进一步理解在Linux中多进程编程的步骤。 2．实验内容该实验有3个进程

2013-09-05 15:32:09

文件管理的知识点汇总，错过绝对后悔

2021-12-23 06:31:59

机械臂运动学模型的知识点汇总，绝对实用

2022-01-20 06:53:26

浅析Windows多进程编程概念

进程的内核对象：即我们通常所讲的PCB（进程控制块），该结构只能由该内核访问，他是操作系统用来管理进程的一个数据结构，操作系统通过该数据结构来感知和管理进程；它的成员负责维护进程的各种信息，包括进程

2019-08-05 07:17:11

浅谈多进程多线程的选择

鱼还是熊掌：浅谈多进程多线程的选择关于多进程和多线程，教科书上最经典的一句话是“进程是资源分配的最小单位，线程是CPU调度的最小单位”，这句话应付考试基本上够了，但如果在工作中遇到类似的选择

2021-08-24 07:38:57

物联网设计与开发的知识点汇总，绝对实用

2022-01-18 06:43:07

红外对管模块的知识点汇总，绝对实用

2022-01-18 07:33:33

聊一聊如何在仿真中如何“多进程”时间管理

绕不开的多进程仿真忆往昔写Verilog与SystemVerilog时，在仿真过程中，不可避免的会出现多进程并发的情况，在构建仿真架构时，总是少不了这几个语法的出现:fork-join:等待所有

2022-06-29 16:11:44

脉冲按键99计数的知识点汇总，绝对实用

2022-01-24 07:00:29

跪求LabVIEW多进程问题，谢谢各位

进行处理。但是这样就不是多线程并行了，相当于几个站点是顺序执行的，就像读取数据时候就是先读第一个站点的数据放进第一个队列，再读第二个站点的数据放进第二个队列......这样，我想这样点多了会死机的吧，或是来不及读取串口或者TCP中数据这样的。请大家帮忙看看。能不能给提供一个多进程并行的思路？谢谢了

2013-04-04 16:34:04

通用同步异步收发器USRAT的知识点汇总，错过绝对后悔

2021-12-09 06:21:48

LINUX系统下多线程与多进程性能分析

采用多进程处理多个任务，会占用很多系统资源（主要是CPU 和内存的使用）。在LINUX 中，则对这种弊端进行了改进，在用户态实现了多线程处理多任务。本文系统论述了多线程间

2009-08-13 08:31:15

超经典常识知识汇总大全

2010-08-10 14:14:55

UNIX环境高级编程_第二版中文

LInux系统编程。包括网络编程，套接字等，以及多进程多线程

2017-01-23 20:25:34

在Zynq SoC上实现双核非对称的多进程处理模式

在我的上一篇博客中我介绍了利用Zynq SoC上的两个ARM Cortex-A9 MPCore处理器执行不同的任务程序，实现非对称的多进程处理模式的概念。

2017-02-11 10:08:38

1898

裸机AMP(非对称多进程处理模式)

在上一篇博客中，我们已经将Zynq SoC启动并运行起来，在AMP（非对称多进程处理）模式下使用了两个ARM Cortex-A9 MPCore处理器，然而因为上一篇博客已经相当长了，我没有详细的介绍软件方面的工程细节。

2017-02-11 10:18:10

3061

电气工程基础知识汇总

知识汇总

2017-02-27 16:06:01

进程控制开发之编写多进程程序实验解析

7.4.1 编写多进程程序 1．实验目的通过编写多进程程序，使读者熟练掌握fork（）、exec（）、wait（）和waitpid（）等函数的使用，进一步理解在Linux中多进程编程的步骤。 2．

2017-10-18 16:33:02

什么是多线程编程?多线程编程基础知识

摘要：多线程编程是现代软件技术中很重要的一个环节。要弄懂多线程，这就要牵涉到多进程。本文主要以多线程编程以及多线程编程相关知识而做出的一些结论。

2017-12-08 16:30:08

11929

异步多进程时间自动机的可覆盖性问题

已有的实时系统模型无法动态创建新进程．为此，基于时间自动机模型，提出了异步多进程时间自动机模型，将每个进程抽象为进程时间自动机，其部分状态能够触发新进程，考虑到队列会导致模型图灵完备，进程都被缓存

2017-12-29 14:10:10

C++学习中易错易混点知识汇总

2018-04-27 09:48:37

如何选好多线程和多进程

关于多进程和多线程，教科书上最经典的一句话是“进程是资源分配的最小单位，线程是CPU调度的最小单位”，这句话应付考试基本上够了，但如果在工作中遇到类似的选择问题，那就没有这么简单了，选的不好，会让你深受其害。

2018-05-11 16:16:00

2754

使用 GDB 调试多进程程序

GDB 是 linux 系统上常用的 c/c++ 调试工具，功能十分强大。对于较为复杂的系统，比如多进程系统，如何使用 GDB 调试呢？考虑下面这个三进程系统：进程Proc2

2019-04-02 14:33:23

439

多进程与多线程的深度比较

扩展到多机分布的用进程，多核分布的用线程。5）都满足需求的情况下，用你最熟悉、最拿手的方式。至于”数据共享、同步“、“编程、调试”、“可靠性”这几个维度的所谓的“复杂、简单”应该怎么取舍，只能说：没有明确的选择方法。一般有一个选择原则：如果多进程和多线程都能够满足要求，那么选择你最熟悉、最拿手的那个。

2019-04-02 14:42:58

352