IO进、线程——进程间通信的IPC对象（共享内存、消息队列和信号灯集）

已于 2023-07-30 14:14:48 修改
阅读量220 收藏 1
点赞数
分类专栏： IO进、线程 文章标签： 算法 linux 运维 c语言 网络 服务器
于 2023-07-29 15:18:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57737603/article/details/131994792
版权

进程间通信IPC对象

进程间通信（IPC，Inter-Process Communication）是指不同进程之间进行信息交换和数据共享的机制。在多进程编程中，进程间通信是非常重要的，它允许不同的进程之间进行协调和合作，从而实现更复杂的任务。

在Linux/Unix操作系统中，提供了多种IPC对象，其中包括共享内存、消息队列、信号量等。这些IPC对象允许进程之间共享数据、发送消息和进行同步操作。接下来，我们将详细介绍共享内存、消息队列和信号灯集这三种常用的进程间通信IPC对象。

ftok():

ftok 函数用于通过给定的文件名和项目ID生成一个唯一的IPC键值。IPC键值在创建IPC对象时被使用，确保进程能够正确地识别和访问同一个IPC对象。

#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

功能：通过参数给的简单值生成一个复杂值（IPC键值）
返回值：成功返回生成的key，失败返回-1
参数说明：
pathname：文件名 会使用文件的inode节点编号
proj_id：随便一个数值，用于与pathname联合生成IPC键值。

//生成IPC 值
    key_t key = ftok(".", 'n');
    if(key < 0){
        perror("ftok");
        return -1;
    }

1. 共享内存（Shared Memory）

共享内存是一种IPC对象，允许多个进程共享同一块物理内存区域，从而避免了进程间的数据复制，提高了进程间通信的效率。

直接读写内存（内核的空间），需要映射

1.1 创建/打开共享内存对象

#include <sys/shm.h>

int shmget(key_t key, size_t size, int shmflg);

在这里插入代码片

功能：打开一个共享内存对象（如果不存在则会先创建再打开）
返回值：成功返回对象ID号，失败返回-1
参数说明：
key：唯一表示某个对象的关键字，ftok()生成，也可以写IPC_PRIVATE，表示创建新的私有共享内存对象。
size：指定共享内存有多大，以字节为单位
shmflg：打开或创建对象的方式

IPC_CREAT：对象不存在则创建
IPC_CREAT | 0666

	//生成IPC 值
    key_t key = ftok(".", 'n');
    if(key < 0){
        perror("ftok");
        return -1;
    }
    //创建打开共享内存对象
    int shmid = shmget(key, 64, IPC_CREAT | 0666);
 	//shmid = shmget(IPC_PRIVATE, 128, IPC_CREAT | 0666);
    if(shmid < 0){
        perror("shmget");
        return -1;
    }

1.2 映射用户空间

void *shmat(int shmid, const void *shmaddr, int shmflg);

功能：把内核空间的地址映射到用户空间来，读写用户空间其实就是读写内核空间
返回值：成功返回映射后的地址，失败返回(void *)-1
参数说明：
shmid：已经打开的对象ID号
shmaddr：映射空间的地址，如果让系统帮忙分配空间就写NULL
shmflg：空间访问方式

SHM_RDONLY：只读
0：读写

	//映射用户空间
    char *shmaddr = (char *)shmat(shmID, NULL, 0);
    if(shmaddr == (char *)-1){
        perror("shmat");
        return -1;
    }

1.3 取消映射

int shmdt(const void *shmaddr);

功能：取消已经映射的空间
返回值：成功返回0，失败返回-1
参数说明：
shmaddr：映射后的地址

	//取消映射对象
    shmdt(shmadder);

1.4 删除对象

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

功能：整体操作共享内存对象（获取属性、设置属性、删除对象…）
返回值：成功返回0，失败返回-1
参数说明：
shmid：共享内存ID号
cmd：整体操作指令

IPC_STAT：获取属性
IPC_SET：设置属性
IPC_RMID：标记删除对象，只有最后一个连接的进程也标记了删除，才会真正的删除

buf：主要用于获取和设置属性，删除对象写NULL

结构体 struct shmid_ds 包含了共享内存的相关属性信息，包括：
struct ipc_perm shm_perm：用于标识共享内存对象的权限信息。
size_t shm_segsz：共享内存段的大小，以字节为单位。
time_t shm_atime：最后一次附加（映射）共享内存的时间。
time_t shm_dtime：最后一次分离共享内存的时间。
time_t shm_ctime：最后一次更改共享内存的时间。
pid_t shm_cpid：创建共享内存的进程ID号。
pid_t shm_lpid：最后一次附加共享内存的进程ID号。
shmatt_t shm_nattch：当前附加（映射）共享内存的进程数量。

struct ipc_perm {
key_t __key; /* Key supplied to shmget(2) /
uid_t uid; / Effective UID of owner /
gid_t gid; / Effective GID of owner /
uid_t cuid; / Effective UID of creator /
gid_t cgid; / Effective GID of creator /
unsigned short mode; / Permissions + SHM_DEST and SHM_LOCKED flags /
unsigned short __seq; / Sequence number */
};

 	//删除对象
    shmctl(shmID, IPC_RMID, NULL);

参考代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/wait.h>

#define SHM_SIZE 1024

int main() {
    int shmid;
    char *shmaddr;
    pid_t pid;

    // 创建共享内存对象
    shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(0);
    }

    // 将共享内存映射到进程的地址空间
    shmaddr = shmat(shmid, NULL, 0);
    if (shmaddr == (char *)-1) {
        perror("shmat");
        exit(0);
    }

    pid = fork();
    if (pid < 0) {
        perror("fork");
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程写入数据到共享内存
        sprintf(shmaddr, "Hello from child process!");
        exit(EXIT_SUCCESS);
    } else {
        // 父进程等待子进程退出
        wait(NULL);
        // 父进程读取共享内存中的数据并打印
        printf("Message from child process: %s\n", shmaddr);
    }

    // 取消映射并删除共享内存对象
    shmdt(shmaddr);
    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}

2.消息队列（Message Queue）

消息队列是一种IPC对象，允许多个进程之间通过发送消息进行通信。每个消息都有一个特定的类型，接收进程可以选择接收某个特定类型的消息。

各种类型的消息统统放到对象里面，只需要进程收发在意类型的消息

2.1 创建/打开消息队列

#include <sys/msg.h>

int msgget(key_t key, int msgflg);

功能：打开消息队列对象，如果不存在则创建后再打开
返回值：成功返回消息队列ID号，失败返回-1
参数说明：
key：可以是IPC_PRIVATE也可以是ftok()返回值
msgflg：打开创建方式 (IPC_CREAT | 0777)

key_t key = ftok(".", 'a');
    if(key < 0){
        perror("ftok");
        return -1;
    }

    //创建打开消息队列
    int msgid = msgget(key, IPC_CREAT | 0666);
    if(msgid < 0){
        perror("msgget");
        return -1;
    }

2.2 发送消息

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

功能：往消息队列对象中添加一个类型的消息
返回值：成功返回0，失败返回-1
参数说明：
msqid：已经打开的消息队列ID号
msgp：要发送的消息所在的缓冲区

struct msgbuf{
long type; // > 0
char text[N];
}

msgsz：表示要发送的消息正文大小，以字节为单位
msgflg：发送选项

0：阻塞
IPC_NOWAIT：非阻塞

//发送消息msgsnd
signal(SIGCHLD, sig_handler);
msgbuf.mtype = 100;//指定消息类型
char buf[256];
while(1){
    fgets(msgbuf.mtext, 256, stdin);
    int msg_snd = msgsnd(msgid, &msgbuf, sizeof(msgbuf.mtext), 0);
    if(msg_snd < 0){
        perror("msgsnd");
        continue;
    }
    if(strncasecmp(msgbuf.mtext, "quit", 4) == 0){
        msgctl(msgid, IPC_RMID, NULL);
        kill(pid, SIGKILL);
    }
}

2.3 接收消息

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

功能：从消息队列对象中读取一个在意类型的消息
返回值：成功返回收到的消息正文字节数，失败返回-1
参数说明：
msqid：消息队列ID号
msgp：用于存放消息的结构体

struct msgbuf{
long type; // > 0
char text[N];
}

msgsz：要收的消息正文大小
msgtyp：在意的消息类型
msgflg：接收方式，接收进程只接收该类型的消息

0：阻塞
IPC_NOWAIT：非阻塞

//接收消息msgrcv
msgbuf.mtype = 200;
while(1){
    int ret = msgrcv(msgid, &msgbuf, sizeof(msgbuf.mtext), msgbuf.mtype, 0);
    if(ret < 0){
        perror("msgrcv");
        continue;
    }
    printf("msgrcv form B:%s", msgbuf.mtext);
    if(strncasecmp(msgbuf.mtext, "quit",4) == 0){
        //如果接收到的内容是quit时就删除消息队列对象
        msgctl(msgid, IPC_RMID, NULL);
        exit(1);
    }
}

2.4 删除对象

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

功能：整体控制消息队列（获取、设置属性，删除对象…）
返回值：成功返回0，失败返回-1
参数说明：
msqid：要操作的消息队列ID号
cmd：操作指令

IPC_STAT
IPC_SET
IPC_RMID

buf：用于设置或获取属性，删除对象使用NULL

结构体 struct msqid_ds 包含了消息队列的相关属性信息，包括：

struct msqid_ds {
struct ipc_perm msg_perm：用于标识消息队列对象的权限信息。
time_t msg_stime：最后一次发送消息的时间。
time_t msg_rtime：最后一次接收消息的时间。
time_t msg_ctime：最后一次更改消息队列的时间。
unsigned long __msg_cbytes：消息队列中当前消息正文的总字节数。
msgqnum_t msg_qnum：当前消息队列中的消息数量。
msglen_t msg_qbytes：消息队列的最大容量，以字节为单位。
pid_t msg_lspid：最后一次发送消息的进程ID号。
pid_t msg_lrpid：最后一次接收消息的进程ID号。
…
};

msgctl(msgid, IPC_RMID, NULL);

参考代码

msg_A:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/wait.h>
#include <string.h>

struct msgbuf{
    long mtype;
    char mtext[256];
}msgbuf;

void sig_handler(int sig){
    int status;
    wait(&status);
    printf("exit = %d\n",(status >> 8) & 0xff);
    exit(0);
}

int main(int argc, char *argv[])
{ 
    key_t key = ftok(".", 'a');
    if(key < 0){
        perror("ftok");
        return -1;
    }

    //创建打开消息队列
    int msgid = msgget(key, IPC_CREAT | 0666);
    if(msgid < 0){
        perror("msgget");
        return -1;
    }

    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        return -1;
    }else if(pid == 0){
        //接收消息msgrcv
        msgbuf.mtype = 200;
        while(1){
            int ret = msgrcv(msgid, &msgbuf, sizeof(msgbuf.mtext), msgbuf.mtype, 0);
            if(ret < 0){
                perror("msgrcv");
                continue;
            }
            printf("msgrcv form B:%s", msgbuf.mtext);
            if(strncasecmp(msgbuf.mtext, "quit",4) == 0){
                //如果接收到的内容是quit时就删除消息队列对象
                msgctl(msgid, IPC_RMID, NULL);
                exit(1);
            }
        }
    }else{
        //发送消息msgsnd
        signal(SIGCHLD, sig_handler);
        msgbuf.mtype = 100;//指定消息类型
        char buf[256];
        while(1){
            fgets(msgbuf.mtext, 256, stdin);
            int msg_snd = msgsnd(msgid, &msgbuf, sizeof(msgbuf.mtext), 0);
            if(msg_snd < 0){
                perror("msgsnd");
                continue;
            }
            if(strncasecmp(msgbuf.mtext, "quit", 4) == 0){
                msgctl(msgid, IPC_RMID, NULL);
                kill(pid, SIGKILL);
            }
        }
    }

    return 0;
}

msg_B:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <sys/wait.h>
#include <string.h>

struct msgbuf{
    long mtype;
    char mtext[256];
}msgbuf;

void sig_handler(int sig){
    int status;
    wait(&status);
    printf("exit = %d\n",(status >> 8) & 0xff);
    exit(0);
}

int main(int argc, char *argv[])
{ 
    key_t key = ftok(".", 'a');
    if(key < 0){
        perror("ftok");
        return -1;
    }

    //创建打开消息队列
    int msgid = msgget(key, IPC_CREAT | 0666);
    if(msgid < 0){
        perror("msgget");
        return -1;
    }

    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        return -1;
    }else if(pid == 0){
        //接收消息msgrcv
        msgbuf.mtype = 100;
        while(1){
            int ret = msgrcv(msgid, &msgbuf, sizeof(msgbuf.mtext), msgbuf.mtype, 0);
            if(ret < 0){
                perror("msgrcv");
                continue;
            }
            printf("msgrcv form A:%s", msgbuf.mtext);
            if(strncasecmp(msgbuf.mtext, "quit",4) == 0){
                //如果接收到的内容是quit时就删除消息队列对象
                msgctl(msgid, IPC_RMID, NULL);
                exit(1);
            }
        }
    }else{
        //发送消息msgsnd
        signal(SIGCHLD, sig_handler);
        msgbuf.mtype = 200;//指定消息类型
        char buf[256];
        while(1){
            fgets(msgbuf.mtext, 256, stdin);
            int msg_snd = msgsnd(msgid, &msgbuf, sizeof(msgbuf.mtext), 0);
            if(msg_snd < 0){
                perror("msgsnd");
                continue;
            }
            if(strncasecmp(msgbuf.mtext, "quit", 4) == 0){
                msgctl(msgid, IPC_RMID, NULL);
                kill(pid, SIGKILL);
            }
        }
    }
    return 0;
}

3.信号灯集（Semaphore Set）

信号灯集是一种IPC对象，允许多个进程对一组信号灯进行操作。信号灯集主要用于实现进程间的同步和互斥，确保多个进程之间按照特定顺序进行执行。

信号量的集合

3.1 打开/创建信号灯集对象

#include <sys/sem.h>

int semget(key_t key, int nsems, int semflg);

功能：打开对象，不存在则创建后再打开
返回值：成功返回ID号，失败返回-1
参数说明：
key：ftok()返回值
nsems：信号灯集下面信号灯的种类数
semflg： IPC_CREAT | 0666

 //生成IPC值
key_t key = ftok(".", 'a');
if(key < 0){
    perror("ftok");
    return -1;
}
//创建打开信号量数组对象
int semid = semget(key, 3, IPC_CREAT | 0666);
if(semid < 0){
    perror("semget");
    return -1;
}

3.2 初始化信号量

int semctl(int semid, int semnum, int cmd, ...);

功能：整体操作（初始化个数、获取属性、删除对象）
返回值：成功返回0，失败返回-1
参数说明：
semid：对象ID号
semnum：信号灯集下某种信号灯的编号，从0开始

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) */
};

cmd：操作指令

SETVAL：初始化值
IPC_SET
IPC_STAT
IPC_RMID：删除对象

//初始化信号量数组中的所有信号量
int init_sem(int semid, int* init_vals){
    union semun arg;
    //myun arg
    arg.array = (unsigned short *)init_vals;
    return semctl(semid, 0, SETALL, arg);
}

3.3 PV操作

int semop(int semid, struct sembuf *sops, size_t nsops);

功能：PV操作的集合，可以通过参数不同而实现申请释放
返回值：成功返回0，失败返回-1
参数说明：
semid：对象ID号
sops：所有的操作所在的结构体

struct sembuf {
unsigned short sem_num; /* 信号灯编号 /
short sem_op; / 信号量操作：-1表示P操作(申请)，1表示V操作(释放) /
short sem_flg; / 操作标志：0表示阻塞，IPC_NOWAIT表示非阻塞 */
};

nsops：要操作的信号灯个数

//对信号量数组中的某个信号执行P操作
int sem_P(int semid, int sem_num){
    struct sembuf sb;
    //mysembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = -1;//P操作，申请
    //设置SEM_UNDO标志，确保进程结束时会释放信号量
    sb.sem_flg = SEM_UNDO;
    semop(semid, &sb, 1);
}

//对信号量数组中的某个信号执行V操作
int sem_V(int semid, int sem_num){
    struct sembuf sb;
    //mysembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = 1;//V操作，释放
    sb.sem_flg = SEM_UNDO;
    return semop(semid, &sb, 1);
}

参考代码：

#include <stdio.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/sem.h>
union semun{
    int val;
    struct semid_ds *buf;
    unsigned short *array;
    struct seminfo *__buf;
}myun;
#if 0
struct sembuf {
    unsigned short sem_num; /* 信号灯编号 */
    short sem_op; /* 信号量操作：-1表示P操作(申请)，1表示V操作(释放)*/
    short sem_flg; /* 操作标志：0表示阻塞，IPC_NOWAIT表示非阻塞 */
}mysembuf;
#endif

//初始化信号量数组中的所有信号量
int init_sem(int semid, int* init_vals);

//对信号量数组中的某个信号执行P操作
int sem_P(int semid, int sem_num);

//对信号量数组中的某个信号执行V操作
int sem_V(int semid, int sem_num);

int main(int argc, char *argv[])
{ 
    //生成IPC值
    key_t key = ftok(".", 'a');
    if(key < 0){
        perror("ftok");
        return -1;
    }
    //创建打开信号量数组对象
    int semid = semget(key, 3, IPC_CREAT | 0666);
    if(semid < 0){
        perror("semget");
        return -1;
    }

    //初始化信号量数组
    int init_vals[3] = {1, 0, 1};
    int ret = init_sem(semid, init_vals);
    if(ret < 0){
        perror("semctl");
        return -1;
    }

    //创建子进程
    pid_t pid = fork();
    if(pid < 0){
        perror("fork");
        return -1;
    }else if(pid == 0){
        //子进程执行P操作
        sem_P(semid, 0);//申请第一个信号量
        printf("子进程申请的资源 1\n");
        sleep(3);
        //子进程执行V操作
        sem_V(semid, 2);//释放第三个信号量
        printf("子进程释放的资源 3\n");
    }else{
        //父进程执行P操作
        sem_P(semid, 2);//申请第三个信号量
        printf("父进程申请的资源 3\n");
        sleep(3);
        //子进程执行V操作
        sem_V(semid, 0);//释放第三个信号量
        printf("父进程释放的资源 1\n");
    }

    //删除信号量数组对象
    int de_sem = semctl(semid, 0, IPC_RMID);
    if(de_sem < 0){
        perror("semctl");
        return -1;
    }

    return 0;
} 


//初始化信号量数组中的所有信号量
int init_sem(int semid, int* init_vals){
    union semun arg;
    //myun arg
    arg.array = (unsigned short *)init_vals;
    return semctl(semid, 0, SETALL, arg);
}

//对信号量数组中的某个信号执行P操作
int sem_P(int semid, int sem_num){
    struct sembuf sb;
    //mysembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = -1;//P操作，申请
    //设置SEM_UNDO标志，确保进程结束时会释放信号量
    sb.sem_flg = SEM_UNDO;
    semop(semid, &sb, 1);
}

//对信号量数组中的某个信号执行V操作
int sem_V(int semid, int sem_num){
    struct sembuf sb;
    //mysembuf sb;
    sb.sem_num = sem_num;
    sb.sem_op = 1;//V操作
    sb.sem_flg = SEM_UNDO;
    return semop(semid, &sb, 1);
}
小羊客栈
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
线程共享内存空间的代码验证
weixin_48080013的博客
12-24 131
demo： #include <stdio.h> #include <pthread.h> int g_data = 0; void *func1(void *arg) { printf("t1:%ld pthread is creat\n",(unsigned long)pthread_self()); printf("t1:param is %d\n", *((int *)arg)); while(1){ printf("t
共享内存进程线程混合通信
墨痕诉清风的博客
03-29 329
多线程共享内存混合编程 /*threadWrite线程向共享内存写数据，threadRead线程从共享内存读数据*/ /*读线程必须等待写线程执行完才开始*/ #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<sys/unistd.h> #i...
11信号灯集 函数用法
qq_35602425的博客
05-25 391
1.创建信号灯集 int semget(key_t key,int nsems,int semflg); 成功时返回信号灯的id，失败返回-1 示例 semget(IPC_PRIVATE,3,0777); key 和消息队列关联的key IPC_PRIVATE或ftok nsems 集合中包含的计数信号灯的个数 semflg 标志位 IPC_CREAT|0666 IPC...
C# 进程间通信 IPC
q771410116的博客
12-22 3413
在 C# 中，进程间通信（IPC）可以通过多种方式实现 套接字通信 Socket 共享内存 管道通信 消息队列
C/C++ 进程间通信system V IPC对象超详细讲解（系统性学习day9）
weixin_58070962的博客
10-08 1987
C/C++ 进程间通信system V IPC对象超详细讲解（系统性学习day9）
Linux Socket编程、Linux IO模型、Linux 进程间通信完整用例
02-16
Linux Socket编程、Linux IO模型、Linux 进程间通信【完整用例】
Android IPC进程间通信详解最新AndroidStudio的AIDL操作)
01-04
前面梳理了Android的线程间的通信《Thread、Handler和HandlerThread关系何在？》 ，这些都是在同一个进程中，那进程间的通信，或者说不同的应用间的通信该如何实现呢？这个时候就要用到AIDL(Android Interface ...
IO-Link——智慧的通信技术.pdf
09-02
"IO-Link——智慧的通信技术" IO-Link是一种智能的通信技术，主要应用于工业自动化领域。它是一种串行数字通信协议，用于与传感器和执行器进行通信。IO-Link技术可以简化工业控制领域的底层设备连接，提供大量的...
IO进程线程Day5 文件夹拷贝 从文件中读取数据到内存，从内存写入到文件 父子进程发送消息
最新发布
04-04
文件夹拷贝 从文件中读取数据到内存，从内存写入到文件（fscanf、fprintf）（fwrite、fread）（wreite、read） 父子进程发送消息
linux------11------共享内存的进程通信
weixin_42714122的博客
09-14 247
linux------11------共享内存的进程通信
线程通信机制：共享内存 VS 消息传递
chuangong2592的博客
07-02 1480
在并发编程中，我们必须考虑的问题时如何在两个线程间进行通讯。这里的通讯指的是不同的线程之间如何交换信息。 目前有两种方式： 1、共享内存 2、消息传递（actor 模型） 共享内存： 共享内存这种方式比较常见，我们经常会设置一个共享变量。然后多个线程去操作同...
线程共享内存空间
weixin_42900834的博客
03-02 1030
1.创建两个线程 #include <stdio.h> #include <pthread.h> //int pthread_create(pthread_t *restrict tidp, const pthread_attr_t *restrict attr, void *(*start_rtn)(void *), void *restrict arg); void *func1(void *arg) { printf("t1:%ld thread is cre
我对多线程共享内存的处理的看法
问渠哪得清如许
10-22 1641
像我以前用到共享内存的时候用临界区来对内存进行保护，这种办法我不认为是错误的 ，这样可以很好的保护好内存，但是问题是当被临界区保护的代码执行的时间长，或者处于挂起状态，那么其它线程在用刀该共享内存的时候会处于等待状态，效率会很低。 现在我学到一种方法，当然需要和业务联系起来，这里只提供一种思路。一个线程对内存进行删除操作，另一个线程对内存进行管理，就是对内存进行修改；利用内存结构体的项，个人建议
C++内存共享, 与多线程同步通信
weixin_43202230的博客
02-21 1901
C++内存共享，与多线程同步
第五章节 - 跨线程共享内存
u012596785的博客
07-14 756
跨线程共享内存 - 章节 介绍跨线程共享内存 - 小节 线程间的沟通 线程需要共享它们的数据 比让值可见更复杂 值也必须正确： 1> 缓存[读取陈旧值]的问题 2> 编译器“欺骗”问题 好的设计是关键 意识到这一点很重要 1> 需要在设计阶段考虑如何共享数据 2> 没有计划地编写代码会导致困难 Bugs可以是： 1> 微妙的 2> 很难找到 3...
线程共享内存及可能存在的问题
涛涛之海
03-29 1814
文章目录线程共享内存及可能存在的问题1.竞态条件2.内存可见性 线程共享内存及可能存在的问题 每个线程表示一条单独的执行流，有自己的程序计数器，有自己的栈，但线程之间可以共享内存，他们可以访问和操作相同的对象。 package com.claa.javabasic.Thread; import java.util.ArrayList; import java.util.List; /** *...
线程间的内存共享问题----你弄懂了吗？
热门推荐
回忆的往昔
10-08 1万+
对线程间共享内存的问题，许多同学是不是都觉得很简单？就是用全局变量来共享码，然而你说的并没有什么卵用…….(^__^)……. 对于线程间内存关系不弄得清清楚楚，很难写好多线程程序。最简练而精准的话来形容线程间共享内存：同一个线程组内线程间共享虚拟内存（自己通过实验总结的，然而不久以后发现一本书中（linux设备驱动程序）早就说过了，我读书好少啊O(∩_∩)O哈哈~） 虚拟内存没弄懂，就看看相关资
C# 进程间通信(共享内存)
05-17
C# 提供了多种进程间通信的方式，其中包括基于共享内存的通信方式。下面介绍一下使用共享内存实现进程间通信的方法。 首先需要在 C# 中引入 System.IO.MemoryMappedFiles 命名空间。然后创建一个 MemoryMappedFile ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小羊客栈

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值