我有一个日志系统，它基本上使用线程本地缓冲区来记录。这有助于减少锁定。可以将一堆消息写入线程本地缓冲区并一次性刷新。而且由于它是线程本地的，我们可以避免为每个日志消息分配缓冲区。

无论如何，问题是在进程退出期间。我们在访问线程本地缓冲区时看到崩溃。

我拥有的线程本地对象类似于std::vector<Buffer>. [vector因为有多个缓冲区]。代表性的代码是这样的。

Buffer* getBuffer (int index)
{
    static thread_local auto buffers =    std::make_unique<std::vector<Buffer>>();
    return buffers ? buffers->at(index) : nullptr;
}

现在，当程序退出并调用全局析构函数时，不幸的是其中一些会记录。析构函数是从主线程调用的（否则不执行任何操作）。因此，当第一个全局对象被销毁并调用记录器时，会创建 thread_local 缓冲区，但它会立即被销毁，因为对象以与创建相反的顺序被销毁，并且这是创建的最后一个静态对象。当下一个全局对象析构函数调用记录器时，它正在有效地访问被破坏的对象，我认为这就是问题所在。

但我查看了 unique_ptr 析构函数，它确实将其内部的指针设置为 nullptr [或者至少将指针设置为默认构造的指针 - 我相信其值初始化为零？？]。所以我的return buffers ? buffers->at(index) : nullptr;检查应该阻止访问已释放的对象，不是吗？

我创建了一个玩具程序来尝试这个，我发现buffers ?检查确实阻止了访问。但在真实的代码库中，这种情况并没有发生。在崩溃时，访问的向量已经是烤面包了。

现在，如果有人能告诉我一个神奇的解决方案，它会让我的生活变得轻松:-)。否则任何想法为什么bool的运算符unique_ptr不返回false。是因为它是访问被破坏的对象的经典未定义行为吗？

我在堆栈溢出中读到，如果对象有一个简单的析构函数，则可以在销毁后访问它。在这种情况下，如果我创建一个线程本地的，我的问题就解决了bool就在上面unique_ptr，并在包含的包装类的析构函数中将其设置为 trueunique_ptr?

但我查看了 unique_ptr 析构函数，它确实将其中的指针设置为 nullptr

不要紧。一旦对象的生命周期结束，以任何方式访问该对象都是UB。所以这是行不通的。

从寿命角度看问题

问题。

您的全局日志在某些本地缓冲区之前超出了范围。

解决方案

全局日志的寿命必须比本地缓冲区的寿命长。

如何实现

如果全局日志的生存时间必须比缓冲区长，则必须首先创建它。要强制执行此操作，请确保您的本地缓冲区在构造时请求对全局缓冲区的引用。这将强制首先创建全局日志，从而在本地缓冲区被破坏时保持活动状态。

示例解决方案

像这样的东西：

class Log
{
    public:
        static Log& getLog()
        {
            static Log theOneAndOnlyLog;
            return theOneAndOnlyLog;
        }
    }
};

class BufferFrame
{
    std::vector<Buffer>   buffer;
    BufferFrame()
    {
        Log::getLog();   // Force the log to be created first.
                         // Note: Order of destruction is guranteed
                         //       for static storage duration objects
                         //       to be the exact reverse of the order of
                         //       creation.
                         //
                         // This means if A is created before B
                         // Then B must be destroyed before A
                         //
                         // Here we know that `theOneAndOnlyLog`
                         // has been constructed (fully) thus `this`
                         // object is created after it. Thus this object
                         // will be destroyed before `theOneAndOnlyLog`.
                         //
                         // This means you can safely accesses `theOneAndOnlyLog`
                         // from the destructor of this object.
    }
    ~BufferFrame()
    {
        // We know the log has been created first
        // So we know it is still alive now.
        foreach(Buffer& buf: buffer) {
             Log::getLog() << buf; // Dump Buffer
        }
    }
    Buffer& at(std::size_t index)
    {
        return buffer.at(index);
    }
};
Buffer& getBuffer(int index)
{
    static thread_local BufferFrame buffers;
    return buffers.at(index);  // Note this will throw if index is out of range.
}

class MyObjectThatLogsToBuffer
{
    public:
        MyObjectThatLogsToBuffer()
        {
            getBuffer(0);   // Have created the FramBuffer
                            // It is created first. So it will be
                            // destroyed after me. So it is safe to
                            // access in destructor.
        }
        ~MyObjectThatLogsToBuffer()
        {
            log("I am destroyed");  // assume this calls getBuffer()
        }                           // while logging. Then it will work.
};