Question

这是一个关于编码设计的问题，所以请原谅长代码清单：如果不显示实际代码，我无法恢复这些想法和潜在的陷阱。

我正在编写一个ConcurrentReferenceCounted类，并希望对我的实现提供一些反馈。此类的子类将收到“release”而不是直接删除。

这是班级：

class ConcurrentReferenceCounted : private NonCopyable {
 public:
  ConcurrentReferenceCounted() : ref_count_(1) {}

  virtual ~ConcurrentReferenceCounted() {}

  void retain() {
    ScopedLock lock(mutex_);
    ++ref_count_;
  }

  void release() {
    bool should_die = false;
    {
      ScopedLock lock(mutex_);
      should_die = --ref_count_ == 0;
    }
    if (should_die) delete this;
  }

 private:
  size_t ref_count_;
  Mutex mutex_;
};

这是一个范围保留：

class ScopedRetain {
public:
  ScopedRetain(ConcurrentReferenceCounted *object) : object_(object) {
    retain();
  }

  ScopedRetain() : object_(NULL) {}

  ~ScopedRetain() {
    release();
  }

  void hold(ConcurrentReferenceCounted *object) {
    assert(!object_); // cannot hold more then 1 object
    object_ = object;
    retain();
  }

private:
  ConcurrentReferenceCounted *object_;

  void release() {
    if (object_) object_->release();
  }

  void retain() {
    object_->retain();
  }
};

最后这是一个用例：

Object *target;
ScopedRetain sr;

if (objects_.get(key, &target))
  sr.hold(target);
else
  return;

// use target
// no need to 'release'

Answer 1

您的ConcurrentReferenceCounted似乎使用完整的互斥锁，这不是必需的，也不是非常快。可以使用依赖于体系结构的互锁指令以原子方式实现引用计数。在Windows下，InterlockedXXX系列函数只包含这些指令。

并发引用计数器类和范围保留：这样可以吗？

1 个答案: