【Linux】线程池|单例模式|STL、智能指针线程安全|读者写者问题

这是一个涉及到多个主题的问题，包括线程安全的读者-写者问题，单例模式，以及使用智能指针管理资源。以下是一个简化的示例代码，展示如何使用C++11的std::shared\_ptr和std::atomic来实现一个线程安全的单例对象池，并解决读者-写者问题。

#include <iostream>
#include <memory>
#include <mutex>
#include <atomic>
#include <list>
 
// 线程安全的对象池
template<typename T>
class ThreadSafeObjectPool {
private:
    std::list<std::shared_ptr<T>> pool;
    std::mutex mtx;
    std::atomic<bool> is_writing;
 
    ThreadSafeObjectPool(const ThreadSafeObjectPool&) = delete;
    ThreadSafeObjectPool& operator=(const ThreadSafeObjectPool&) = delete;
 
    static std::shared_ptr<ThreadSafeObjectPool<T>> instance;
 
protected:
    ThreadSafeObjectPool() : is_writing(false) {}
 
public:
    // 单例模式获取对象池实例
    static std::shared_ptr<ThreadSafeObjectPool<T>> getInstance() {
        if (!instance) {
            std::lock_guard<std::mutex> lock(mtx);
            if (!instance) {
                instance.reset(new ThreadSafeObjectPool<T>());
            }
        }
        return instance;
    }
 
    // 获取对象
    std::shared_ptr<T> getObject() {
        std::lock_guard<std::mutex> lock(mtx);
        if (pool.empty()) {
            // 如果没有可用对象，则创建一个新的对象
            return std::make_shared<T>();
        }
        auto obj = pool.front();
        pool.pop_front();
        return obj;
    }
 
    // 归还对象
    void returnObject(std::shared_ptr<T> obj) {
        std::lock_guard<std::mutex> lock(mtx);
        pool.push_back(obj);
    }
 
    // 写者请求访问
    void writerRequest() {
        while (is_writing.exchange(true)) {
            // 循环等待，直到没有其他写者
        }
    }
 
    // 写者完成访问
    void writerComplete() {
        is_writing.store(false);
    }
};
 
// 注意：以下代码需要C++11及以上支持
 
int main() {
    // 假设有一个需要线程安全的对象类型
    class Object {
    public:
        Object() { std::cout << "Object created" << std::endl; }
        ~Object() { std::cout << "Object destroyed" << std::endl; }
    };
 
    // 获取对象池实例
    auto pool = ThreadSafeObjectPool<Object>::getInstance();
 
    // 获取对象
    auto obj = pool->getObject();
 
    // 使用对象...
 
    // 归还对象
    pool->returnObject(obj);
 
    return 0;
}

这个代码示例展示了如何使用std::atomic来避免读者-写者问题，以及如何使用std::shared\_ptr和std::list来创建一个线程安全的对象池。这个对象池可以在多线程环境中安全地获取和归还对象，而不会引发数据竞争或内存泄漏。