AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

多线程、多进程同时操作MMAP，会怎么样？（二）

2023-01-07 378
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： 多线程、多进程同时操作MMAP，会怎么样？

文件锁flock

在linux 系统中，flock函数是为解决多进程对同一文件的读写冲突的，而flock函数只能锁定整个文件，无法锁定文件的某一区域。且flock可以保证robust，这也是我们选择它最终目的。

int flock(int fd,int operation);
  • fd 文件描述
  • operation 锁的模式
  • LOCK_SH 建立共享锁定。多个进程可同时对同一个文件作共享锁定。
  • LOCK_EX 建立互斥锁定。多个进程中一个文件同时只有一个互斥锁定。
  • LOCK_UN 解除文件锁定状态。
  • LOCK_NB 无法建立锁定时，此操作可不被阻断，马上返回进程。通常与LOCK_SH或LOCK_EX 做组合
  • 单一文件无法同时建立共享锁定和互斥锁定，且当使用dup()或fork()时文件描述符也不会继承此种锁定。
  • 返回值 返回0表示成功，若有错误则返回-1，错误代码存于errno。

代码实现

void MMIPC::setData(const string &key, const string &value) {
//    AutoMutex autoMutex(m_mutex_lock);
    // 上跨进程写锁
    flock(m_fd, LOCK_EX);
    string content = key + ":" + value + ",";
//    ALOGD("setData content=%s", content.c_str());
    size_t numberOfBytes = content.length();
    if (m_position + numberOfBytes > m_file_size) {
        auto msg = "m_position: " + to_string(m_position) + ", numberOfBytes: " +
                   to_string(numberOfBytes) +
                   ", m_file_size: " + to_string(m_file_size);
        throw out_of_range(msg);
    }
    m_position = strlen(m_ptr);
    memcpy(m_ptr + m_position, (void *) content.c_str(), numberOfBytes);
//    ALOGD("setData success m_ptr.len=%d", m_position + numberOfBytes);
    // 解锁
    flock(m_fd, LOCK_UN);
}

运行效果

2022-07-24 12:54:32.259 10191-10191/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc 日志： set data
2022-07-24 12:54:32.521 10221-10221/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc:childProcess 日志： init
2022-07-24 12:54:32.523 10221-10221/com.zzy.mmipc D/MMIPC->: root dir /data/user/0/com.zzy.mmipc/files
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc D/MMIPC->: open success for mutex: fd[76], /data/user/0/com.zzy.mmipc/files/default_mutex.ipc
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc E/MMIPC->: pid[10221]
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc D/MMIPC->: open m_fd[76], /data/user/0/com.zzy.mmipc/files/default_mmap.ipc
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc D/MMIPC->: m_fd size[4194304]
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc D/MMIPC->: getFileSize m_file_size 4194304, default_mmap_size 4194304
2022-07-24 12:54:32.524 10221-10221/com.zzy.mmipc D/MMIPC->: mmap success
2022-07-24 12:54:44.677 10221-10221/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc:childProcess 日志： 2796540
2022-07-24 12:55:52.774 10191-10191/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc 日志： 3600000

怎么是36万？不应该是18万么，是的，因为我跑了两遍，一遍不放心不是，万一出问题呢。接着之前的经验，为了避免自己手欠无法正常的配对使用锁，我们封装下文件锁flock，如下

//
// Created by 张占永 on 2022/7/24.
//
#include <fcntl.h>
#include <sys/file.h>
#include <unistd.h>
#include <cerrno>
#include "AndroidLog.h"
#ifndef MMIPC_FILELOCK_H
#define MMIPC_FILELOCK_H
enum LockType {
    SharedLockType,
    ExclusiveLockType,
};
class FileLock {
    int m_fd;
    bool isFileLockValid() { return m_fd >= 0; }
public:
    explicit FileLock(int fd);
    bool lock(LockType lockType);
    bool try_lock(LockType lockType);
    bool unlock();
    // just forbid it for possibly misuse
    explicit FileLock(const FileLock &other) = delete;
    FileLock &operator=(const FileLock &other) = delete;
    class Autolock {
    public:
        inline Autolock(FileLock &flock, LockType lockType) : mFLock(flock), m_lockType(lockType) {
            mFLock.lock(m_lockType);
        }
        inline Autolock(FileLock *flock, LockType lockType) : mFLock(*flock), m_lockType(lockType) {
            mFLock.lock(m_lockType);
        }
        inline ~Autolock() { mFLock.unlock(); }
    private:
        FileLock &mFLock;
        LockType m_lockType;
    };
};
inline FileLock::FileLock(int fd)
        : m_fd(fd) {
}
inline bool FileLock::lock(LockType lockType) {
    if (!isFileLockValid()) {
        return false;
    }
    int res = flock(m_fd, lockType == SharedLockType ? LOCK_SH : LOCK_EX);
    if (res == -1) {
        ALOGD("flock lock fail: fd[%d]", m_fd);
    }
    return res == 0;
}
inline bool FileLock::try_lock(LockType lockType) {
    if (!isFileLockValid()) {
        return false;
    }
    int res = flock(m_fd, lockType == SharedLockType ? LOCK_SH | LOCK_NB : LOCK_EX | LOCK_NB);
    if (res == -1) {
        ALOGD("flock try_lock fail: fd[%d]", m_fd);
    }
    return res == 0;
}
inline bool FileLock::unlock() {
    if (!isFileLockValid()) {
        return false;
    }
    int res = flock(m_fd, LOCK_UN);
    if (res == -1) {
        ALOGD("flock unlock fail: fd[%d]", m_fd);
    }
    return res == 0;
}
typedef FileLock::Autolock AutoFileLock;
#endif //MMIPC_FILELOCK_H

然后调用如下

void MMIPC::setData(const string &key, const string &value) {
//    AutoMutex autoMutex(m_mutex_lock);
    // 加文件锁
    AutoFileLock autoFileLock(m_file_lock, ExclusiveLockType);
    string content = key + ":" + value + ",";
//    ALOGD("setData content=%s", content.c_str());
    size_t numberOfBytes = content.length();
    if (m_position + numberOfBytes > m_file_size) {
        auto msg = "m_position: " + to_string(m_position) + ", numberOfBytes: " +
                   to_string(numberOfBytes) +
                   ", m_file_size: " + to_string(m_file_size);
        throw out_of_range(msg);
    }
    m_position = strlen(m_ptr);
    memcpy(m_ptr + m_position, (void *) content.c_str(), numberOfBytes);
//    ALOGD("setData success m_ptr.len=%d", m_position + numberOfBytes);
}

运行一下，看看如何

2022-07-24 13:36:29.715 28670-28670/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc 日志： init
2022-07-24 13:36:29.716 28670-28670/com.zzy.mmipc D/MMIPC->: root dir /data/user/0/com.zzy.mmipc/files
2022-07-24 13:36:29.716 28670-28670/com.zzy.mmipc D/MMIPC->: open success for mutex: fd[75], /data/user/0/com.zzy.mmipc/files/default_mutex.ipc
2022-07-24 13:36:29.716 28670-28670/com.zzy.mmipc E/MMIPC->: pid[28670]
2022-07-24 13:36:29.717 28670-28670/com.zzy.mmipc D/MMIPC->: open m_fd[75], /data/user/0/com.zzy.mmipc/files/default_mmap.ipc
2022-07-24 13:36:29.717 28670-28670/com.zzy.mmipc D/MMIPC->: m_fd size[0]
2022-07-24 13:36:29.717 28670-28670/com.zzy.mmipc D/MMIPC->: getFileSize m_file_size 0, default_mmap_size 4194304
2022-07-24 13:36:29.717 28670-28670/com.zzy.mmipc D/MMIPC->: mmap success
2022-07-24 13:36:29.929 28670-28670/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc 日志： set data
2022-07-24 13:36:30.414 28737-28737/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc:childProcess 日志： init
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: root dir /data/user/0/com.zzy.mmipc/files
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: open success for mutex: fd[76], /data/user/0/com.zzy.mmipc/files/default_mutex.ipc
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc E/MMIPC->: pid[28737]
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: open m_fd[76], /data/user/0/com.zzy.mmipc/files/default_mmap.ipc
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: m_fd size[4194304]
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: getFileSize m_file_size 4194304, default_mmap_size 4194304
2022-07-24 13:36:30.415 28737-28737/com.zzy.mmipc D/MMIPC->: mmap success
2022-07-24 13:36:38.311 28737-28737/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc:childProcess 日志： 1463520
2022-07-24 13:36:51.944 28670-28670/com.zzy.mmipc D/MMIPC->: 进程：com.zzy.mmipc 日志： 1800000

好的，18万，完美。是不是可结束了？其实光有flock是不行的，还需要线程同步，这里又用到了mutex的线程锁，可以往上翻一翻看下，今天就到此结束。

总结

多线程如何保持结果一致性，我们做了两种实现方式：

  • Looper 实现
  • mutex 互斥锁

多进程如何保持结果一致性，我们做了三种：

  • Semaphores 找了大量的示例，没有测试成功，抱歉
  • mutext 实现了跨进程的互斥锁，但它无法保证robust，意思是在进程出现异常死掉时，无法释放锁，导致其他进程无法再次获取，从而产生不可预估的问题
  • flock 实现了跨进程的文件锁，但需要配合mutex线程锁来解决多线程问题

总之，目前为止，我们搞定了mmap的跨线程以及跨进程同步的问题，接下来就可以考虑如何设计传输的数据结构，下期我们来用pb做载体，体验pb的魅力。

源码地址

github.com/ibaozi-cn/m…

文章标签：
日志服务
Linux
关键词：
线程进程
线程多进程
进程mmap
线程mmap
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
i校长
目录
相关文章
jianz123
|
24天前
|
消息中间件 并行计算 安全
进程、线程、协程
【10月更文挑战第16天】进程、线程和协程是计算机程序执行的三种基本形式。进程是操作系统资源分配和调度的基本单位，具有独立的内存空间，稳定性高但资源消耗大。线程是进程内的执行单元，共享内存，轻量级且并发性好，但同步复杂。协程是用户态的轻量级调度单位，适用于高并发和IO密集型任务，资源消耗最小，但不支持多核并行。
jianz123
39 1
叫个什么名字
|
3天前
|
并行计算 数据处理 调度
Python中的并发编程：探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程，通过对比分析它们的工作原理、适用场景及性能差异，揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念，随后详细阐述了Python中多线程与多进程的实现机制，包括GIL（全局解释器锁）对多线程的影响以及多进程的独立内存空间特性。最后，通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
叫个什么名字
15 5
肥猪肥猪-17824
|
8天前
|
Linux 调度 C语言
深入理解操作系统：进程和线程的管理
【10月更文挑战第32天】本文旨在通过浅显易懂的语言和实际代码示例，带领读者探索操作系统中进程与线程的奥秘。我们将从基础知识出发，逐步深入到它们在操作系统中的实现和管理机制，最终通过实践加深对这一核心概念的理解。无论你是编程新手还是希望复习相关知识的资深开发者，这篇文章都将为你提供有价值的见解。
肥猪肥猪-17824
41 5
Skyund
|
5天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程，是系统运行的基本单位，因此进程是动态的。系统运行一个程序即是一个进程从创建，运行到消亡的过程。简单来说，一个进程就是一个执行中的程序，它在计算机中一个指令接着一个指令地执行着，同时，每个进程还占有某些系统资源如CPU时间，内存空间，文件，文件，输入输出设备的使用权等等。换句话说，当程序在执行时，将会被操作系统载入内存中。 线程 线程，与进程相似，但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源，所以系统在产生一个线程，或是在各个线程之间做切换工作时，负担要比
Skyund
14 1
shuj
|
10天前
深入理解操作系统：进程与线程的管理
【10月更文挑战第30天】操作系统是计算机系统的核心，它负责管理计算机硬件资源，为应用程序提供基础服务。本文将深入探讨操作系统中进程和线程的概念、区别以及它们在资源管理中的作用。通过本文的学习，读者将能够更好地理解操作系统的工作原理，并掌握进程和线程的管理技巧。
shuj
23 2
游客qf4jmczx4xu2y
|
12天前
|
调度 Python
深入浅出操作系统：进程与线程的奥秘
【10月更文挑战第28天】在数字世界的幕后，操作系统悄无声息地扮演着关键角色。本文将拨开迷雾，深入探讨操作系统中的两个基本概念——进程和线程。我们将通过生动的比喻和直观的解释，揭示它们之间的差异与联系，并展示如何在实际应用中灵活运用这些知识。准备好了吗？让我们开始这段揭秘之旅！
游客qf4jmczx4xu2y
24 1
蛋先生DX
|
1月前
|
存储 消息中间件 人工智能
进程，线程，协程 - 你了解多少？
本故事采用简洁明了的对话方式，尽洪荒之力让你在轻松无负担的氛围中，稍微深入地理解进程、线程和协程的相关原理知识
蛋先生DX
40 2
进程，线程，协程 - 你了解多少？
叫个什么名字
|
22天前
|
Python
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析，我们将了解何时使用多线程或多进程更为合适，并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。
叫个什么名字
43 2
jianz123
|
25天前
|
消息中间件 并行计算 安全
进程、线程、协程
【10月更文挑战第15天】进程、线程和协程是操作系统中三种不同的执行单元。进程是资源分配和调度的基本单位，每个进程有独立的内存空间；线程是进程内的执行路径，共享进程资源，切换成本较低；协程则更轻量，由用户态调度，适合处理高并发和IO密集型任务。进程提供高隔离性和安全性，线程支持高并发，协程则在资源消耗和调度灵活性方面表现优异。
jianz123
44 2
shuj
|
1月前
|
算法 安全 调度
深入理解操作系统：进程与线程的管理
【10月更文挑战第9天】在数字世界的心脏跳动着的，不是别的，正是操作系统。它如同一位无形的指挥家，协调着硬件与软件的和谐合作。本文将揭开操作系统中进程与线程管理的神秘面纱，通过浅显易懂的语言和生动的比喻，带你走进这一复杂而又精妙的世界。我们将从进程的诞生讲起，探索线程的微妙关系，直至深入内核，理解调度算法的智慧。让我们一起跟随代码的脚步，解锁操作系统的更多秘密。
shuj
35 1

热门文章

最新文章

  • 1
    为什么redis是单线程的以及为什么这么快？
  • 2
    多线程开发（二）
  • 3
    一个简单的C#多线程间同步的例子
  • 4
    使用UncaughtExceptionHandler重启线程
  • 5
    Python多线程编程之多线程加锁
  • 6
    多线程程序设计学习（4）guarded suspension模式
  • 7
    Linux多线程5-5_线程与fork
  • 8
    多线程中的临界区
  • 9
    线程同步中异常情况的处理
  • 10
    线程池系列三：ThreadPoolExecutor讲解
  • 1
    Python中的并发编程：理解多线程与多进程的区别与应用
    44
  • 2
    `subprocess`模块是Python中用于生成新进程、连接到它们的输入/输出/错误管道，并获取它们的返回（退出）代码的模块。
    52
  • 3
    在Python中，`multiprocessing`模块提供了一种在多个进程之间共享数据和同步的机制。
    53
  • 4
    `multiprocessing`是Python的一个标准库，用于支持生成进程，并通过管道和队列、信号量、锁和条件变量等同步原语进行进程间通信（IPC）。
    27
  • 5
    Python的`signal`模块提供了访问底层操作系统提供的信号机制的方式。信号是操作系统用来通知进程发生了某种情况（如用户按下Ctrl+C）的一种机制。
    38
  • 6
    linux进程状态基本语法
    36
  • 7
    【Linux】多线程——线程概念|进程VS线程|线程控制（下）
    65
  • 8
    【Linux】多线程——线程概念|进程VS线程|线程控制（上）
    68
  • 9
    【Linux】进程信号（下）
    36
  • 10
    【Linux】进程信号（上）
    43

    • 相关电子书

    更多
  • 服务上云加速大家居产业C2M进程
  • 多IO线程优化版
  • 多线程

    • 相关实验场景

    更多
  • 观察进程的并发性
    • 下一篇
    阿里云OSS设置跨域访问