Linux共享内存与互斥锁

Linux共享内存

共享内存是从系统的空闲内存池中分配，并希望访问它的每个进程都能连接它。连接的过程称为映射。映射后，每个进程都可通过访问自己的内存而访问共享内存区域，进而与其它进程进行通信。

共享内存相关函数

打开创建共享内存文件

int shm_open(const char *name, int oflag, mode_t mode)

删除共享内存

int shm_unlink(const char *name)

重置共享内存文件大小

int ftruncate(int fd, off_t length)

建立（连接）共享内存映射

void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)

// addr：建立映射区的首地址，由Linux内核指定。使用是，直接传递NULL

// length：欲创建映射区的大小

// prot：映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

// flags：标志位参数（常用于设定更新物理区域，设置共享、创建匿名映射区）

       MAP_SHARED：会将映射区所做的操作反映到物理设备（磁盘上），无血缘关系的进程通信

       MAP_PRIVATE：映射区所做的修改不会反映到物理设备

       MAP_ANONYMOUS：匿名映射区

// fd：用来建立映射区的文件描述符

// offset：映射文件的偏移（4k的整数倍）

解除映射

int munmap(void *addr, size_t length)

进程间同步互斥锁相关函数

初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr)

释放互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex)

尝试加锁

int pthread_mutex_trylock(pthread_mutex_t *mutex)

加锁

int pthread_mutex_lock(pthread_mutex_t *mutex)

加锁（存在时间限制）

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const struct timespc *restrict abstime)

解锁

int pthread_mutex_unlock(pthread_mutex_t *mutex)

定义mutex锁的属性

pthread_mutexattr_t mattr

初始化一个mutex属性对象

int pthread_mutexattr_init(pthread_mutexattr_t *attr)

销毁mutex属性对象（非销毁锁）

int pthread_mutexattr_destory(pthread_mutexattr_t *attr)

修改mutex属性

int pthread_mutexattr_setshared(pthread_mutexattr *attr, int pshared)

// pshared取值如下：

// 线程锁：PTHREAD_PROCESS_PRIVATE（mutex的默认属性为线程锁，进程间私有）

// 进程锁：PTHREAD_PROCESS_SHARED

共享内存测试程序

// test1.cpp
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
        int fd = shm_open("/test-shm", O_CREAT|O_RDWR|O_EXCL, 0777);
        if (fd < 0) {
                fd = shm_open("/test-shm", O_RDWR, 0777);
                printf("open ok\n");
                if (fd < 0) {
                        printf("error open shm object\n");
                        return 0;
                }  
        }  
        else {
                printf("create ok\n");
                ftruncate(fd, 1024);
        }
        char *ptr = (char *)mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        close(fd);
        strcpy(ptr, "write by t08");
        return 0;
}

程序编译：

gcc -lrt -o test1 test1.cpp

// test2.cpp
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
        int fd = shm_open("/test-shm", O_RDWR, 0777);
        if (fd < 0) {
                printf("error open shm object\n");
                return 0;
        }  
        char *ptr = (char *)mmap(NULL, 1024, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        close(fd);
        getchar();
        printf("%s\n", ptr);
        return 0;
}

程序编译：

gcc -lrt -o test2 test2.cpp

程序执行：

./test1和./test2后，能看到相关结果

Linux共享内存与互斥锁

猜你喜欢