c – 线程安全内存池

正如您在更新中所暗示的,您需要有效地管理免费/有效的使用.这是一个非常简单的问题,给定一个恒定的类型并不是并发的.

例如(从我的头顶部,未经测试)：

template<typename T>
class ThreadStorage
{
    std::vector<T> m_objs;
    std::vector<size_t> m_avail;

public:
    explicit ThreadStorage(size_t count) : m_objs(count,T()) {
        m_avail.reserve(count);
        for (size_t i = 0; i < count; ++i) m_avail.push_back(i);
    }

    T* alloc() {
        T* retval = &m_objs[0] + m_avail.back();
        m_avail.pop_back();
        return retval;
    }

    void free(T* p) {
        *p = T(); // Assuming this is enough destruction.
        m_avail.push_back(p - &m_objs[0]);
    }
};

然后,对于每个线程,都有一个ThreadStorage实例,并根据需要调用alloc()和free().

您可以添加智能指针来管理您的自由(),如果昂贵,您可以优化构造函数/析构函数调用.

你也可以看看boost :: pool.

更新：

跟踪已经被使用的东西,以便可以在第二次通过处理的新要求似乎对我来说有些不清楚.我想你的意思是当一个对象上的主处理完成时,你不需要释放它,但是请继续参考它进行第二阶段的处理.一些对象,您将被释放回池,不用于第二阶段处理.

我假设你想在同一个线程中这样做.

作为第一遍,您可以向ThreadStorage添加一个这样的方法,当您想对所有未发布的T实例进行处理时调用它.不需要额外的书本保留.

void do_processing(boost::function<void (T* p)> const& f) {
    std::sort(m_avail.begin(),m_avail.end());

    size_t o = 0;
    for (size_t i = 0; i != m_avail.size(); ++i) {
        if (o < m_avail[i]) {
            do {
                f(&m_objs[o]);
            } while (++o < m_avail[i]);
            ++o;
        } else of (o == m_avail[i])
            ++o;
    }

    for (; o < m_objs.size(); ++o) f(&m_objs[o]);
}

假设没有其他线程正在使用ThreadStorage实例,这是合理的,因为它是线程本地的设计.再次,我的头顶,未经测试.