[Linux]进程间通信

Linux——进程间通信 之前写的代码都是单进程的。是无法使用并发能力,并且无法实现多进程协同传输数据,同步执行流,消息通知等进程间通信不是目的,而是一种手段。进程间通信的技术背景进程是具有独立性的。虚拟地址空间+页表。保证进程运行的独立性(进程内核数据结构+进程的代码和数据)通信成本比较高。如何理解进程间通信?进程运行具有独立性!——进程想通信,难度比较大——进程间通信的本质:需要中间媒介,先让不同的进程看到同一份资源(内存空间)所谓的进程看到同一块“内存”,属于哪一个进程? 阅读详情

[Linux]进程间通信

进程间通信
什么是进程间通信

进程之间具有独立性,如果需要进行通信,就必须打破进程间的独立性。进程通信需要提供一块公共的能够进行信息存储和取出的空间。文件系统提供的我们称为管道,操作系统提供的System V。

进程间通信的目的
  1. 数据传输:一个进程将数据发送给另一个进程。
  2. 资源共享:多个进程共享相同的资源。
  3. 事件通知:一个进程需要向另一个或一组进程发送消息。通知它们发生了某种事件,例如子进程终止时需要通知父进程。
  4. 进程控制:有的进程希望完全控制另一个进程的执行,例如Debug进程。
进程间通信的本质

进程间通信的本质就是让不同的进程看到同一份资源。

实际上就是构建一个公共区域,供不同进程进行写入或读取数据。

image-20230727104753581

为什么存在进程间通信

实际情况中,有时候我们需要多进程协作完成某种业务。

进程间通信的分类
  1. 管道
  • 匿名管道
  • 命名管道
  1. System V
  • System V消息队列
  • System V信号量
  • System V共享内存
  1. POSIX
  • 共享内存
  • 信号量
  • 消息队列
  • 互斥量
  • 条件变量
  • 读写锁
管道
什么是管道
  • 管道是Unix中最古老的进程间通信的形式。
  • 我们把从一个进程连接到另一个进程的数据流称为一个“管道”。

其实我们早在之前命令中的学习就已经见过了管道|,我们也经常使用管道命令。

例如,查看服务器连接人数:

[---@VM-8-4-centos day04]$ who | wc -l

image-20230727110434843

在这里插入图片描述

匿名管道
本质

匿名管道主要用于父子间的通信。它本质上就是让父子进程看到同一个被打开的文件,然后让父子进程进行写入或读取数据,从而实现父子间的通信。

这里的文件是由操作系统提供的,所以在父进程或子进程写入数据时,并不会发生写时拷贝。

pipe
int pipe(int pipefd[2]);
  • 头文件:#include<unistd.h>
  • pidfd是一个输出型参数,pipfd[0]:管道读端的文件描述符;pipfd[1]:管道写端的文件描述符。
  • 返回值:调用成功,返回0;调用失败,返回-1。
pipe的使用

实际上,我们需要对一对父子进程关闭相反的两个端口来使用匿名管道进行通信。

  • 需要父进程读,则关闭父进程的写端和关闭子进程的读端。
  • 需要父进程写,则关闭父进程的读端和关闭子进程的写端。

例如,父进程关闭写端,子进程关闭读端。

#include <iostream>
#include <unistd.h>
#include <cstdlib>
#include <cstring>

#include <sys/types.h>
#include <sys/wait.h>
using namespace std;

int main()
{
    int fd[2] = {0};
    int n = pipe(fd);
    if (n != 0)
        perror("pipe fail");
    pid_t id = fork();
    int cnt = 0;
    const char *str = "I am a child process. MYPID->";
    if (id > 0)
    {
        close(fd[1]); // 父进程关闭写端
        while (1)
        {
            char buffer[1024];
            ssize_t r = read(fd[0], buffer, sizeof(buffer) - 1);
            if (r > 0)
            {
                buffer[r] = '\0';
                cout << "parent process get message-> " << buffer << endl;
            }
            else if (r == 0)
            {
                // 读完了
                cout << endl;
                cout << "数据读取完毕!!!" << endl;
                break;
            }
            else
            {
                perror("read fail");
                return -1;
            }
        }
        int wp = waitpid(-1, nullptr, 0);
        close(fd[0]);
        return 0;
    }
    else if (id == 0)
    {
        close(fd[0]); // 子进程关闭读端
        while (1)
        {
            char buffer[1024];
            snprintf(buffer, sizeof(buffer), "Message: %s%d, count: %d", str, getpid(), cnt++);
            write(fd[1], buffer, strlen(buffer));
            sleep(1); // 每隔1秒写入一次
            if (cnt == 6)
                break;
        }
        close(fd[1]);
        exit(0);
    }
    else
    {
        perror("fork fail");
        return -1;
    }
    return 0;
}

在这里插入图片描述

匿名管道读写情况
  1. 如果管道中没有数据,读端进行读取,就会阻塞当前读取的进程
  2. 如果写端写满了,写端还进行写入,就会阻塞当前写端的进程
  3. 如果写端关闭了,读端读完数据后就会返回0,正常退出
  4. 如果读端关闭了,操作系统会向写端发送13号信号SIGPIPE,从而让写端关闭
匿名管道的特征
  1. 匿名管道是半双工通信的。
  • 单工通信:数据传输在通信双方是单向的,一方为固定发送端,另一方为固定接收端。
  • 半双工通信:数据传输在通信双方是双向的,但不能同时发送数据。
  • 全双工通信:数据传输在通信双方是双向的,允许同时发送数据。
  1. 管道的生命周期随进程,进程退出,则管道释放。
  • 管道的本质是通过一个文件进行通信的,当打开这个文件的进程退出后,这个文件也会被释放掉。
  1. 管道提供的是流式服务。
  • 对于写端写入的数据,读端读取的数据是任意的,这就是流式服务。
  • 对于写端写入的数据,读端读取时根据数据的分割(按一定的报文段)读取,这就是与流式服务相对的数据报服务。
  1. 内核对管道操作会进行同步和互斥。
  • 同步:在特定的时间点或条件下,不同进程之间的操作按照一定的顺序和速度进行,以保证它们之间的状态和行为达到预期的一致性。
  • 互斥:一个公共资源同一时刻只能被一个进程使用,多个进程不能同时使用公共资源。

对于管道来说,同步就是指这两个进程不能同时对管道进行操作,但这两个进程必须要按照某种次序来对管道进行操作;互斥就是两个进程不可以同时对管道进行操作,它们会相互排斥,必须等一个进程操作完毕,另一个才能操作。

ps:管道的最大容量一般是65536字。

我们也可以通过以下命令查看:

[---@VM-8-4-centos day04]$ ulimit -a

image-20230727210011484

命名管道

匿名管道通常只能用于父子进程间的通信,为了让不具有亲缘关系的进程相互通信,由此有了命名管道。

本质

通过创建一个特殊的文件,让两个进程看到同一份资源,从而实现通信。

匿名管道和命名管道都是内存文件,但是命名管道在磁盘上有一个特殊的映像。(大小为0,因为命名管道和匿名管道都不会刷新到磁盘上)

命令行创建命名管道
[---@VM-8-4-centos day04]$ mkfifo named_pipe

image-20230727211628264

我们可以从第一个p看到出,这个文件类型是管道文件,管道文件大小默认是0。

此时我们已经可以进行通信了,我们使用两个不同的命令行进行通信测试:

image-20230727212134864

如果我们不进行读取,写端就会阻塞等待读端读取。

创建和删除命名管道
int mkfifo(const char *pathname, mode_t mode);
  • pathname:命名管道创建路径,若给出文件名,则创建在当前路径下;若给出路径,按路径创建

  • mode:管道文件默认权限

  • 返回值:创建成功,返回0;创建失败,返回-1。

image-20230727214411219

image-20230727214428861

int main()
{
    umask(0);
    int n = mkfifo("named_pipe", 0666);
    if(n < 0) perror("mkfifo fail");
    //创建成功
    cout << "mkfifo success..." << endl;
    return 0;
}

image-20230727215445358

int unlink(const char *path)
  • path:管道路径
  • 返回值,创建成功,返回0;创建失败,返回-1

image-20230728104124115

image-20230728104145636

int main()
{
    int n = unlink("./named_pipe");
    if(n == -1) 
    {
        perror("unlink fail");
        return -1;
    }
    cout << "unlink success ......." << endl;
    return 0;
}

image-20230728104530341

实现服务端与客户端通信

com.hpp

#pragma once
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>

using namespace std;

bool create_named_pipe()
{
    umask(0);
    int n = mkfifo("./named_pipe", 0600); // 创建管道文件
    if (n != 0)
    {
        perror("mkfifo fail");
        return false;
    }

    cout << "mkfifo success ......" << endl;
    return true;
}

void unlink_named_pipe()
{
    int n = unlink("./named_pipe");
    if (n != 0)
        perror("unlink fail");

    cout << "unlink success ......" << endl;
}

serve.cc

#include "com.hpp"

int main()
{
    bool flag = create_named_pipe();
    if (flag == false)
    {
        perror("create_named_pipe fail");
        exit(-1);
    }
    int fd = open("./named_pipe", O_RDONLY);
    if (fd < 0)
        perror("open fail");

    char buffer[1024];
    while (1)
    {
        ssize_t r = read(fd, buffer, sizeof(buffer) - 1);
        if (r > 0)
        {
            buffer[r] = '\0';
            cout << "serve get message -> " << buffer << endl;
        }
        else if (r == 0)
        {
            cout << "read end ......" << endl;
            break;
        }
        else
        {
            perror("read fail");
            return -1;
        }
    }
    close(fd);
    unlink_named_pipe();
    return 0;
}

client.cc

#include "com.hpp"

int main()
{
    int fd = open("./named_pipe", O_WRONLY);
    if (fd < 0)
        perror("open fail");

    char buffer[1024];
    while(1)
    {
        cout << "client Enter # ";
        fgets(buffer, sizeof(buffer), stdin);//fgets剩一个空间会被系统填充'\0',不用-1
        ssize_t w = write(fd, buffer, strlen(buffer));
        if(w != strlen(buffer))
        {
            perror("write fail");
            exit(-1);
        }
    }
    close(fd);
    return 0;
}

image-20230728224245270

另外一提,命令行中的管道|是匿名管道。

System V

之前我们提到过System V通信方式有:System V共享内存、System V消息队列、System V信号量,下面我们就着重说说System V共享内存。

system V共享内存
共享内存的原理

用户使用操作系统提供的接口在物理内存中申请一块资源,通过页表将这段物理空间映射至进程地址空间,进程将这段虚拟地址的起始地址返回给用户。

image-20230728110710348

操作系统中的进程都可以通过共享内存进行通信,一个操作系统可以有多个共享内存。

共享内存不止一个,操作系统必然对这些共享内存也要进行管理,系统也为他维护了一个数据结构:

struct shmid_ds {
	struct ipc_perm     shm_perm;   /* operation perms */
	int         shm_segsz;  /* size of segment (bytes) */
	__kernel_time_t     shm_atime;  /* last attach time */
	__kernel_time_t     shm_dtime;  /* last detach time */
	__kernel_time_t     shm_ctime;  /* last change time */
	__kernel_ipc_pid_t  shm_cpid;   /* pid of creator */
	__kernel_ipc_pid_t  shm_lpid;   /* pid of last operator */
	unsigned short      shm_nattch; /* no. of current attaches */
	unsigned short      shm_unused; /* compatibility */
	void            *shm_unused2;   /* ditto - used by DIPC */
	void            *shm_unused3;   /* unused */
};

第一个成员shm_perm的类型ipc_perm结构是这样的。(key也存在shm_perm中)

struct ipc_perm{
	__kernel_key_t  key;
	__kernel_uid_t  uid;
	__kernel_gid_t  gid;
	__kernel_uid_t  cuid;
	__kernel_gid_t  cgid;
	__kernel_mode_t mode;
	unsigned short  seq;
};
IPC资源的查看

我们使用以下命名,可以查看系统中的IPC资源:

[---@VM-8-4-centos day05]$ ipcs

在这里插入图片描述

ipcs这个命令还有3个选项,分别来查看共享内存、消息队列和信号量。

  • -q:仅显示消息队列的信息
  • -m:仅显示共享内存的信息
  • -a:仅显示信号量的信息
共享内存的创建和释放
key_t ftok(const char *pathname, int proj_id);
  • 作用:将一个存在且可获取的路径名pathname和一个整数标识符proj_id转换成一个key值,称为IPC键值,方便共享内存创建唯一标识。
  • 返回值:创建成功,返回key值;创建失败,返回-1。

image-20230728112857273

image-20230728112914784

int shmget(key_t key, size_t size, int shmflg);
  • key:形成唯一标识,保证进程看到的是同一块共享内存。(使用ftok获取)
  • size:创建共享内存的大小。
  • shmflg:共享内存的创建方式。IPC_CREAT:共享内存不存在,则创建,如果存在则获取;IPC_EXCL:无法单独使用,IPC_CREAT|IPC_EXCL:如果不存在就创建,如果存在就出错返回。(记得设置权限0666等,例如IPC_CREAT | IPC_EXCL | 0666)
  • 返回值:创建成功,返回共享内存标识符;创建失败,返回-1。

image-20230728113015896
image-20230728113106487

#include <iostream>
#include <sys/types.h> 
#include <sys/ipc.h> 
#include <sys/shm.h> 
#include <unistd.h>

using namespace std;

int main()
{
    key_t key = ftok("./makefile", 0x6666);
    if(key < 0) 
    {
        perror("ftok fail");
        return -1;
    }
    int shm = shmget(key, 4096, IPC_CREAT | IPC_EXCL);
    if(shm < 0)
    {
        perror("shmget fail");
        return -2;
    }
    cout << key << endl << shm << endl;
    return 0;
}

image-20230728112809018

我们使用ipcs命令来看一下,我们是否创建成功:

在这里插入图片描述


int shmctl(int shmid, int cmd, struct shmid_ds *buf);
  • shmid:表示所控制共享内存的用户级标识符。
  • cmd:表示具体的控制动作。IPC_RMID最为常用,表示删除共享内存。
  • buf:用于获取或设置所控制共享内存的数据结构。一般设置为nullptr
  • 返回值:调用成功,返回0;调用失败。返回-1。

image-20230728113720899

image-20230728113747665

int main()
{
    key_t key = ftok("./makefile", 0x6666);
    if (key < 0)
    {
        perror("ftok fail");
        return -1;
    }
    int shm = shmget(key, 4096, IPC_CREAT | IPC_EXCL);
    if (shm < 0)
    {
        perror("shmget fail");
        return -2;
    }
    cout << key << endl << shm << endl;
    cout << "create success..." << endl;
    sleep(3);
    int ctl = shmctl(shm, IPC_RMID, nullptr);
    if(ctl < 0)
    {
        perror("shmctl fail");
        return -3;
    }
    cout << "delete success..." <<endl;
    return 0;
}

我们创建一块共享内存,让程序休眠3秒。休眠后,删除这块共享内存。(我们可以看见其中有3行打印了这块共享内存,第4行就没有了,这也证明了我们代码的逻辑是正确的)

右边命令行使用以下的监控脚本:

[wsj@VM-8-4-centos day05]$ while :; do ipcs -m;echo "###################################";sleep 1;done

image-20230728180549070


我们也可以使用命令行来删除共享内存:

[wsj@VM-8-4-centos day05]$ ipcrm -m 6(数字代表自己共享内存的shm)

image-20230728181119102

共享内存的关联和去关联
void *shmat(int shmid, const void *shmaddr, int shmflg);
  • shmid:待关联的共享内存标识符
  • shmaddr:指定共享内存映射到进程地址空间中的某一地址,一般设置nullptr让内核自己选择。
  • shmflg:SHM_RDONLY,表示关联共享内存后,仅进行读取操作;SHM_RND,表示如果shmaddr不为空,则自动向下调整为SHMLBA的整数倍;0,默认为读写权限。
  • 返回值:调用成功,返回映射到进程地址空间的共享内存的地址;调用失败,返回(void*)-1。
int shmdt(const void *shmaddr);
  • shmaddr:待去关联的共享内存,使用shmat得到的地址。

  • 返回值,调用成功,返回0;调用失败,返回-1。

接下来,我们使用一段代码加深一下对这些接口调用的理解:

int main()
{
    key_t key = ftok("./makefile", 0x6666);
    if (key < 0)
    {
        perror("ftok fail");
        return -1;
    }
    int shm = shmget(key, 4096, IPC_CREAT | IPC_EXCL | 0666);
    if (shm < 0)
    {
        perror("shmget fail");
        return -2;
    }
    cout << "create success..." << endl;
    cout << "-----------------------" << endl;

    void* mem = shmat(shm, nullptr, 0);
    if(mem == (void*)-1)
    {
        perror("shmat fail");
        return -3;
    }
    cout << "attach success..." << endl;
    cout << "-----------------------" << endl;
    int dt = shmdt(mem);
    if(dt < 0)
    {
        perror("shmdt fail");
        return -4;
    }
    cout << "detach success ..." << endl;
    cout << "-----------------------" << endl;
    int ctl = shmctl(shm, IPC_RMID, nullptr);
    if(ctl < 0)
    {
        perror("shmctl fail");
        return -5;
    }
    cout << "delete success..." << endl;
    return 0;
}

右边的命令行,任然使用上面的监控脚本。

我们从共享内存,从无到有;从关联数,从0到1,再到0。证明我们代码的逻辑是正确的。(创建共享内存->关联该共享内存->去关联该共享内存->删除共享内存)

image-20230728184614542

ps:创建共享内存时需要设置权限,不然就无法正常关联。

image-20230728185006918

实现服务端与客户端通信

com.hpp

#include <iostream>
#include <cstdio>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>

using namespace std;

#define PATH "./makefile"
#define PROJ_ID 0X888
#define MAX_SIZE 4096

key_t getKey() // 获取key值
{
    key_t key = ftok(PATH, PROJ_ID);
    if (key == -1)
    {
        perror("ftok fail");
        exit(-1);
    }
    return key;
}

int getShm(key_t key, int flag) // 创建共享内存,为下面两个函数服务
{
    int shm = shmget(key, MAX_SIZE, flag);
    if (shm < 0)
    {
        perror("shmget fail");
        exit(-2);
    }
    return shm;
}

int shmHelper(key_t key) // 获取共享内存(已创建的前提)
{
    return getShm(key, IPC_CREAT);
}

int createShm(key_t key) // 创建共享内存
{
    return getShm(key, IPC_CREAT | IPC_EXCL | 0666);
}

void *attachShm(int shm) // 关联
{
    void *mem = shmat(shm, nullptr, 0);
    if (mem == (void *)-1)
    {
        perror("shmat fail");
        exit(-3);
    }
    return mem;
}

void detachShm(void *mem) // 去关联
{
    if (shmdt(mem) < 0)
    {
        perror("shmdt fail");
        exit(-4);
    }
}

int deleteShm(int shm) // 删除共享内存
{
    if (shmctl(shm, IPC_RMID, nullptr) < 0)
    {
        perror("shmctl fail");
        exit(-5);
    }
}

serve.cc

#include "com.hpp"

int main()
{
    int key = getKey();
    int shm = createShm(key);
    cout << shm << endl;
    void *mem = attachShm(shm);
    cout << mem << endl;
    int cnt = 0;
    while (cnt++ < 10)
    {
        printf("client # %s\n", mem);
        struct shmid_ds ds;
        shmctl(shm,IPC_STAT,&ds);
        cout << "PID->" << getpid() << ", creator->" << ds.shm_cpid << ", key->" << ds.shm_perm.__key << endl;
        sleep(1);
    }
    detachShm(mem);
    deleteShm(shm);
    return 0;
}

client.cc

#include "com.hpp"

int main()
{
    int key = getKey();
    int shm = shmHelper(key);
    cout << shm << endl;
    void *mem = attachShm(shm);
    cout << mem << endl;
    int cnt = 0;
    char *message = "Hello, I`m client";
    while (1)
    {
        snprintf((char *)mem, MAX_SIZE, "PID->%d : %s, count : %d\n", getpid(), message, ++cnt);
        sleep(1);
    }
    detachShm(mem);
    return 0;
}

image-20230728223930542

共享内存是所有通信中最快的通信方式,因为它没有缓冲区,能大大减少通信数据的拷贝次数。

Linux 进程间通信 Linux进程通信继承了传统的UNIX进程间通信方式,包括无名管道、有名管道以及信号;还有System V进程间通信(IPC),包括System V消息队列、System V信号量以及System V共享内存;套接字。 阅读详情

相关推荐

思科华三设备组网思科生成树PVST发BPDU导致全网闪断

一、故障现象 1.思科PVST BPDU报文导致全网闪断。 2.光衰低时不同品牌网络设备无法兼容导致接入交换机中断。 二、网络拓扑 图1 网络拓扑图 组网结构为H3C汇聚,接入交换机有思科,也有H3C,而且与汇聚直连的接入交换机下面串接了较多的交换机,或者hub。 三、排查思路 1.回忆一下最近做了什么事情,什么时候开始出的问题。 将网络汇聚交换机从思科换为H3C,H3C汇聚和思科接入对接出问题...

Silence_always的博客 7495

Linux进程间通信

进程间通信(IPC)是指不同进程之间的数据交换和通信。在多进程环境下,不同的进程需要共享内存、文件等资源,但是每个进程都有自己独立的地址空间,因此需要通过进程间通信来实现进程之间的数据交换和共享。进程间通信使得进程间可以进行数据传输、资源共享、通知事件等。例如,一个进程需要将它的数据发送给另一个进程,或者多个进程之间共享同样的资源,或者一个进程需要向另一个或一组进程发送消息,通知它们发生了某种事件等。本节我们将为大家介绍进程间通信的相关知识!

ARMCSKGT的博客 2765

Isaac Gym摄像头数据获取全攻略:从CPU到GPU,教你实时显示RGB与深度图

本文详细介绍了在Isaac Gym中获取摄像头数据的两种高效方案:CPU模式与GPU张量模式。通过实战代码示例,展示了从摄像头配置、数据获取到实时可视化RGB与深度图的全流程,帮助开发者优化机器人仿真与计算机视觉应用的性能。特别强调了GPU模式下的零拷贝访问与张量运算优势,适用于需要低延迟处理的场景。

weixin_29056701的博客 388

Linux:进程间通信

一篇带你完全掌握进程间通信

Makise的博客 2106

AI重塑运营商CRM:从传统办理到智能推荐的实战经验

本文探讨了AI技术如何重塑运营商CRM系统,从传统办理模式升级为智能推荐平台。文章首先分析了传统CRM系统在产品推荐效率、客户信息录入、业务流程和个性化服务等方面的痛点,提出AI赋能的解决方案。技术架构采用分层设计,包含智能推荐引擎、知识图谱系统和大模型集成三大核心模块。实战案例详细介绍了基于深度学习的智能推荐系统实现,包括用户行为特征提取、产品特征建模、推荐模型训练和实时推荐服务等关键组件代码实现,展示了AI如何提升运营商CRM系统的智能化水平和服务效率。

技术传感器的博客 1051

Miniconda入门:在CentOS上的安装、基本操作、目录结构、卸载

Miniconda是一个 免费的 轻量级的 conda安装程序 它只包含conda、Python、pip、zlib等基础的文件和依赖包 使用conda install命令可从Anaconda存储库中安装额外的conda包 简介 下载 安装 基本操作 虚拟环境的操作 包的操作 目录结构 卸载

ArYe 1万+

<Linux> 进程间通信

进程间通信,匿名管道、命名管道、共享内存、消息队列、信号量

prodigy623的博客 3493

Multisim 11.0的安装破解汉化步骤

15:打开注册机,选择管理员运行,默认第一项,选择生成文件路径,这里不要随意选择,要找到你安装Multisim安装路径下Shard下的License Manager路径下,否则会报错,破解失败。14:后面会出现一个更新提示,选择否,然后选择重启电脑后,先不要选择重启电脑,在这里出现了问题(可能敲击回车,默认去重启电脑了),所以我说不要重启电脑,重启破解时右下角出现这,点击否。17:重启电脑,如果前面重启过,那可以跳过重启,应用程序下找到下图所示,启动。16:点击确认覆盖,路径下生成了该文件。

qq_53260940的博客 2380

【Linux】进程间通信

学习进程间通信的两种方法:匿名管道和命名管道。了解他们的特性及使用情况;进行匿名管道的实践——简易实现进程池,命名管道的实践——cilent&&serve端通信

Mesar的博客 1397

python零基础入门到精通,python入门到精通教程

坚持到了这儿,恭喜你,表示你有做开发的潜力,其实我想说的上面的内容还是刚刚开始,刚开始大家不需要多么精通了解这些内容,除了Python方面的知识,每个部分掌握一点儿能进行基本开发就好,主要是不断练习,让自己跳出「舒适区」,进入「学习区」,但是又不进入「恐慌区」,不断给自己「喂招」。上述这份完整版的Python全套学习资料已经上传优快云官方,朋友们如果需要可以扫描下方二维码免费获取【保证100%免费】

YYmmsss的博客 3480

告别机载网络通信混乱:利用ARINC825的LCC与带宽管理机制构建高可靠CAN总线

本文深入探讨了ARINC825规范如何通过逻辑通信通道(LCC)和带宽管理机制解决机载CAN总线通信的混乱问题。文章详细解析了ARINC825的核心架构设计、LCC工程实现、时间触发带宽管理等关键技术,展示了其在提升航空电子系统可靠性和实时性方面的显著效果,为现代飞机通信系统提供了高可靠解决方案。

weixin_26878995的博客 241

【Linux进程间通信】Linux匿名管道详解:构建进程间通信的隐形桥梁

当提及Linux系统中的进程间通信(IPC),管道(Pipes)无疑是最基础且广泛使用的一种机制。作为匿名通信的典范,管道为进程间数据交换提供了一个简单而有效的途径。在这个信息飞速传递的时代,掌握Linux管道的使用不仅是理解操作系统底层通信原理的关键一步,也是提升软件开发效率、构建复杂应用系统的必备技能

EterNity_TiMe_的计算机学习之路 4089

微磁模拟实战指南:从OOMMF安装到首个3D模型运行

本文详细介绍了OOMMF微磁模拟软件的安装与使用,从环境配置到首个3D模型运行的完整教程。涵盖Windows、Linux和macOS平台的安装避坑指南,以及MIF文件编写、并行计算优化等实战技巧,帮助研究人员快速掌握这一开源工具在磁畴壁运动、磁滞回线等微磁学问题中的应用。

weixin_29294597的博客 155

Linux之进程间通信

Linux之进程通信

2302_81120572的博客 1946

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

ssm框架搭建

这个是一个在idea上成功跑起来的ssm框架项目,保存在这里方便以后使用直接下载

【Linux】Linux进程间通信

进程间通信简称IPC(Interprocess communication),进程间通信就是在不同进程之间传播或交换信息。管道是Unix中最古老的进程间通信的形式。我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”我们可以用who | wc -l的命令看当前使用云服务器上的登录用户个数。who命令用于查看当前云服务器的登录用户(一行显示一个用户),wc -l用于统计当前的行数。

m0_70088010的博客 2190

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

linux下的进程间通信

semctl()系统调用:semctl();原型:int semctl(int semid,int semnum,int cmd,union semunarg);返回值:如果成功,则为一个正数。如果失败,则为-1:errno=EACCESS(权限不够)EFAULT(arg指向的地址无效)EIDRM(信号量集已经删除)EINVAL(信号量集不存在,或者semid无效)EPERM(EUID没有cmd的权利)ERANGE(信号量值超出范围)

szxhcljyjsjdff的博客 1687

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

【Linux】10. 进程间通信

本文讲述了4种进程间通信的手段:管道(匿名管道和命名管道)、System V标准下的3种通信方式(共享内存、消息队列和信号量)。无论是哪种进程间通信方式,本质上都是由操作系统提供一个公共空间作为桥梁,多个进程之间在这片公共空间上进行读写操作,以此来达成进程间通信的目的。

weixin_52811588的博客 2361

Linux: 进程间通信

在我们学习进程的时候,我们知道正是因为程序地址空间的存在,所以进程之间具有独立性,他们互不影响,但是在我们的实际应用中,进程之间总会有需要通信(交流获取对方数据)。

2301_79927432的博客 2833

Linux下的进程间通信-详解

   详细的讲述进程间通信在这里绝对是不可能的事情,而且笔者很难有信心说自己对这一部分内容的认识达到了什么样的地步,所以在这一节的开头首先向大家推荐著 名作者Richard Stevens的著名作品:《Advanced Programming in the UNIX Environment》,它的中文译本《UNIX环境高级编程》已有机械工业出版社出版,原文精彩,译文同样地道,如果你的确对在Linu

技术资料库 3万+

Linux进程间通信详解

进程间通信目的数据传输:一个进程需要将它的数据发送给另一个进程资源共享:多个进程之间共享同样的资源。通知事件:一个进程需要向另一个或一组进程发送消息,通知它(它们)发生了某种事件(如进程终止时要通知父进程)。进程控制:有些进程希望完全控制另一个进程的执行(如Debug进程),此时控制进程希望能够拦截另一个进程的所有陷入和异常,并能够及时知道它的状态改变。进程间通信发展管道System V进程间通信POSIX进程间通信进程间通信分类管道匿名管道pipe命名管道。

机会是给有准备的人 1809

Linux的进程间通信

本文摘要:本文系统介绍了Linux系统中进程间通信(IPC)的两种主要方式:管道和SystemV共享内存。首先阐述了进程间通信的目的(数据传输、资源共享、事件通知、进程控制)和发展历程。重点分析了管道通信的四种情况、匿名管道和命名管道的实现原理及特性,并通过代码示例展示了基于匿名管道的进程池实现。随后详细讲解了SystemV共享内存机制,包括shmget()创建、shmat()/shmdt()挂接/分离、shmctl()控制等系统调用,以及内核中SystemVIPC资源的组织管理方式。全文采用C/C++实现

博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴 1840

linux-进程间通信

一个完整的系统离不开各种各样的进程执行不同的任务,不同的任务之间存在着一些联系,为了能够保证进程之间的协调运作,使系统达到的理想的效果,需要进程之间传递信息。由于一个进程是不能访问到另一个进程的资源的,即进程之前是具有独立性的。那么进程之间要通信,就不能使用属于进程的资源,。的方式通常有管道(包括无名管道和命名管道)、消息队列、信号量、共享内存、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC。

m0_67794241的博客 1450
上一篇: Linux基础IO(二)
下一篇: [双指针](一) Leetcode 283.移动零和1089.复写零
沉着冷静2024
博客等级 码龄5年 669粉丝 128原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值