基于Boost线程库实现Java中atomic…

最新推荐文章于 2025-02-16 18:43:04 发布

Runyon1982

最新推荐文章于 2025-02-16 18:43:04 发布

阅读量539

点赞数

CC 4.0 BY-SA版权

分类专栏： c/cpp

本文链接：https://blog.youkuaiyun.com/runyon1982/article/details/49018803

c/cpp 专栏收录该内容

96 篇文章

订阅专栏

本文介绍了一个简单的Boost库原子操作类的实现，该实现模仿了Java的java.util.concurrent.atomic包的功能，提供了基本的锁自由线程安全编程支持。文章中包含了Atomic和AtomicInteger两个类的具体实现代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

    Java的java.util.concurrent.atomic包的说明是“ A small toolkit of classes that support lock-free thread-safe programming on single variables”。挺贴切的。是实际多线程编程时很方便的一组类。最近我使用boost里的thread库模仿实现了下，没有单元测试，但应该是正确的。因为它是如此简单以至于肉眼就能看出是否正确了。注意：我模仿的只是外部接口和功能，具体实现不是lock-free的，效率会低一些。
    实现了两个类：Atomic（模板类，基本使用它)和AtomicInteger（继承了Atomic，额外提供++、--等整形操作）。
    技术含量很低，但又很实用的两个类。我觉得boost::thread库如果能够实现下java.util.concurrent提供的众多基础设施，对并发编程肯定很有帮助。

===================华丽的代码分割线====================
#pragma once

#include <boost/thread.hpp>

template <class T>
class Atomic
{
public:
    Atomic()
        : val()
    {
    }

    Atomic(T val_)
        : val(val_)
    {
    }

    virtual ~Atomic(){}

    void set(T val_)
    {
        boost::mutex::scoped_lock lock(mtx);
        val = val_;
    }

    T get()
    {
        boost::mutex::scoped_lock lock(mtx);
        return val;
    }

    bool updateTo(T update)
    {
        boost::mutex::scoped_lock lock(mtx);
        if (val != update)
        {
            val = update;
            return true;
        }
        return false;
    }

    bool compareAndSet(T expect, T update)
    {
        boost::mutex::scoped_lock lock(mtx);
        if (val == expect)
        {
            val = update;
            return true;
        }
        return false;
    }

    T getAndSet(T update)
    {
        boost::mutex::scoped_lock lock(mtx);
        T tmp = val;
        val = update;
        return tmp;
    }

protected:

    T val;
    boost::mutex mtx;
};

class AtomicInteger
    : public Atomic<int>
{
public:
    AtomicInteger()
        : Atomic<int>(0)
    {
    }

    AtomicInteger(int val_)
        : Atomic<int>(val_)
    {
    }

    bool operator==(int comp)
    {
        boost::mutex::scoped_lock lock(mtx);
        return (val == comp);
    }

    int operator++(int)
    {
        boost::mutex::scoped_lock lock(mtx);
        return (val++);
    }

    int operator++()
    {
        boost::mutex::scoped_lock lock(mtx);
        return (++val);
    }

    int operator--(int)
    {
        boost::mutex::scoped_lock lock(mtx);
        return (val--);
    }

    int operator--()
    {
        boost::mutex::scoped_lock lock(mtx);
        return (--val);
    }

    void operator+=(int delta)
    {
        boost::mutex::scoped_lock lock(mtx);
        val += delta;
    }

    void operator-=(int delta)
    {
        boost::mutex::scoped_lock lock(mtx);
        val -= delta;
    }

};