进程间同步互斥浅浅探索、没有函数用法

NCpaste

已于 2023-07-28 17:49:51 修改

阅读量59

点赞数

分类专栏：笔记文章标签： c++

于 2023-07-28 17:49:28 首次发布

本文链接：https://blog.csdn.net/nzg_cat/article/details/131985365

版权

笔记专栏收录该内容

14 篇文章 0 订阅

订阅专栏

进程同步通信

Proc

#include <semaphore.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include <sys/sem.h>
int semctl(int sem_id, int sem_num, int command, ...);
int semget(key_t key, int num_sems, int sem_flags);
int semop(int sem_id, struct sembuf *sem_ops, size_t num_sem_ops);

// linux 共享内存+信号量 https://blog.csdn.net/fengweibo112/article/details/119611439
// semget https://www.cnblogs.com/52php/p/5851570.html

class Monitor
{
public:
	Monitor(std::string path1, std::string path2);
	~Monitor();

public:
    void enq();
    void ouq();
    void fun();

public:
    int keySem;
    int keyShm;
    int semNum;

    void* shm;
};

Monitor(std::string path1, std::string path2)
{
    keySem = ftok(path1.c_str(), 1);
    keyShm = ftok(path2.c_str(), 2);

    semId = semget(keySem, 0, 0);
    shmId = shmget(keyShm, 0, 0);

    if (-1 == semId)
    {
        semId = semget(keySem, semNum, IPC_CREAT | IPC_EXCL | 0666)
    }    
    if (-1 == shmId)
    {
        semId = shmget(keySem, Size, ?);
    }
}

但是这种方法虽然没有明说被遗弃，但是很多人已经默认过时不再使用 // <sys/sem.h>
当前更多使用的是<semaphore.h>

简单说一下各个函数

ftok(pahtname, num)

根据pathname和num来生成一个key，用于semget\shmget\mesget
semget()

获取信号量
shmget()

获取共享内存
mesget()

获取消息

管程、进程间通信（管道，共享内存，消息）

管程

首先明白，管程需要自己写，本质是将pv操作和共享内存进行了封装（java和Golang好像有现成的包）

管程封装成为一种结构或者软件包？

必要性
- 不进行封装的情况下，pv操作和共享内存独立，操作的时候经常会出现匹配问题
模型

管程分为两种模型
1. MESA模型
2. HOARE模型
不得不使用管程

Sure. Suppose you want to take an action if you can acquire the lock, but if some other object already owns it, you don’t want to block for longer than a certain time:
```
bool gotMonitor = false;

try
{
    Monitor.TryEnter(monitor, 500, ref gotMonitor);
    if (gotMonitor)
    {
        // Okay, we're in the lock. We can do something useful now.
    }
    else
    {
        // Timed out - do something else
    }
}
finally
{
    if (gotMonitor)
    {
        Monitor.Exit(monitor);
    }
}
```
大佬说：
- 管程不是一个独立的程序，而是一个概念，像golang中的wait_group和java中的synchronized都是，但是 c++好像没有类似的库，但是可以带着mutex和 condition_variable自己实现类似管程的功能
- 管程不算是一个独立的程序，而相当于一个Model，不应该说有一个管程，而应该是使用管程 Monitor
- 可以理解为，假设 C++有这么一个类库，不同的程序使用这一个相同的 Minitor类来操作互斥资源

命名管道（FIFO）

与管道的区别：提供了一个路径名与之关联，以FIFO文件的形式存储于文件系统中，能够实现任何两个进程之间通信。而匿名管道对于文件系统是不可见的，它仅限于在父子进程之间的通信

#pragma once
#include "stdafx.h"
#include <windows.h>

#define BUF_SIZE 4096

class Monitor
{
public:
    Monitor();
    ~Monitor();

    void PV(int flag);
public:
    HANDLE hMapFile;    // 新创建的文件映射对象的句柄
    LPVOID lpBase;      // 内存映射视图
    HANDLE hmutex;      // 互斥锁

    char szBuffer[100];
};

#include "Monitor.h"

Monitor::Monitor()
{
    hMapFile = OpenFileMapping(FILE_MAP_ALL_ACCESS, NULL, L"ShareMemory");
    if (!hMapFile)
    {
        hMapFile = CreateFileMapping(
            INVALID_HANDLE_VALUE,       // 物理文件句柄
            NULL,                       // 默认安全级别
            PAGE_READWRITE,             // 可读可写
            0,                          // 高位文件大小
            BUF_SIZE,                   // 地位文件大小
            L"ShareMemory"              // 共享内存名称
        );
    }

    lpBase = MapViewOfFile(
        hMapFile,            // 共享内存的句柄
        FILE_MAP_ALL_ACCESS, // 可读写许可
        0,
        0,
        BUF_SIZE
    );

    hmutex = OpenMutex(MUTEX_ALL_ACCESS, FALSE, TEXT("MutexTest"));

    if (hmutex == NULL)
    {
        hmutex = CreateMutex(NULL, false, TEXT("MutexTest"));
    }
}

Monitor::~Monitor()
{
    if (hmutex != NULL)
    {
        CloseHandle(hmutex);
    }

    UnmapViewOfFile(lpBase);
    CloseHandle(hMapFile);
}

void Monitor::PV(int flag)
{
    WaitForSingleObject(hmutex, INFINITE);

    if (flag == 1)
        strcpy((char*)lpBase, szBuffer);
    else if (flag == 2)
        strcpy(szBuffer, (char*)lpBase);

    ReleaseMutex(hmutex);
}