c++ - C++：多线程和引用计数

Question

目前，我使用以下方法获得了一些引用计数类：

class RefCounted
{
public:
    void IncRef()
    {
        ++refCnt;
    }
    void DecRef()
    {
        if(!--refCnt)delete this;
    }
protected:
    RefCounted():refCnt(0){}
private:
    unsigned refCnt;
    //not implemented
    RefCounted(RefCounted&);
    RefCounted& operator = (RefCounted&};
};

我还有一个处理引用计数的智能指针类，尽管它没有统一使用（例如，在一个或两个性能关键代码中，我最小化了 IncRef 和 DecRef 调用的数量）。

template<class T>class RefCountedPtr
{
public:
    RefCountedPtr(T *p)
    :p(p)
    {
        if(p)p->IncRef();
    }
    ~RefCountedPtr()
    {
        if(p)p->DecRef();
    }
    RefCountedPtr<T>& operator = (T *newP)
    {
        if(newP)newP->IncRef();
        if(p)   p   ->DecRef();
        p = newP;
        return *this;
    }
    RefCountedPtr<T>& operator = (RefCountedPtr<T> &newP)
    {
        if(newP.p)newP.p->IncRef();
        if(p)     p     ->DecRef();
        p = newP.p;
        return *this;
    }
    T& operator *()
    {
        return *p;
    }
    T* operator ->()
    {
        return p;
    }
    //comparison operators etc and some const versions of the above...
private:
    T *p;
};

对于类本身的一般用途，我计划使用读取器/写入器锁定系统，但是我真的不想为每个单独的 IncRef 和 DecRef 调用获取写入器锁。

我还只是想到了在 IncRef 调用之前指针可能无效的情况，请考虑：

class Texture : public RefCounted
{
public:
    //...various operations...
private:
    Texture(const std::string &file)
    {
        //...load texture from file...
        TexPool.insert(this);
    }
    virtual ~Texture()
    {
        TexPool.erase(this);
    }
    freind CreateTextureFromFile;
};
Texture *CreateTexture(const std::string &file)
{
    TexPoolIterator i = TexPool.find(file);
    if(i != TexPool.end())return *i;
    else return new Texture(file);
}

线程A 线程B
t = CreateTexture("ball.png");
t->IncRef();
...使用 t... t2 = CreateTexture("ball.png");//返回 *t
...线程暂停...
t->DecRef();//删除t ...
... t2->IncRef();//错误

所以我想我需要完全改变引用计数模型，我在设计中返回后添加引用的原因是为了支持以下内容：

MyObj->GetSomething()->GetSomethingElse()->DoSomething();

而不必：

SomeObject a = MyObj->GetSomething();
AnotherObject *b = a->GetSomethingElse();
b->DoSomething();
b->DecRef();
a->DecRef();

在多线程环境中，C++ 中是否有一种快速引用计数的干净方法？

score 16 · Accepted Answer

使引用计数原子化，您将不需要任何锁。在 Windows 中可以使用 ::InterlockedIncrement 和 ::InterlockedDecrement。在 C++ 0x 中，你有 atomic<>。

score 10 · Accepted Answer

除非您知道这是我会使用的特定瓶颈boost::shared_ptr

它非常快，但是在分配的额外控制块中有一些额外的开销。另一方面，它有很多好处：

它是便携式的
它是正确的
你不必浪费你的心理周期，让你有时间真正完成工作
它很快
它是行业标准，其他程序员会立即理解它。
它迫使你使用boost如果你不是你应该使用的

另请注意，您可能不希望引用计数对象的读取器\写入器锁定。争用很小，额外的开销将完全压倒您将获得的任何好处。共享指针是通过芯片级原子 int 操作实现的，这比普通互斥锁要好得多，后者比读写锁要快得多。

score 6 · Accepted Answer

如果您不想使用 boost 或 C++0X，但仍需要无锁引用计数，则可以通过在代码中包含正确的特定于平台的 atomic-increment/atomic-decrement 汇编例程来实现。例如，这是我用于引用计数的 AtomicCounter 类；它适用于最常见的操作系统：

https://public.msli.com/lcs/muscle/html/AtomicCounter_8h_source.html

是的，这是一个令人讨厌的#ifdefs 混乱。但它确实有效。

score 2 · Accepted Answer

osg，OpenSceneGraph就有这样的结构。

你从 osg::Referenced 派生你的类，即使在多线程中你也不关心析构函数。

您只需将类创建为：

osg::ref_ptr<MyClass> m = new MyClass();

代替：

MyClass* m = new MyClass();

score 2 · Accepted Answer

你想要线程安全还是原子线程安全？boot::shared_ptr 仅仅是线程安全的。您仍然需要“拥有”一个 shared_ptr 才能安全地复制它。

我在 http://atomic-ptr-plus.sourceforge.net/上做了一些关于原子线程安全引用计数的实验性工作，可以让您了解所涉及的内容。

score 1 · Accepted Answer

boost::shared_ptr 和 Poco::SharedPtr 都将这个习语包装在一个独立的智能指针中。

如果您想要侵入式引用计数，正如您在上面所展示的，Poco 的 AutoPtr 是一个很好的工作实现。

编辑：我会添加链接，但我的声誉太低了。谷歌搜索任何类名，你应该找到自己的方式。

score 1 · Accepted Answer

您的主要问题是在 CreateTexture 返回之前您没有获得参考。如果您像这样进行开放编码，处理它的最简单方法是在 TexPool 周围设置一个锁，这在删除之前释放引用时也会使用，如下所示：

// PSEUDOCODE WARNING: --refcnt MUST be replaced by an atomic decrement-and-test
// Likewise, AddRef() MUST use an atomic increment.
void DecRef() {
    if (!--refcnt) {
        lock();
        if (!refcnt)
            delete this;
        unlock();
    }
}

和：

Texture *CreateTexture(const std::string &file)
{
    lock();

    TexPoolIterator i = TexPool.find(file);
    if(i != TexPool.end()) {
        *i->AddRef();
        unlock();
        return *i;
    }
    unlock();
    return new Texture(file);
}

也就是说，正如其他人所提到的，boost::shared_ptr（又名 std::tr1::shared_ptr）以无锁、安全的方式实现了这一切，并且还支持弱指针，这将有助于您的纹理缓存。

score 1 · Accepted Answer

1

您的缓存需要使用一个boost::weak_ptr或类似的构造。

于 2009-07-16T21:35:41.280 回答

score 0 · Accepted Answer

我认为您确实需要此特定设计的关键部分。需要它的地方之一是 CreateTexture，否则您将面临在系统中拥有多个相同纹理对象的风险。而且，一般来说，如果多个线程可以创建和销毁相同的纹理，它就会使其成为“可变共享状态”。

score 0 · Accepted Answer

看看这个 pdf：http ://www.research.ibm.com/people/d/dfb/papers/Bacon01Concurrent.pdf

这描述了一个不需要任何锁定的引用计数系统。（好吧，您需要一次“暂停”一个线程，这可以算作锁定。）它还收集垃圾周期。缺点是它要复杂得多。还有一些重要的事情留给读者作为练习。就像创建新线程或删除旧线程时会发生什么，或者如何处理固有的非循环对象。（如果你决定这样做，请告诉我你是如何解决这些问题的。）

c++ - C++：多线程和引用计数

10 回答 10

Related

Reference