软件编程3-进程和线程4-进程间通信-信号、消息队列、共享内存、信号灯

原创 已于 2025-08-20 09:34:39 修改 · 871 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#linux #运维 #服务器 #消息队列 #共享内存 #信号灯 #semctl

于 2025-08-20 09:31:46 首次发布

一、信号

1、概念：

  • Linux系统中的信号主要实现应用层和内核层之间的信号通知
  • 应用层与内核层之间通信的信号根据含义分为很多不同的信号
  • 信号主要用于多个进程任务间的事件通知
  • 信号可以用户异步通信

2、信号的类型：

  • 使用kill -l 查看信号类型

SIGINT:中止信号(可以从键盘输入)           ctrl + c
SIGQUIT:退出信号(可以从键盘输入)         ctrl + \
SIGKILL:杀死进程信号
SIGSEGV:段错误信号
SIGPIPE:管道破裂信号
SIGALARM:定时时间到达信号
SIGCHLD:子进程结束时，父进程回收到该信号
SIGCONT:继续执行进程任务
SIGSTOP:停止进程任务
SIGTSTP:挂起信号(可以从键盘输入)         ctrl + z
SIGIO:异步IO信号

3、信号的处理方式：

  • 缺省：信号来了，按照默认方式处理
  • 忽略：信号来了，不处理信号，忽略信号
  • 捕捉：信号来了，按照用户自己定义的方式处理信号
  • 注意：
    • 9号信号（SIGKILL）和19号信号（SIGSTOP）不能被忽略和捕捉

4、函数接口：

  •  signal

  • 练习：
    • 从终端输入 ctrl + c打印 SIGINT信号来了
    • 输入 ctrl + \打印 SIGQUIT信号来了
    • 输入 ctrl + z打印 SIGTSTP信号来了

#include "../head.h"

void handler1(int signo)
{
    printf("SIGINT信号来了\n");
    return;
}

void handler2(int signo)
{
    printf("SIGQUIT信号来了\n");
    return;
}

void handler3(int signo)
{
    printf("SIGTSTP信号来了\n");
    return;
}


int main(void)
{
    void (*pret1)(int) = NULL;
    void (*pret2)(int) = NULL;
    void (*pret3)(int) = NULL;

    pret1 = signal(SIGINT,handler1);
    if (handler1 == pret1)
    {
        perror("fail to signal");
        return -1;
    }

    pret2 = signal(SIGQUIT,handler2);
    if (handler2 == pret2)
    {
        perror("fail to signal");
        return -1;
    }

    pret3 = signal(SIGTSTP,handler3);
    if (handler3 == pret3)
    {
        perror("fail to signal");
        return -1;
    }

    while (1)
    {
        
    }


//杀死信号　ps -ef | grep a.out
//kill -9 信号名(数字－linux旁边那个)

    return 0;
}

  • alarm

  • kill

二、消息队列

1、IPC对象：

  • IPC对象可以理解为一种内存文件
  • IPC对象在操作系统关闭的情况下数据被回收掉
  • IPC对象可以通过文件系统来定位
  • 每个IPC对象可以创建一个消息队列、一个共享内存、一个信号

2、IPC对象操作命令：

  • 查看   ipcs
    • ipcs -q/m/s 消息队列/共享内存/信号灯ID
  • 删除   ipcrm
    • ipcrm -q/m/s 消息队列/共享内存/信号灯的ID
    • ipcrm -Q/M/S IPC对象的Key值

3、操作流程：

  • 创建/打开消息队列
  • 向消息队列中发送消息
  • 从消息队列中接收消息

4、函数接口：

  • ftok

  • msgget

  • msgsnd

  • msgrcv

函数类型是 ssize_t ，所以判断函数使用是否成功，类型也要是ssize_t ( ssize_t nret = 0; )

  • msgctl

三、共享内存

1、概念：

        进程空间是独立的，共享内存是开辟一段内核空间，进程都映射到这一片空间上，实现空间的共享、进程间通信最高效形式

2、操作方法：

        1. 创建IPC对象名称
        2. 创建共享内存
        3. 将进程空间地址映射到共享内存空间中
        4. 读写共享内存空间实现进程间通信
        5. 解除共享内存映射
        6. 删除共享内存

3、函数接口：

  • ftok：创建IPC对象
  • shmget

  • shmat

原型：void *shmat(int shmid, const void *shmaddr, int shmflg);
功能：
                将进程空间中的地址映射到共享内存中
参数：
                shmid:共享内存的ID号
                shmaddr: NULL:系统选择一个合适的地址进行映射
                shmflg:标志默认为0
                        
返回值：
                成功返回映射到共享内存空间中的地址
                失败返回（void *）-1

函数类型是viod *，所以定义变量接返回值的时候按需求定义

  • shmdt

  • shmctl

四、信号灯

1、 概念：

  • 搭配共享内存实现进程间通信
  • 主要用于多进程任务间的同步
  • 信号灯是一组信号量，即信号量的数组
  • 用于线程间通信的信号量称为无名信号量，信号灯是有名信号量

2、信号灯操作：

  • 创建信号量数组
  • 申请信号量
  • 释放信号量
  • 信号量的销毁

3、函数接口：

  • ftok
  • semget

  • semctl : 初始化

信号灯初始化时，四个参数，且需要将共用体加在全局变量中

原型：int semctl(int semid, int semnum, int cmd, ...);
功能：
                利用cmd实现对信号量的操作
参数：
                semid:信号量数组的ID号
                semnum:操作的信号量的下标
                cmd:IPC_RMID 删除信号量
                SETVAL 设置信号量的值
返回值：
                成功返回0
                失败返回-1
union semun {
        int val;                                 /* Value for SETVAL */
        struct semid_ds *buf;         /* Buffer for IPC_STAT, IPC_SET */
        unsigned short *array;         /* Array for GETALL, SETALL */
        struct seminfo *__buf;         /* Buffer for IPC_INFO
                                                        (Linux-specific) */
};

  • semop

可以申请释放信号量进行操作

原型：int semop(int semid, struct sembuf *sops, size_t nsops);
功能：

                完成对一个信号量的操作
参数：
                semid:信号量数组的ID号
                sops:对信号量进行操作的空间的首地址
                nsops:对信号量进行操作的个数
返回值：
                成功返回0
                失败返回-1
unsigned short sem_num; /* semaphore number */：操作信号量的下标
short sem_op; /* semaphore operation */：+1 释放1个资源 -1申请1个资源
short sem_flg; /* operation flags */：SEM_UNDO 对信号量的操作在进程结束后撤销

  • semctl : 删除

原型：int semctl(int semid, int semnum, int cmd, ...);
功能：
                利用cmd实现对信号量的操作
参数：
                semid:信号量数组的ID号
                semnum:操作的信号量的下标
                cmd:IPC_RMID 删除信号量

返回值：
                成功返回0
                失败返回-1

}

五、练习

1、消息队列实现聊天

代码实现：

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <math.h>
#include <dirent.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>


#define my_fgets(filename) do { \
    fgets(filename, sizeof(filename), stdin); \
    filename[strlen(filename)-1] = '\0'; \
} while (0)

#endif

makefile

all:a b

a:1.c
    gcc $^ -o $@ -lpthread        //(链接thread库文件)
b:2.c
    gcc $^ -o $@ -lpthread

1.c

#include "../head.h"

typedef struct message{
    long mtype;
    char mtext[256];
}message_t;

pthread_t tidsend;
pthread_t tidrecv;
int msgid = 0;


void *sendfun(void *arg)
{
    int ret = 0;
    message_t send;

    while (1)
    {
        send.mtype = 100L;
        my_fgets(send.mtext); 
        ret = msgsnd(msgid,&send,sizeof(send.mtext),0);
        if (-1 == ret)
        {
            perror("fail ro msgsnd");
            return NULL;
        }
        if (send.mtext == ".quit")
        {
            break;
        }
    }
   
    return NULL;
}
void *recvfun(void *arg)
{
    int ret = 0;
    message_t recv;
    
    while (1)
    {
        ret = msgrcv(msgid,&recv,sizeof(recv.mtext),200L,0);
        if (-1 == ret)
        {
            perror("fail ro msgrcv");
            return NULL;
        }
        if (recv.mtext == ".quit")
        {
            break;
        }
        printf("RECV:%s\n",recv.mtext);

    
    }
    return NULL;
}
int main(void)
{
    key_t key;

    int ret = 0;

    key = ftok("/",'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }
    printf("IPC对象键值%#x\n",key);

    msgid = msgget(key,IPC_CREAT | 0664);
    if (-1 == msgid)
    {
        perror("fail to msgget");
        return -1;
    }


    printf("消息队列的ID:%d\n",msgid);

    pthread_create(&tidsend,NULL,sendfun,NULL);
    pthread_create(&tidrecv,NULL,recvfun,NULL);

    pthread_join(tidrecv,NULL);
    pthread_join(tidsend,NULL);

    msgctl(msgid, IPC_RMID, NULL);


    return 0;
}

2.c

#include "../head.h"

typedef struct message{
    long mtype;
    char mtext[256];
}message_t;

pthread_t tidsend;
pthread_t tidrecv;
int msgid = 0;


void *sendfun(void *arg)
{
    int ret = 0;
    message_t send;

    while (1)
    {
        send.mtype = 200L;
        my_fgets(send.mtext); 
        ret = msgsnd(msgid,&send,sizeof(send.mtext),0);
        if (-1 == ret)
        {
            perror("fail ro msgsnd");
            return NULL;
        }
        if (send.mtext == ".quit")
        {
            break;
        }
    }
   
    return NULL;
}
void *recvfun(void *arg)
{
    int ret = 0;
    message_t recv;
    
    while (1)
    {
        ret = msgrcv(msgid,&recv,sizeof(recv.mtext),100L,0);
        if (-1 == ret)
        {
            perror("fail ro msgrcv");
            return NULL;
        }
        if (recv.mtext == ".quit")
        {
            break;
        }
        printf("RECV:%s\n",recv.mtext);

    
    }
    return NULL;
}
int main(void)
{
    key_t key;

    int ret = 0;

    key = ftok("/",'a');
    if (-1 == key)
    {
        perror("fail to ftok");
        return -1;
    }
    printf("IPC对象键值%#x\n",key);

    msgid = msgget(key,IPC_CREAT | 0664);
    if (-1 == msgid)
    {
        perror("fail to msgget");
        return -1;
    }
    printf("消息队列的ID:%d\n",msgid);

    pthread_create(&tidsend,NULL,sendfun,NULL);
    pthread_create(&tidrecv,NULL,recvfun,NULL);

    pthread_join(tidrecv,NULL);
    pthread_join(tidsend,NULL);

    msgctl(msgid, IPC_RMID, NULL);


    return 0;
}

结果

2、利用共享内存 实现一边写一边读

代码实现：

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <math.h>
#include <dirent.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>


#define my_fgets(filename) do { \
    fgets(filename, sizeof(filename), stdin); \
    filename[strlen(filename)-1] = '\0'; \
} while (0)

#endif

makefile

all:read write

read:read.c
    gcc $^ -o $@ -lpthread
write:write.c
    gcc $^ -o $@ -lpthread

read.c

#include "../head.h"

int main(void)
{
    key_t key;
    int shmid = 0;
    int ret = 0;
    char *pshmaddr = NULL;

    key = ftok("/",'a');
    if (0 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    shmid = shmget(key,4096,IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }
    
    pshmaddr = shmat(shmid,NULL,0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }


    while (1)
    {
        if (0 == strcmp(pshmaddr,".quit"))
        {
            break;
        }
        printf("pshmaddr = %s\n",pshmaddr);
    }

    ret = shmdt(pshmaddr);
    if (-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }
    
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

write.c

#include "../head.h"

int main(void)
{
    key_t key;
    int shmid = 0;
    int ret = 0;
    char *pshmaddr = NULL;

    key = ftok("/",'a');
    if (0 == key)
    {
        perror("fail to ftok");
        return -1;
    }

    shmid = shmget(key,4096,IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmget");
        return -1;
    }
    
    pshmaddr = shmat(shmid,NULL,0);
    if (NULL == pshmaddr)
    {
        perror("fail to shmat");
        return -1;
    }


    //my_fgets(pshmaddr); 可以接指针，但是指针大小８字节，那个宏不太合适
    while (1)
    {
        fgets(pshmaddr,4096,stdin);
        pshmaddr[strlen(pshmaddr)-1] = '\0';
        if (0 == strcmp(pshmaddr,".quit"))
        {
            break;
        }
    }

    ret = shmdt(pshmaddr);
    if (-1 == ret)
    {
        perror("fail to shmdt");
        return -1;
    }
    
    shmctl(shmid,IPC_RMID,NULL);

    return 0;
}

结果

3、利用共享内存和信号灯实现两个进程对共享内存的同步操作（写一次、读一次）

head.h

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
#include <time.h>
#include <math.h>
#include <dirent.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/shm.h>
#include <sys/sem.h>


#define my_fgets(filename) do { \
    fgets(filename, sizeof(filename), stdin); \
    filename[strlen(filename)-1] = '\0'; \
} while (0)

#endif

makefile

all:read write

read:read.c
    gcc $^ -o $@ -lpthread  //使用多线程时makefile需要连接pthread库文件
write:write.c
    gcc $^ -o $@ -lpthread

read.c

#include "../head.h"

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};

int main(void)
{
    key_t key;
    int semid = 0;
    int shmid = 0;
    int ret = 0;
    char *shmaddr = NULL;
    union semun myun;
    struct sembuf mybuf;

    //创建IPC对象
    key = ftok("/",'a');
    if (0 == key)
    {
        perror("fail to fotok");
        return -1;
    }


    //创建信号量
    semid = semget(key,2,IPC_CREAT | 0664); //权限不要忘记了
    if (-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }


    //初始化读信号 信号量
    myun.val = 0; //读权限
    ret = semctl(semid,0,SETVAL,myun); //0:信号量编号
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }


    //初始化写信号　信号量
    myun.val = 1;
    ret = semctl(semid,1,SETVAL,myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    } 


    //创建共享内存
    shmid = shmget(key,4096,IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmid");
        return -1;
    }


    //将地址映射到内存文献中
    shmaddr = shmat(shmid,NULL,0); //NULL:系统选个合适位置进行映射
    if ((char *)-1 == shmaddr)
    {
        perror("fail to shmat");
        return -1;
    }


    while (1)
    {
        //申请读信号量
        mybuf.sem_num = 0; //信号量下标
        mybuf.sem_op = -1;
        mybuf.sem_flg = SEM_UNDO;
        ret = semop(semid,&mybuf,1);//1：操作信号量个数
        if (-1 == ret)
        {
            perror("fail to semop");
            return -1;
        }


        //判断结束条件
        if (0 == strcmp(shmaddr,".quit"))
        {
            break;
        }


        //将读出结果打印
        printf("RECV:%s\n",shmaddr);


        //释放写的信号量
        mybuf.sem_num = 1;
        mybuf.sem_op = +1;
        mybuf.sem_flg = SEM_UNDO;
        ret = semop(semid,&mybuf,1);
        if (-1 == ret)
        {
            perror("fail to semop");
            return -1;
        }        

    }


    ret = shmdt(shmaddr);
    if (-1 == ret)
    {
        perror("fail to shmat");
        return -1;
    }

    ret = shmctl(shmid,IPC_RMID,NULL); 
    if (-1 == ret)
    {
        perror("fail to shmctl");
        return -1;
    }


    semctl(semid,0,IPC_CREAT,NULL);

    return 0;
}

write.c

#include "../head.h"

union semun {
    int              val;    /* Value for SETVAL */
    struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    unsigned short  *array;  /* Array for GETALL, SETALL */
    struct seminfo  *__buf;  /* Buffer for IPC_INFO
                                (Linux-specific) */
};

int main(void)
{
    key_t key;
    int semid = 0;
    int shmid = 0;
    int ret = 0;
    char *shmaddr = NULL;
    union semun myun;
    struct sembuf mybuf;

    //创建IPC对象
    key = ftok("/",'a');
    if (0 == key)
    {
        perror("fail to fotok");
        return -1;
    }


    //创建信号量
    semid = semget(key,2,IPC_CREAT | 0664); //权限不要忘记了
    if (-1 == semid)
    {
        perror("fail to semget");
        return -1;
    }


    //初始化读信号 信号量
    myun.val = 0; //读权限
    ret = semctl(semid,0,SETVAL,myun); //0:信号量编号
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    }


    //初始化写信号　信号量
    myun.val = 1;
    ret = semctl(semid,1,SETVAL,myun);
    if (-1 == ret)
    {
        perror("fail to semctl");
        return -1;
    } 


    //创建共享内存
    shmid = shmget(key,4096,IPC_CREAT | 0664);
    if (-1 == shmid)
    {
        perror("fail to shmid");
        return -1;
    }


    //将地址映射到内存文献中
    shmaddr = shmat(shmid,NULL,0); //NULL:系统选个合适位置进行映射
    if ((char *)-1 == shmaddr)
    {
        perror("fail to shmat");
        return -1;
    }


    while (1)
    {
        //申请写信号量
        mybuf.sem_num = 1;                        //信号量下标
        mybuf.sem_op = -1;
        mybuf.sem_flg = SEM_UNDO;
        ret = semop(semid,&mybuf,1);        //1：操作信号量个数
        if (-1 == ret)
        {
            perror("fail to semop");
            return -1;
        }


        //接收写的内容
        fgets(shmaddr,4096,stdin);
        shmaddr[strlen(shmaddr)-1] = '\0';
       
        //释放读的信号量
        mybuf.sem_num = 0;
        mybuf.sem_op = +1;
        mybuf.sem_flg = SEM_UNDO;
        ret = semop(semid,&mybuf,1);
        if (-1 == ret)
        {
            perror("fail to semop");
            return -1;
        }


        //判断结束条件
        if (0 == strcmp(shmaddr,".quit"))
        {
            break;
        }        

    }


    ret = shmdt(shmaddr);
    if (-1 == ret)
    {
        perror("fail to shmat");
        return -1;
    }

    ret = shmctl(shmid,IPC_RMID,NULL); 
    if (-1 == ret)
    {
        perror("fail to shmctl");
        return -1;
    }


    semctl(semid,0,IPC_CREAT,NULL);

    return 0;
}

结果

八.linux的进程间通信之管道、消息队列、共享内存简介
Mr.Wang的博客
04-27 2807
http://note.youdao.com/noteshare?id=e776f7ddbdee26e3d3a3f102b27174be&sub=725B6C7D7A074448AE46FDEF0B8682D5 目录 一、linux的进程间通信简介 1、进程间通信简介 2、多进程编程的优缺点 1、优点 2、缺点 二、linux的IPC机制1-管道 1、管道（无名管道） 2...
unix 环境高级编程 c语言 --- 进程间通信5种方式汇总
weixin_53272394的博客
08-17 752
何为进程间通信 进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢?进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。另外，系统空间是"公共场所"，各进程均可以访问，所以内核也可以提供这样的条件。此外，还有双方都可以访问的外设。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过"注册表"或其它数据库中的某些表项和记录交换信息。广义上这也是进程间通信的手段，但是一般都不把这算作"进程间通信"。 分类 1 简单进程间通
软件编程3-进程和线程4-进程间通信1-管道
DebugKitty的博客
08-18 606
本文介绍了Linux系统下进程间通信的基本概念和实现方式。主要内容包括：1)进程空间独立，是资源分配的最小单元；2)三种传统通信方式：管道(无名/有名)、信号、消息队列等系统调用；3)重点讲解了管道机制，无名管道只能用于亲缘关系进程，有名管道通过命名文件实现任意进程通信；4)给出了一个使用有名管道实现双进程聊天的代码示例，包含管道创建、读写线程以及同步处理等关键实现。该方案展示了进程间通信的实际应用方法。
Linux软件编程（8）—进程间通信（2）消息队列、共享内存、信号灯
Childecool的博客
08-19 739
原型：ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);原型：int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);进程空间是独立的，共享内存是开辟一段内核空间，进程都映射到这一片空间上，实现空间的共享。原型：int semctl(int semid, int semnum, int cmd, ...);
Linux编程——进程间通信（信号灯集、消息队列）
weixin_43624626的博客
08-15 743
System V的信号灯是一个或者多个信号灯的一个集合。其中的每一个都是单独的计数信号灯。而Posix信号灯指的是单个计数信号灯。🚨注意：第一次创建信号灯集，semid为0，不能用，要排除。故第一次创建完之后要删除semid为0的信号灯集，重新创建。用法：第四个参数是一个共用体，需自己创建，共用体第一个参数就是信号灯的值。获取信号灯值：函数semctl(semid, 0, GETVAL)的返回值。删除系统信号灯集：ipcrm -s semid。通过信号灯集实现共享内存的同步操作。
Linux软件编程：进程与线程（进程间通信（消息队列、共享内存、信号灯））
2501_91498265的博客
08-19 584
1.进程空间是独立的，共享内存是开辟一端内核空间，进程都映射到这一片空间上，实现空间的共享。ipcrm -q/m/s（消息队列/共享内存/信号灯的ID）ipcs -q/m/s(查看消息队列/共享内存/信号灯)4.每个IPC对象可以创建一个消息队列、一个共享内存、一个信号灯。ipcrm -Q/M/S（IPC对象的key值）4.用于线程间通信的信号量成为无名信号量，信号灯是有名信号量。3.将进程空间地址映射到共享内存空间中。4.读写共享内存空间实现进程间通信。1.搭配共享内存实现进程间通信。
Linux软件编程----进程间的相互通信
mutou8541的博客
08-09 1023
SYS VBSD。
进程间通信--消息队列--共享内存--线程基础
瑞凯
05-25 435
进程间通信 消息队列 Queue 通信原理：在内存中建立队列模型，进程通过队列存取消息实现通信， 实现方法： from multiprocessing import Queue q = Queue(maxsize = 0) 功能：创建消息队列 参数：最多存放多少消息 q.put(data,[block,timeout]) 功能：向队列存入消息 参数：data 要存入的数据 ...
进程间的通信--信号量
2503_90753911的博客
08-02 386
进程间的通信--信号量的实现。利用信号量和共享内存实现进程同步（生产者消费者模型），代码实现。
IO进、线程——进程间通信的IPC对象（共享内存、消息队列和信号灯集）
qq_57737603的博客
07-29 364
进程间通信（IPC，Inter-Process Communication）是指不同进程之间进行信息交换和数据共享的机制。在多进程编程中，进程间通信是非常重要的，它允许不同的进程之间进行协调和合作，从而实现更复杂的任务。在Linux/Unix操作系统中，提供了多种IPC对象，其中包括共享内存、消息队列、信号量等。这些IPC对象允许进程之间共享数据、发送消息和进行同步操作。接下来，我们将详细介绍和这三种常用的进程间通信IPC对象。
Linux进程间通信（IPC）详解：管道、信号、消息队列、信号灯、共享内存、套接口
"这篇文章深入探讨了Linux进程间通信（IPC），涵盖了从管道、信号、消息队列、信号灯、共享内存到套接口等多种通信机制。作者通过详细的讲解和实例，帮助读者理解这些通信方式的工作原理和应用。 1. **管道**：管道...
linux系统编程--进程间通信--管道
08-21
常用的进程间通信方式有多种，包括无名管道、有名管道、信号、System V IPC 对象共享内存、消息队列和信号灯、BSD 套接字等。 本文主要介绍无名管道（pipe）的概念和使用方法。无名管道是一种半双工的通信方式，...
Linux rsync命令
菜鸟记录
11-24 1024
⏹Linux rsync命令
Linux性能调优使用strace来分析文件系统的性能问题
最新发布
运维老生常谈
11-25 515
前面几章我们介绍了文件系统和磁盘的相关信息，其中大篇幅讲了I/O请求落到磁盘的整个过程，以及可能存在性能瓶颈的地方和排查工具方法。还未看过的，可以到文章末尾参阅之前的文章。今天主要来介绍工具strace，并由它来组合lsof、vmstat、iostat、pidstat等工具共同分析文件系统存在的性能问题。为什么要用这个工具？一是它安装使用比较方便、容易上手，可以通过命令来安装，安装后直接通过strace命令使用，无需额外配置。
使用 nethogs 和 nload 进行 Linux 网络监控
Zsr1023的博客
11-22 144
特性nethogsnload监控对象进程网络接口核心问题谁在占用带宽流量总体多大，趋势如何优势精确定位到问题进程直观显示总体流量和速率变化关系微观，深入进程内部宏观，把握整体状况。
Linux---进程概念（一）——冯诺依曼体系、操作系统、进程、PCB的概念讲解
2401_88465894的博客
11-22 841
本文系统阐述了计算机系统的核心概念。首先介绍了冯诺依曼体系结构，包括五大组件（输入设备、存储器、运算器、控制器、输出设备）及其协作关系，重点解释了内存作为CPU与磁盘间缓冲的重要性。其次深入剖析了操作系统的本质，即通过"先描述再组织"的方式管理软硬件资源，将管理对象抽象为数据结构进行操作。然后详细讲解了进程概念，指出进程由内存中的程序代码/数据和PCB（进程控制块）共同构成，并阐述了进程调度中上下文切换的机制。最后说明了进程标识符的获取方式，强调用户程序必须通过系统调用访问内核数据结构。
【Linux】从条件变量到信号量｜环形队列版生产者 - 消费者模型实战（附完整源码）
欢迎来到我的博客，私信我可以一起交流技术
11-23 890
前言：欢迎各位光临本博客，这里小编带你直接手撕**，文章并不复杂，愿诸君**耐其心性，忘却杂尘，道有所长！！！！在多线程编程中，同步与互斥是核心问题。本文将从条件变量、阻塞队列入手，逐步深入到POSIX信号量，并最终实现一个基于环形队列的生产者-消费者模型，展示不同同步机制的应用场景与实现细节。条件变量是线程间同步的基础工具，用于线程间的“等待-通知”机制。你可以把它想象成一个“消息板”，线程A在上面等待一个消息（条件满足），线程B在条件满足时在消息板上发布通知，唤醒线程A。这是条件变量最基础的实现，包含了
【Linux】make 与 makefile 实现自动化构建
L_0907的博客
11-24 643
本篇文章主要介绍 Linux 中 make 工具与 makefile 来实现自动化构建
RHCE Day5 SELinux
Y_P_W的博客
11-23 1093
SELinux是Linux内核的安全访问控制系统，通过强制访问控制机制对进程和文件进行细粒度权限管理。SELinux有三种工作模式：强制模式(enforcing)、宽容模式(permissive)和禁用模式(disabled)。系统管理员可以通过getenforce/setenforce命令查看和临时修改模式，或通过修改/etc/selinux/config配置文件永久修改。SELinux通过安全上下文(security context)标识进程和文件的访问权限，包含用户类型、角色类型和策略类型等字段。管理
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值