【进程间通信 之 通信的建立】

已于 2024-05-30 17:39:52 修改
阅读量515 收藏 8
点赞数 18
分类专栏： Linux 文章标签： c++ c语言 linux
于 2023-05-10 23:49:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66363962/article/details/130198649
版权

目录：

前言

打怪升级：第69天
在这里插入图片描述

进程间通信的目的

数据传输：一个进程需要将它的数据发送给另一个进程
资源共享：多个进程之间共享同样的资源。
通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

进程间通信的方式

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

该部分内容来源：进程间通讯的7种方式

本文主要讲解管道、命名管道以及共享内存三个部分，希望可以给朋友们提供帮助。

管道

1.匿名管道

管道，通常指匿名管道，是 UNIX 系统IPC最古老的形式，下文中所说的管道和匿名管道是同一个，都是管道。
它可以在两个相关联的进程之间创建一个管道（Pipe），进程可以通过管道进行单向通信。

在 pipe 中，数据是按照字节流的形式传输的，即发送进程将数据写入管道的一端，接收进程从管道的另一端读取数据。管道可以看作是一条单向的、先进先出（FIFO）的队列，进程可以在队列的两端进行操作：写入数据的进程称为管道的写入端，读取数据的进程称为管道的读取端。

  • 命令

在这里插入图片描述
在这里插入图片描述
指令含义：查看我们当前所在路径，并将路径信息通过 管道 传递给 wc 指令，统计行数。

管道，可以给多个指令建立联系，使得多个指令可以进行数据传输，
上方的指令我想大家都是用过的，那么下面我们就来了解一下在语言层面通过系统调用建立匿名管道的方法。

  • 系统调用
    在这里插入图片描述
    管道也称为匿名管道，创建匿名管道的方法就是使用系统调用 pipe，参数很简单 ：一个整形数组，或者说一个整形指针。
    函数的声明提示我们 pipefd数组有两个元素，其中这两个元素是两个fd（文件描述符），其中pipefd[0]表示读端，pipefd[1]表示写端。
    从这里我们就可以看出：管道是属于文件系统的，那么我们有了文件描述符，之后的操作就和对文件的操作一样。

简单示例1 - 消息传输

使用 pipe 进行进程间通信的步骤如下：

  1. 调用 pipe 函数创建一个管道，并返回两个文件描述符：一个用于读取数据，一个用于写入数据。
  2. 创建一个子进程，它可以通过继承父进程的文件描述符来访问管道。
  3. 在父进程中关闭管道的读取端（如果不需要读取数据）或关闭管道的写入端（如果不需要写入数据）。
  4. 在父进程和子进程中分别使用管道的读取端和写入端进行通信。
  5. 在通信完成后，关闭管道的另一端以释放资源。
    下面是一个简单的示例程序，展示了如何使用 pipe 进行进程间通信：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include<cstring>
int main()
{
    int fd[2];
    pid_t pid;

    if (pipe(fd) < 0) 
    {
        perror("pipe error");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid < 0) 
    {
        perror("fork error");
        exit(EXIT_FAILURE);
    } 
    else if (pid == 0) /* 子进程 */
    { 
        close(fd[0]); /* 关闭管道的读取端 */
        const char* ptrs= "Hello, parent!";
        write(fd[1], ptrs, strlen(ptrs)); /* 向管道写入数据 */
        close(fd[1]); /* 关闭管道的写入端 */
        exit(EXIT_SUCCESS);
    } 
    else /* 父进程 */
    { 
        char buffer[1024];
        close(fd[1]); /* 关闭管道的写入端 */
        read(fd[0], buffer, sizeof(buffer)); /* 从管道读取数据 */
        printf("Message from child: %s\n", buffer);
        close(fd[0]); /* 关闭管道的读取端 */
        exit(EXIT_SUCCESS);
    }
}

运行结果：
这里是引用

在这里插入图片描述

上述程序创建了一个管道，然后创建了一个子进程。在子进程中向管道写入一条消息，并在父进程中读取该消息并打印输出。值得注意的是，在使用管道进行通信时需要注意错误处理、关闭文件描述符等问题，以免出现资源泄漏或其他错误。

五个特性

  1. 单向通信 – 一种特殊的半双工 – 一方只能写，一方只能读
  2. 管道本质上是文件，因为文件的生命周期随进程，所以管道的生命周期随进程
  3. 管道只能用于具有血缘关系的进程间的通信 – 父子、兄弟 – 管道继承
  4. 在管道通信中，读取的次数与写入的次数不是严格匹配的，读写次数没有强相关 – 字节流
  5. 具有一定的协同能力，使 read 和 write 能够按照一定的步骤进行通信 – 同步与互斥
  6. 当要写入的数据不大于PIPE_BUF时，Linux将保证写入的原子性。

注：管道一般专指匿名管道，匿名管道只能用于具有血缘关系间的进程通信；
下方我们会遇到 FIFO，一般称它为 命名管道，可以实现两个不相关进程间的通信。

四种场景

  1. read 快于 write：如果我们读取完毕管道中的数据，如果对方不发，我们会进行等待；
  2. write 快于 read：read会一次读取write多次写入的数据，如果管道写满就不能写入；
  3. 关闭管道的read：OS判定write后面的写入无效，OS不会容忍低效率、无意义的事情占用CPU资源，会杀死write的进程 – 信号13:SIGPIPE；
  4. 关闭管道的write：read读取完管道中的数据，再次读取取得数据为0，退出。

简单示例2 - 进程控制

一个父进程同时对多个子进程发布任务。

  • mypipe.hpp
#include<iostream>
using namespace std;
#include<vector>

struct Person
{
  int _wfd; // 写文件描述符
  int _cid;  // 子进程id
};

void PrintLog()
{
  cout << "我正在执行打印日志的任务..." << endl;
}
void LoadVideo()
{
  cout << "我正在执行加载视频的任务..." << endl;
}
void WaitNetwork()
{
  cout << "我正在等待网络资源" << endl;
}                                                                          


typedef void(*FUNC)(); // 定义一个函数指针类型

class Task
{
  public:
  
    Task()
     {
      _taskArr.push_back(PrintLog);
      _taskArr.push_back(LoadVideo);
      _taskArr.push_back(WaitNetwork);
     }

  public:
   vector<FUNC> _taskArr; // 任务列表
};

  
  void Menu()
  {
    cout << "***********************" << endl;
    cout << "*1.打印日志 2.加载视频*" << endl;
    cout << "*3.等待网络 0.退出    *" << endl;                               
    cout << "***********************" << endl;
  }
  • test.cc
  #include"mypipe.hpp"
  #include<cstdlib>
  #include<cassert>
  #include<sys/types.h>
  #include<sys/wait.h>
  #include<unistd.h>
  
  const int cpCnt = 5; // 创建子进程个数
  
  void GetCommend(Task task)
  {
    while(true)
    {
      int commend;
      ssize_t rCnt = read(0, &commend, sizeof(commend));
      if(rCnt != sizeof(int) || commend == 0) break; // 读取到的应该是一个整数并且收到执行任务的指令
      cout << "我是子进程,我的pid是:" << getpid() <<", ";
      
      task._taskArr[commend-1]();
    }
 }
  
  void CtrlProess(Person* p, const Task task)
  {
    int commend;
    int i=0;
    do
    {
      Menu();
      cin >> commend;
      if(commend < 0 || commend > task._taskArr.size()) continue; // 保证选项合理
      write(p[i]._wfd, &commend, sizeof(commend));
      i = (i + 1) % cpCnt; // 各个子进程依次执行任务
      sleep(1);
      } while(commend);
      cout << "父进程退出" << endl;
  }                                                                          
  
  void Creat(Person* p, const Task& task)
  {
    for(int i=0; i<cpCnt; ++i)
    {
       // 创建管道
      int pipe_fd[2];
      assert(pipe(pipe_fd) != -1);
      //创建子进程
      pid_t id = fork();
      assert(id != -1);
  
      if(id == 0) // child
      {
        // 关闭不需要的fd
        //close(pipe_fd[1]); // 无法形成干净的管道
        for(int i = pipe_fd[0]+1; i<=pipe_fd[1]; ++i)
         close(i); // 如果有疑问可以分别画出子进程1,2,3的files结构体

        dup2(pipe_fd[0], 0); // 将文件标准输入重定向到该管道
        // 读取执行
        GetCommend(task);
        // 子进程退出
        close(pipe_fd[0]);
        exit(0);
      }
  
      // parent                                                              
    //关闭不需要的fd
      close(pipe_fd[0]);
      p[i]._wfd = pipe_fd[1];
      p[i]._cid = id;
    }
  }
  
  void WaitProc(Person* p)
  {
    for(int i=0; i<cpCnt; ++i)
    {
      close(p[i]._wfd);
      waitpid(p[i]._cid, nullptr, 0); // 等待子进程退出
    }
  
    cout << "等待子进程成功" << endl;
  }
  
// 一个父进程与多个子进程通过管道 -- 5 -- 父进程写 子进程读
  int main()
  {
    //创建管道与进程 -- 并且保存子进程与写文件信息
    Person p[cpCnt];
    Task task;
    Creat(p, task);
    //开始通信
    CtrlProess(p, task);
    // 关闭管道并且回收子进程资源
    WaitProc(p);
    return 0;
  }

对管道的深入理解

这里是引用

上方的代码我们可以不过多关注，但是有一个地方确是我们需要注意的：不需要的管道的关闭。
父进程同时管理多个子进程，按照我们的预期应该如上图所示，那么我们的代码是否可以达到我们的目的呢？

在这里插入图片描述

分析原因：在这里插入图片描述
我以为 vs 实际上
在这里插入图片描述

解决方法有三

  • 方案1

关闭写端 和 等待子进程分开来写，当我们关闭了所有写端后，子进程会从后往前一次退出并进入僵尸状态。
在这里插入图片描述

  • 方案2

我们可以从后往前倒着关闭匿名管道，这样类似于方案1.

在这里插入图片描述

  • 方案3

前两种方法虽说都可以达到我们的目的，但是，从根本上来说并没有达到所谓管道的条件 – 一方写来一方读
因此，我们可以在创建子进程的时候就将不必要存在的fd全部关闭掉，这样一来才能形成一个个干净的管道。
在这里插入图片描述

2.命名管道

对于匿名管道我们知道它只能用于具有血缘关系的进程直接通信，至于原因：因为它没有名字，除了一个家族内可以通过fd找到它，其他进程并不知道它的存在；
因此，为了实现毫不相干的进程之间的通信，我们有了FIFO，也称命名管道。
命名管道与管道的区别就是它拥有自己的名字，不同进程只要知道它的位置都可以找到它。

  • 指令

mkfifo filename
创建匿名管道，可以直接使用ls查看。
命名管道的删除可以使用 unlink命令，
同时，命名管道说到底还是文件，因此它的删除可以直接使用 rm。
在这里插入图片描述

  • 系统调用


参数一：命名管道路径名，创建文件的权限
这里就和文件类似，mode为八进制，分别为读、写、执行。

和管道不同的是：管道的生命周期是随进程的，但是命名管道我们可以提前手动创建与删除，OS不会自动帮我们回收，
因此，在使用完命名管道后我们需要手动删除它。
在这里插入图片描述
参数：文件路径

简单示例3 – 不相关进程间通信

  • msg.h // 存储一些公共信息
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<cassert>
#include<cstring>

#define LOG "fifo"
#define MODE 0666
#define NUM 1024
  • user.cc // 用户端输入
#include"msg.h"

int main()
{
 // 打开文件 -- 只写
 int wfd = open(LOG, O_WRONLY);
 assert(wfd != -1);
  // 写入数据
  while(true)
  {
    char inquire[NUM] = {0};
    cout << "请输入消息# ";
    fgets(inquire, sizeof(inquire), stdin);
    inquire[strlen(inquire)-1] = 0; // 删除最后一个的 \n
    if(strcasecmp(inquire, "quit") == 0)  break;
    // 发送消息
    write(wfd, inquire, strlen(inquire));
  }

  cout << "user quit success." << endl;
  close(wfd);
  return 0;
}
  • server.cc // 服务端回显
#include"msg.h"

// 两个不同进程间的通信
int main()
{
  // 1.1 创建命名管道
  umask(0);
  int fifoRet = mkfifo(LOG, MODE);  
  assert(fifoRet != -1);
  (void)fifoRet; // 防止由于fifoRet只定义未使用而报警告
  cout << "create fifo success" << endl;
  // 打开文件 -- 只读
  int rfd = open(LOG, O_RDONLY);
  assert(rfd != -1);
  //1.2 读取数据 -- 进行反馈
  cout << "open fifo success" << endl;
  while(true)
  {
    char buf[NUM] = {0};
    ssize_t rCnt = read(rfd, buf, NUM - 1);
    if(rCnt == 0)
    {
      cout << "user quit, me too." << endl;
       break;
    }

    cout << "user# " << buf << endl;
  }
  //2.2关闭写端
  close(rfd);
  // 2.2 删除命名管道 -- nulink
  assert(unlink(LOG)==0);
  return 0;
}

在这里插入图片描述
有很重要的一点需要我们注意：当server端启动后一开始只打印了“创建成功”，直到user端也启动后才打印出“打开成功”，
也就是说：当只有server端是server是无法单独打开 fifo的，这点和pipe一样：OS不允许任何无效或低效率的事情发生，因为管道是用来传输数据的，但是当只有读端或者写端时无法进行通信，因此OS会将该进程阻塞，直到有其他进程以另一种方式打开管道才会给它们分配CPU资源。

system V

system V通信的三种方式：
System V 消息队列
System V 共享内存
System V 信号量

  • 指令
  1. 查看IPC通信结构：ipcs
  2. 删除IPC通信结构：ipcrm -m/q/s id

这里是引用

共享内存

  • 系统调用
  1. 创建共享内存 -> shm – shared memory

在这里插入图片描述
参数一：随机key值 – 由ftok函数生成
参数二：共享内存大小
参数三：shm打开方式以及shm权限设置

参数三的常用选项：IPC_CREAT ， IPC_EXCL，IPC_RMID
IPC_CRETA：创建共享内存，如果存在（有相同的key）就使用已存在的，不存在就创建新的。
IPC_EXCL：创建共享内存时必须是新的，如果之前就存在就报错。（绝不将就）
ICP_RMID：根据共享内存的id号删除共享内存，在shmctl函数中使用。
返回值：创建成功返回 共享内存标识符 – shmid，创建失败返回-1.并且设置erron

在这里插入图片描述

ftok()函数使用给定路径名命名的文件的标识(它必须引用一个现有的、可访问的文件)

有效的8位proj_id(必须是非零的)来生成key_t类型的System V IPC密钥
简单说：文件名和proj_id 这两个参数都是可以随便给的，它们的作用就是生成一个新的key（类似于生成随机数）来唯一标识shm。
返回值：生成成功返回 key，生成失败返回-1并设置erron。

在这里插入图片描述

  • shmat：shm attach，触摸shm，和shm建立连接，返回值为shm的首地址，有了地址我们就可以将它当做数组来使用。
    参数一：shmid
    参数二：可以直接设为nullptr
    参数三：可以直接设为0
    shmat返回值：连接成功返回 shm地址 – shmaddr，失败返回-1，设置erron；

  • shmdt：shm detach ，脱离shm，与shm取消链接
    参数一：shm地址
    shmdt返回值：取消关联成功返回 0，失败返回-1，设置erron。

在这里插入图片描述
参数一：shmid
参数二：IPC_RMID ，删除shm
参数三：直接设为nullptr
返回值：删除成功返回0，失败返回-1并设置erron。

在这里插入图片描述
补充知识点：共享内存的映射在进程地址空间的共享区（堆栈之间），如果大家了解过动静态库的话就知道，动态库也是链接在这部分的。

简单示例4 - 通知事件+消息传输

  • server.cc

#include"msg.hpp"

int main()
{
    // 和shm建立联系
    Shm s(SERVER);
    // 使用FIFO控制读取
    // 打开读端
    int rfd = open(FIFONAME, O_RDONLY);
    // 开始通信
    int cnt = 10;
    while(cnt)
    {
        size_t rsize = read(rfd, &cnt, sizeof cnt);
        if(rsize == 4)
        {
            printf("user# %s\n", s._address);
        }
    }

  return 0;
}
  • user.cc
#include"msg.hpp"

int main()
{
    // 1. 和shm建立联系
    Shm s(USER);
    // 2. 使用FIFO通知server可以进行读取
    //2.1 创建fifo
    mkfifo(FIFONAME, MODE);
    // 打开写端
    int wfd = open(FIFONAME, O_WRONLY);
    // 3. 开始通信
    int cnt = 10;
    while(cnt--)
    {
        printf("输入: ");
        fflush(stdout);

        fscanf(stdin, "%[^\n]s", s._address); // 遇到非换行符字符全部读取 -- 也就是遇到换行符就结束
        getchar(); // 	“吃掉” 缓冲区中的换行符
        write(wfd, &cnt, sizeof cnt); // 每次录入信息后写入一个整数，通知server可以进行读取
    }

  return 0;
}
  • msg.hpp
#include<iostream>
using namespace std;
#include<cassert>
#include<cstring>
#include<string>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/shm.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>

#define SIZE 4096
#define LOG  "."
#define NUM 0x1234
#define MODE 0666
#define SERVER 0 // 服务标识
#define USER 1   // 用户标识
#define FIFONAME "f.fifo"
class Shm{

public:
    Shm(int name)
    :_name(name)
    {
        // 创建shm
        int key = GetKey();
        if(_name == SERVER)
            _shmid = CreateShm(key, SIZE);
        else
            _shmid = FindShm(key, SIZE);
        cout << "create shm success." << endl;
        // 建立连接
        _address = Attach(_shmid);
        cout << "attach shm success." << endl;
    }

    ~Shm()
    {
        //   取消链接
        Detach(_address);

        // server删除shm
        if(_name == SERVER)
        {
            DelShm(_shmid);
            cout << "free shm success." << endl;
        }
    }

    void ToHex(int n)
    {
        if(n)
        {
            ToHex(n / 16);
            cout << n % 16;
        }
    }

    int GetKey()
    {
        int key = ftok(LOG, NUM);
        assert(key != -1);
        return key;
    }

private:
    int GetShm(int key, int size, int cmd)
    {
        int shmid = shmget(key, size, cmd);
        assert(shmid != -1);
        return shmid;
    }

    //  创建共享内存 -- 返回shmid
    int CreateShm(int key, int size)
    {
        umask(0);
        return GetShm(key, size, IPC_CREAT | IPC_EXCL | MODE); // IPC_EXCL：我只要新的，否则我就报错
    }


    int FindShm(int key, int size) 
    {
         return GetShm(key, size, IPC_CREAT);  // 我用其他人的也可以
    }

    char* Attach(int shmid)
    {
        char* shmadd = (char*)shmat(shmid, nullptr, 0);
        return shmadd;
    }

    void Detach(char* shmadd)
    {
        assert(shmdt(shmadd) != -1);
    }

    void DelShm(int shmid)
    {
        assert(shmctl(shmid, IPC_RMID, nullptr) != -1);
    }

public:
    int _name;   // 用户区分
    int _shmid;  // shm标识
    char* _address; // shm地址

};

在这里插入图片描述

总结

在这里插入图片描述

  1. 匿名管道只能用于具有血缘关系的进程之间通信；
  2. 在命令行中通过管道连接的各个指令是兄弟关系，它们的父进程都为bash；
  3. 管道与命名管道都属于文件系统，数据缓冲区的大小随文件缓冲区，数据的流动只在文件缓冲区中进行；
  4. 命名管道的大小永远是0，文件中的数据不会刷新到磁盘（仅仅作为通信的中间体，没有必要保存数据）；
  5. 由于共享内存创建之后就不需要依赖于OS，因此消息传输是最快的，而同时，因为消息传输时不经过OS的控制，所以通信过程是不安全的 – 没有同步与互斥（两个用户同时进行写入，造成数据覆盖，信息丢失）。
  6. 两种管道如果只存在读端或者写端会被OS强制关闭，shm则不会。
  7. 内存中的数据是以块为单位存储的，一块的大小为 4KB（4096B），因此当我们申请4096B时OS会给我们分配4096B，
    但是如果我们申请4097B时OS就会给我们分配 2 * 4096B的空间，不过即使给我们分配了这么多，我们也只能使用4097B。
  8. 共享内存映射在进程地址空间的共享区。
胜利熊猫
关注
  • 18
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 20
    评论
专栏目录
进程间通信之管道
weixin_57023347的博客
09-14 3777
目录 前言 进程间通信的目的: 一.管道 1.1 匿名管道 1.1.1 匿名管道的使用场景 1.1.2 匿名管道实现通信的原理 1.1.3 怎么创建管道 1.1.4 怎么实现进程间通信 1.1.5 管道通信额四种情况 1.1.6 匿名管道的特征 1.2 命名管道 1.2.1 命名管道的原理 1.2.2 创...
进程间通信详解
向未来❀去探索 的博客
06-26 1万+
进程间通信详解(命名管道，匿名管道，共享内存)
【Linux】进程间通信
热门推荐
Edward_Asia的博客
05-02 1万+
目录 1. 进程间通信 1.1. 进程间通信的目的 1.2. 如何实现进程间通信 2. 管道通信 2.1. 匿名管道 2.1.1 创建匿名管道 2.1.2 . 深入理解匿名管道 2.2. 命名管道 2.2.1. 创建命名管道 3. system V 标准进程间通信 3.1. 共享内存 3.1.1. 实现原理 3.1.2. 代码实现 3.2. 消息队列(了解) 3.2.1 实现原理 3.3. 信号量(了解) 3.3.1. 实现原理 1. 进程间通信 1.1.
C++进程间通信 详解2
GIS摆渡人
05-24 3595
文章目录 一、概述二、进程间通信概念及方法1. 管道的概念2. pipe3. 管道的读写行为4. 管道缓冲区大小5. 管道优劣6. FIFO7. 共享存储映射8. mmap函数9. munmap函数10. mmap九问11. mmap父子进程间通信12. 匿名映射13. mmap无血缘关系进程间通信 3. 练习 一、概述 二、进程间通信概念及方法 Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和...
使用socket实现进程间通信
afootball的博客
12-16 4512
socket除了可以实现网络通信之外，还可以实现进程间通信，与网络通信一样，以一个服务端和一个客户端的方式存在 一、与网络通信上使用的不同之处 1.创建socket的过程
进程间通信
冯同学的博客
05-11 7217
了解进程间的通信方式，例如管道(匿名管道和命名管道)、共享内存、消息队列、信号量
进程间通信和线程间通信
feelinghappy的专栏
08-18 4388
进程间通信 转自 https://www.cnblogs.com/LUO77/p/5816326.html 线程间通信 https://www.cnblogs.com/jobs1/p/10784021.html 线程间通信 进程和线程的区别 程序只是一组指令的有序集合，它本身没有任何运行的含义，它只是一个静态的实体。而进程则不同，它是程序在某个数据集上的执行。进程是一个动态的实体，它有自己的生命周期。它因创建而产生，因调度而运行，因等待资源或事件而被处于等待状态，因完成任务而被撤消。反映...
进程间通信&线程间通信
渣渣
07-26 2303
一、多进程： 首先，先来讲一下fork之后，发生了什么事情。 由fork创建的新进程被称为子进程（child process）。该函数被调用一次，但返回两次。两次返回的区别是子进程的返回值是0，而父进程的返回值则是新进程（子进程）的进程 id。将子进程id返回给父进程的理由是：因为一个进程的子进程可以多于一个，没有一个函数使一个进程可以获得其所有子进程的进程id。对子进程来说，之所以fork返回0给它，是因为它随时可以调用getpid()来获取自己的pid；也可以调用getppid()来获取父进程的id
进程间通信和线程间通信总结
小小默：进无止境
02-16 1万+
写在前面 面试的时候一定不要疲劳战，比如上午面了一个，然后中午不休息直接赶到另外一个相距比较远的公司，影响状态。 面试的时候一定不要紧张，不管对方有几个人，总之面试的时候做好充分准备，休息好，放松心态。 好了，言归正传，开始总结。 【1】进程间通信方式 进程间通信又称IPC(Inter-Process Communication),指多个进程之间相互通信，交换信息的方法。根据进程通信时信息量大小的...
3.1 多进程：进程间通信
酒心★
12-05 1791
多进程之间不共享数据，但共享同一套文件系统，像访问同一个文件、同一终端打印，如果不进行同步操作，就会出现错乱的现象。 所有在 threading 存在的同步方式，multiprocessing 中都有类似的等价物，如：锁(lock,RLock)、信号量Semaphore,Event（事件）Condition,Barrier等。
Android之Binder与进程间通信
01-31
Binder机制是android中实现的进程间通信的架构，它采用的是c/s架构，client通过代理完成对server的调用。既然这里提到了server，那么我们有必要先了解下在android中是怎么来管理server的。先来看一个重要的Native...
NngTEST.tar.gz NNG进程间通信，简单的Doem 分析
01-11
《NngTEST.tar.gz：NNG进程间通信与Doem示例详解》 NngTEST.tar.gz 是一个包含了NNG（Not Only NATS）库在进程间通信中的应用实例的压缩包。NNG是一个轻量级的消息传递库，旨在提供简单、高效的网络通信能力，支持...
Pipo 的 QT socket的进程间通信
03-13
在QT中，Socket通信是实现进程间通信（IPC, Inter-Process Communication）的一种常见方式，特别是对于Pipo这样的项目，可能涉及到多个进程之间的数据交换。下面将详细介绍QT中的Socket通信以及如何实现进程间通信。...
四种进程间通信的方式demo
12-14
在Android系统中，进程间通信（Inter-Process Communication, 简称IPC）是应用程序之间交换数据的关键技术。本文将详细解析标题“四种进程间通信的方式demo”所涵盖的四个主要方法：Activity、Service与AIDL、...
【C++】STL—vector的使用
2301_77112794的博客
09-04 715
本文介绍了vector重点函数接口的使用
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 515
C语言 | Leetcode C语言题解之第389题找不同
C语言——strcpy、sprintf与memcpy
最新发布
鲸落博客
09-09 909
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C语言作用域
天道酬勤
09-07 965
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
QWidget(c++)嵌入window环境的exe
sunflower_2020的博客
09-05 289
QWidget(c++)嵌入window环境的exe
评论 20
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值