当前位置:

首页 > 编程开发 > C++之写时复制(CopyOnWrite)原理详解

C++之写时复制(CopyOnWrite)原理详解

写时复制通过浅拷贝与引用计数实现,读操作共享数据,写操作时创建副本。QString、QImage等Qt类利用该技术减少内存拷贝,提升性能,且并发读操作无需阻塞。

本文目录

    1.简介

    先聊一个非常经典的编程思想:CopyOnWrite(COW)。它的核心思路其实很简单——如果多个对象或变量共享同一份数据,那大家就先共用着,没必要每个对象都单独拷贝一份。只有到真正需要修改数据的时候,才去创建一个副本,在副本上动手脚,原始数据则保持不动。

    这种思路在处理那些很少变动、或者天生不可变的数据结构时,效果尤其显著。通过共享来避免不必要的复制,既省内存又提性能。举个典型的例子:Linux 系统中,fork 系统调用创建子进程时,并不会一股脑儿把父进程的所有内存页都复制一份。父子进程先共用同一块内存页,只有当其中一方真的要去修改某个内存页时,才触发真正的复制。如果两方都只是读,那性能优势就体现出来了。

    Qt 里的 QString,也正是这一思想的忠实实践者。日常操作中,读操作随意进行,完全不需要加锁。只有到了写操作的关键时刻,它才会从原始数据中复制出一个副本,修改完毕后再将原数据替换掉。更有意思的是,在修改进行的过程中,读操作并不会被阻塞,而是继续读取旧的数据——这一点对于并发场景来说非常友好。

    2.实现原理

    写时复制的本质,说白了就是“浅拷贝 + 引用计数”。读操作时走浅拷贝,写操作时才触发深拷贝。而引用计数的作用,就是记录当前有多少个指针共享同一块内存空间。

    2.1 QString之写时复制

    当两个QString发生复制或赋值时,并不会真的拷贝字符串内容。它只是增加一次引用计数,然后让字符串指针做一次浅拷贝。这一步的时间复杂度是O(1)。只有后续真正要去修改某个字符串内容时,才会执行那个代价较高的实际复制。

    C++之写时复制(CopyOnWrite)原理详解

    2.2 引用计数

    引用计数本身放在堆区,通常和数据紧挨着放在一起。而且最佳实践是把它放在数据的前面——这样数据内容发生变化时,不会影响到引用计数的位置。

    C++之写时复制(CopyOnWrite)原理详解

    3.QString的实现分析

    3.1 内部结构

    QString 的底层数据结构是 QTypedArrayData,这一点从源码中可以直接看到:

    template 
    struct QTypedArrayData
        : QArrayData
    {
        ...
    };
    
    typedef QTypedArrayData QStringData;
    
    class Q_CORE_EXPORT QString
    {
    public:
        typedef QStringData Data;
        ...
        Data*  d;  //真正存储QString数据的对象
    };

    而 QTypedArrayData 继承自 QArrayData。

    struct Q_CORE_EXPORT QArrayData
    {
        QtPrivate::RefCount ref;  //引用计数
        int size;
        uint alloc : 31;
        uint capacityReserved : 1;
    
        qptrdiff offset; // in bytes from beginning of header
    
        void *data()
        {
            Q_ASSERT(size == 0
                    || offset < 0 || size_t(offset) >= sizeof(QArrayData));
            return reinterpret_cast(this) + offset;
        }
    
        const void *data() const
        {
            Q_ASSERT(size == 0
                    || offset < 0 || size_t(offset) >= sizeof(QArrayData));
            return reinterpret_cast(this) + offset;
        }
        ...
    };

    可以看到,QArrayData 里有一个 QtPrivate::RefCount 类型的成员变量 ref,它记录这块内存被引用的次数。正因为这个设计,QString 才能用 Copy On Write 技术来优化字符串内存的管理。

    3.2 写入时复制

    QtPrivate::RefCount 的核心作用就是保存并管理引用计数,源码走一波:

    class RefCount
    {
    public:
        inline bool ref() Q_DECL_NOTHROW {  //增加引用计数
            int count = atomic.load();
    #if !defined(QT_NO_UNSHARABLE_CONTAINERS)
            if (count == 0) // !isSharable
                return false;
    #endif
            if (count != -1) // !isStatic
                atomic.ref();
            return true;
        }
    
        inline bool deref() Q_DECL_NOTHROW { //减少引用计数
            int count = atomic.load();
    #if !defined(QT_NO_UNSHARABLE_CONTAINERS)
            if (count == 0) // !isSharable
                return false;
    #endif
            if (count == -1) // isStatic
                return true;
            return atomic.deref();
        }
        ...
        QBasicAtomicInt atomic;  //原子变量
    };

    再看赋值操作符的源码:

    QString &QString::operator=(const QString &other) Q_DECL_NOTHROW
    {
        other.d->ref.ref();    //other增加引用计数 [1]
        if (!d->ref.deref())    //自己减少引用计数 [2]
            Data::deallocate(d); //如果自己计数为0则释放内存 [3]
        d = other.d;            //直接指针赋值 [4]
        return *this;
    }

    通过这四步,赋值操作就完成了。对比一下传统的深拷贝:

    class String{
    public:
       String(const String &rhs):m_pstr(new char[strlen(rhs) + 1]()){
       }
    private:
       char* m_pstr;
    };

    显然,COW 省去了内存申请和实际拷贝的开销,运行效率的提升是肉眼可见的。

    再看 QString 的 append 方法,同样遵循了 COW 的套路:

    QString &QString::append(const QString &str)
    {
        if (str.d != Data::sharedNull()) {
            if (d == Data::sharedNull()) {
                operator=(str);
            } else {
                if (d->ref.isShared() || uint(d->size + str.d->size) + 1u > d->alloc)
                    reallocData(uint(d->size + str.d->size) + 1u, true);
                memcpy(d->data() + d->size, str.d->data(), str.d->size * sizeof(QChar));
                d->size += str.d->size;
                d->data()[d->size] = '';
            }
        }
        return *this;
    }

    而 reallocData 函数则是 COW 执行的关键入口——在需要写入数据时,它会重新分配内存,在新内存上增加计数,并减少原内存的引用计数。这才是 COW 思想的精髓所在。

    void QString::reallocData(uint alloc, bool grow)
    {
        auto allocOptions = d->detachFlags();
        if (grow)
            allocOptions |= QArrayData::Grow;
    
        if (d->ref.isShared() || IS_RAW_DATA(d)) {
            Data *x = Data::allocate(alloc, allocOptions);
            Q_CHECK_PTR(x);
            x->size = qMin(int(alloc) - 1, d->size);
            ::memcpy(x->data(), d->data(), x->size * sizeof(QChar));
            x->data()[x->size] = 0;
            if (!d->ref.deref())
                Data::deallocate(d);
            d = x;
        } else {
            Data *p = Data::reallocateUnaligned(d, alloc, allocOptions);
            Q_CHECK_PTR(p);
            d = p;
        }
    }

    4.QImage中的写时拷贝分析

    对于像 QImage 这样通常占用内存较大的类型,写时拷贝的意义就更大了。整个流程可以用这个图来理解:

    C++之写时复制(CopyOnWrite)原理详解

    • 第一次创建 imgA 时,会生成一个 QImage 外壳和一份真正的 QImageData。外壳就是 QImage 类本身,数据则是 QImageData 类型,通过 d_ptr 指向。
    • 当 imgB 要拷贝 imgA 时,并不会复制 imagedata。它只是创建一个新的外壳 wrapperimgB,然后让 d_ptr 指向 imgA 的 imagedata,并把引用计数 ref 加 1。此时两个外壳共享同一份数据。
    • 而当 imgB 真正要进行写操作时,会先触发 detach 操作:把 imgdata 拷贝一份,让 wrapperimgB 的 d_ptr 指向新的那份数据,并调整引用计数。至此,两个外壳才算真正解耦,之后各改各的。

    关键函数一览:

    构造函数,第一次构造时通过 QImageData::create() 创建原生的 imgdata。

    QImage::QImage(uchar* data, int width, int height, Format format, QImageCleanupFunction cleanupFunction, void *cleanupInfo)
        : QPaintDevice()
    {
        d = QImageData::create(data, width, height, 0, format, false, cleanupFunction, cleanupInfo);
    }

    拷贝构造与赋值构造:先判断被拷贝的 QImage 是否处于绘制状态。如果正在绘制,那就意味着数据可能会变化,直接走深拷贝。否则让新外壳指向同一份 imgdata,共用一个数据。

    赋值时还需要处理左值原来的引用计数——将之前指向的 imgdata 引用计数减一。如果减到零,就释放那块内存。

    QImage::QImage(const QImage &image)
        : QPaintDevice()
    {
        if (image.paintingActive() || isLocked(image.d)) {
            d = 0;
            image.copy().swap(*this);
        } else {
            d = image.d;
            if (d)
                d->ref.ref();
        }
    }
    
    QImage &QImage::operator=(const QImage &image)
    {
        if (image.paintingActive() || isLocked(image.d)) {
            operator=(image.copy());
        } else {
            if (image.d)
                image.d->ref.ref();
            if (d && !d->ref.deref())
                delete d;
            d = image.d;
        }
        return *this;
    }

    析构时也是把引用计数减一,计数归零则释放内存。

    QImage::~QImage()
    {
        if (d && !d->ref.deref())
            delete d;
    }

    detach 函数则在写操作触发时被调用。核心流程就是拷贝一份 imgdata,让当前需要 detach 的 QImage 的 d_ptr 指向那份新数据。

    void QImage::detach()
    {
        if (d) {
            if (d->is_cached && d->ref.load() == 1)
                QImagePixmapCleanupHooks::executeImageHooks(cacheKey());
    
            if (d->ref.load() != 1 || d->ro_data)
                *this = copy();
    
            if (d)
                ++d->detach_no;
        }
    }

    以 setDevicePixelRatio 为例,它属于数据写操作,所以会先过 detach 生成独立数据,然后才去修改:

    void QImage::setDevicePixelRatio(qreal scaleFactor)
    {
        if (!d)
            return;
    
        if (scaleFactor == d->devicePixelRatio)
            return;
    
        detach();
        if (d)
            d->devicePixelRatio = scaleFactor;
    }

    如果未来需要设计类似的大内存数据类型,完全可以参考 QImage 的写时拷贝机制,自己做一套类似的实现。

    5.示例分析

    C++ 标准库本身并没有直接提供写入时复制的容器,但只要愿意,自定义实现并不复杂。下面是一个写入时复制的数组示例:

    #include   
    #include   
    #include   
      
    template   
    class CopyOnWriteArray {  
    private:  
        std::shared_ptr> data;  
      
    public:  
        CopyOnWriteArray() : data(std::make_shared>()) {}  
      
        size_t size() const {  
            return data->size();  
        }  
      
        const T& operator[](size_t index) const {  
            return (*data)[index];  
        }  
      
        void set(size_t index, const T& value) {  
            if (data.unique()) {  
                // 当前是唯一持有者,无需复制  
            } else {  
                // 否则,创建新副本  
                data = std::make_shared>(*data);  
            }  
            (*data)[index] = value;  
        }  
      
        void push_back(const T& value) {  
            if (data.unique()) {  
                data->push_back(value);  
            } else {  
                data = std::make_shared>(*data);  
                data->push_back(value);  
            }  
        }  
    };  
      
    int main() {  
        CopyOnWriteArray array;  
        array.push_back(1);  
        array.push_back(2);  
        array.push_back(3);  
        std::cout << "Size: " << array.size() << std::endl;  
        std::cout << "Element at index 1: " << array[1] << std::endl;  
        array.set(1, 100); // 写入时复制发生在这里  
        std::cout << "Element at index 1 after modification: " << array[1] << std::endl;  
        return 0;  
    }

    这个 CopyOnWriteArray 类用 std::shared_ptr 来管理底层数据的生命周期。多个对象共享同一个 std::vector 时,如果其中一个要修改数据,就会触发写入时复制。背后的逻辑是:修改前检查 shared_ptr 的引用计数,如果大于1,就创建一个新的 std::vector 副本,然后在新副本上修改。这样一来,其他仍然引用原始数据的对象不会受到任何影响。

    6.使用场景

    写入时复制最适合的场景,当然是高并发读操作、写操作相对较少的场景。尤其是在“读远超于写”的情况下,它的优势非常突出。下面这些场景都很典型:

    • 并发容器:实现线程安全的容器时,如果读操作远多于写操作,可以用写入时复制。读取数据不需要加锁,并发读取效率很高。只有写入时才会复制数据并做修改,确保线程安全。
    • 共享不可变数据:多个线程或进程需要共享一些很少变化的数据。更新时可以用写入时复制创建新副本并修改,其他线程仍然可以安全访问原始数据。
    • 事件处理系统:事件驱动系统中,多个处理函数可能同时处理不同事件。如果事件数据在处理过程中不会被修改,用写入时复制的容器存储数据,每个处理函数都可以安全读取,不用担心数据竞争。
    • 日志记录:日志系统里,日志信息大多是写一次、读很多次。用写入时复制的容器存储日志,多个线程可以同时写入不同条目,复杂同步操作大大减少。

    不过也得注意,如果写操作很频繁或者数据量特别大,写入时复制的内存开销和性能反而会下降。所以在决定使用前,一定要评估好读写比例、数据规模以及性能要求。另外,实现时务必把引用计数和内存管理搞对,避免出现内存泄漏之类的麻烦。

    7.总结

    CopyOnWrite 思想的核心价值在于:

    • 内存效率:多个对象共享相同数据,避免不必要的数据复制。对大型数据结构或者多个对象需要引用相同数据的情况,节省内存的效果非常可观。
    • 性能优化:数据很少修改时,性能提升相当明显。读操作不加锁,多个线程可以同时访问共享数据,并发效率很高。对于那些读多写少的数据(比如配置、黑名单、物流地址等),写入时复制几乎就是无锁的解决方案,可以帮程序实现更高的并发。
    • 减少数据拷贝:读时共享,写时才真正复制。不必要的拷贝开销被降到最低。

    当然,Write 时复制也不是银弹:

    • 写操作开销:一旦有写操作,就要复制数据。复制大型结构体消耗的时间和内存都不容小觑,频繁的写操作会严重拖累性能。
    • 不适合频繁修改的场景:正因为每次写都要复制,写操作一多,性能就下来了。对于需要频繁修改数据的场景,还是另寻更合适的数据结构或算法吧。

    总的来说,CopyOnWrite 非常适合“大量读取、少量写入”的场景,在内存效率和线程安全并发访问方面表现优异。只不过选择和权衡之间,需要针对具体的应用场景量体裁衣。

    本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系bd@zhengruan.com
    作者最新文章
    编程开发
    相关文章 更多
    QQ影音怎么加速播放视频课程
    QQ影音怎么加速播放视频课程

    播放时右键选播放速度,或点控制条倍速,1.25 到 1.5 倍看课最舒服;公式代码类内容别超过 1.25 倍。

    企业微信创建企业提示失败怎么办 实名与填写检查
    企业微信创建企业提示失败怎么办 实名与填写检查

    先看提示属于哪类:名称占用就加后缀,实名不一致就重填本人信息,证件不清晰就重拍。统一社会信用代码逐位核对,连续三次失败别改材料重投,直接联系客服人工核。

    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?
    Modern Web Guidance 的 legacy-scan 反转建议应该怎样判断?

    说明源码提交对字符串、生成器和数组的识别边界,以及扫描命令与发行包核验限制。

    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?
    Codex 0.170.0 正式版的语音与连接更新,适用范围有哪些限制?

    0.170.0 的语音更新限于终端通话协商能力的明确新增,同名工具服务器跨环境支持仍标注实验性质;连接部分则修复大请求回退、认证竞态和云端重连等具体问题。这份正式版公告不足以证明所有账户、所有客户端都已具备完整语音功能。

    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?
    Hy4 flash 三种权重怎么选,安装和授权要注意哪些条件?

    了解Hy4 flash、FP8与base的适用任务,阅读官方安装及图文代码,并核对资源和MaaS许可条件。

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化
    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化

    OpenAI Python SDK 3.55.0 升级看点:Live MCP 服务配置与预算接口变化。说明已核实的更新范围、类型兼容性和本地版本确认方法。

    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?
    OpenAI Java SDK 4.108.0 的两项新增能力适合哪些项目?

    OpenAI Java SDK 4.108.0 面向 Live MCP 工具接入与 Managed Agents 预算状态处理,说明新增模型、事件含义、正式发布范围和适用限制。

    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?
    Free Claude Code 6.19.37 如何兼顾网页搜索与普通工具调用?

    Free Claude Code 6.19.37 在自动搜索时保留客户端工具及选择条件,代理执行搜索后仍返回普通调用。说明适用场景、历史信息保留、请求约束与第三方项目的版本边界。

    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?
    Google GenAI Go SDK 1.78.0 的 v1beta 配置优先级怎样判断?

    Google GenAI Go SDK 1.78.0 将 Gemini Developer API 默认改为 v1,可用 HTTPOptions.APIVersion 或环境变量保留 v1beta,Vertex AI 默认值不变。

    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?
    Google GenAI SDK 3.5.0实时交互值得哪些项目升级评估?

    解释实验性实时支持、环境检查与生产评估中需要验证的条件。

    查看更多
    精品专题 更多
    装机必备
    装机必备

    正软商城装机必备专区,精选办公、浏览器、安全防护、影音播放、压缩解压、设计创作和系统工具等电脑常用正版软件,帮助用户快速完成新电脑软件配置。

    Windows
    Windows

    正软商城Windows软件专区,汇集适用于Windows电脑的办公、设计、安全防护、影音播放、开发工具和系统优化软件,提供软件介绍、系统要求、正版授权及购买下载服务。

    PDF教程
    PDF教程

    正软商城PDF教程频道提供PDF编辑、转换、合并、拆分、压缩及格式处理方法,同时介绍常用PDF软件和工具的使用技巧。

    Mac软件 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    Aperty macOS版
    Aperty macOS版
    macOS

    Aperty 是 Skylum 推出的 AI 人像修图软件,支持自然肤质修饰、瑕疵处理、面部与身体调整、预设及批量同步。

    WINDOWS 更多
    讯飞智作 网页版
    讯飞智作 网页版
    Windows/ macOS/ Linux

    讯飞智作是一款基于语音合成技术、虚拟人驱动技术与数字人形象声音构建能力的 AI 数字人音视频创作平台。

    火山引擎 网页版
    火山引擎 网页版
    Windows/ macOS/ Linux

    火山引擎是字节跳动旗下企业级云与AI服务平台。聚焦大模型核心能力,依托字节自研豆包多模态大模型,凭借火山方舟一站式平台,提供模型精调、推理部署、智能应用搭建等全链路服务,结合高性能AI算力,助力各行业快速落地大模型数字化与智能化应用。

    PixTV 网页版
    PixTV 网页版
    Windows

    PixTV 是一款在浏览器中使用的 AI 视觉内容创作平台,提供图片、视频、音频、文字生成、AI 分镜、局部重绘、提示词反推和无限画布等工具,适合短剧、漫剧、广告及社交媒体内容制作。