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);
}

ThreadA                                ThreadB
t = CreateTexture("ball.png");
t->IncRef();
...use t...                            t2 = CreateTexture("ball.png");//returns *t
...                                    thread suspended...
t->DecRef();//deletes t                ...
...                                    t2->IncRef();//ERROR

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

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

而不是：

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

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

Answer 1

使引用计数为原子，您不需要任何锁定。在Windows :: InterlockedIncrement和:: InterlockedDecrement可以使用。在C ++ 0x中，您有原子＆lt;＆gt;。

Answer 2

除非你知道这是一个特定的瓶颈，否则我只会使用boost::shared_ptr

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

便携式
这是正确的
你不必浪费你的心理周期，让你有时间实际完成任务
很快
这是行业标准，其他程序员会立即理解它。
强迫您使用boost如果您不是，那么

另请注意，您可能不希望读取器/写入器锁定引用计数对象。争用很少，额外的开销将完全压倒你所拥有的任何好处。共享指针使用芯片级原子int操作实现，这明显优于普通互斥锁，后者明显快于读取器/写入器锁。

Answer 3

如果您不想使用boost或C ++ 0X，但仍需要无锁引用计数，则可以通过在代码中包含正确的特定于平台的原子增量/原子减量程序集例程来实现。举个例子，这是我用于引用计数的AtomicCounter类;它适用于最常见的操作系统：

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

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

Answer 4

osg，OpenSceneGraph有这样的结构。

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

你只需创建类：

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

而不是：

MyClass* m = new MyClass();

Answer 5

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

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

Answer 6

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

如果您想进行侵入式引用计数，正如您在上面所说明的那样，Poco的AutoPtr是一个很好的工作实现。

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

Answer 7

您的主要问题是您在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）以无锁，安全的方式实现了这一切，并且还支持弱指针，这将有助于你的纹理缓存

Answer 8

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

Answer 9

我认为你确实需要这个特定设计的关键部分。需要的地方是CreateTexture，因为否则您将面临在系统中具有多个相同纹理对象的风险。而且，通常，如果多个线程可以创建并销毁相同的纹理，则会使其成为“可变共享状态”。

Answer 10

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

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

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

10 个答案: