资源释放堆栈

// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef BASE_AT_EXIT_H_ #define BASE_AT_EXIT_H_ #include <stack> #include "base/basictypes.h" #include "base/lock.h" namespace base { // This class provides a facility similar to the CRT atexit(), except that // we control when the callbacks are executed. Under Windows for a DLL they // happen at a really bad time and under the loader lock. This facility is // mostly used by base::Singleton. // // The usage is simple. Early in the main() or WinMain() scope create an // AtExitManager object on the stack: // int main(...) { // base::AtExitManager exit_manager; // // } // When the exit_manager object goes out of scope, all the registered // callbacks and singleton destructors will be called. class AtExitManager { protected: // This constructor will allow this instance of AtExitManager to be created // even if one already exists. This should only be used for testing! // AtExitManagers are kept on a global stack, and it will be removed during // destruction. This allows you to shadow another AtExitManager. AtExitManager(bool shadow); public: typedef void (*AtExitCallbackType)(void*); AtExitManager(); // The dtor calls all the registered callbacks. Do not try to register more // callbacks after this point. ~AtExitManager(); // Registers the specified function to be called at exit. The prototype of // the callback function is void func(). static void RegisterCallback(AtExitCallbackType func, void* param); // Calls the functions registered with RegisterCallback in LIFO order. It // is possible to register new callbacks after calling this function. static void ProcessCallbacksNow(); private: struct CallbackAndParam { CallbackAndParam(AtExitCallbackType func, void* param) : func_(func), param_(param) { } AtExitCallbackType func_; void* param_; }; Lock lock_; std::stack<CallbackAndParam> stack_; AtExitManager* next_manager_; // Stack of managers to allow shadowing. DISALLOW_COPY_AND_ASSIGN(AtExitManager); }; } // namespace base #endif // BASE_AT_EXIT_H_ // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/at_exit.h" #include "base/logging.h" namespace base { // Keep a stack of registered AtExitManagers. We always operate on the most // recent, and we should never have more than one outside of testing, when we // use the shadow version of the constructor. We don't protect this for // thread-safe access, since it will only be modified in testing. static AtExitManager* g_top_manager = NULL; AtExitManager::AtExitManager() : next_manager_(NULL) { DCHECK(!g_top_manager); g_top_manager = this; } AtExitManager::AtExitManager(bool shadow) : next_manager_(g_top_manager) { DCHECK(shadow || !g_top_manager); g_top_manager = this; } AtExitManager::~AtExitManager() { if (!g_top_manager) { NOTREACHED() << "Tried to ~AtExitManager without an AtExitManager"; return; } DCHECK(g_top_manager == this); ProcessCallbacksNow(); g_top_manager = next_manager_; } // static void AtExitManager::RegisterCallback(AtExitCallbackType func, void* param) { if (!g_top_manager) { NOTREACHED() << "Tried to RegisterCallback without an AtExitManager"; return; } DCHECK(func); AutoLock lock(g_top_manager->lock_); g_top_manager->stack_.push(CallbackAndParam(func, param)); } // static void AtExitManager::ProcessCallbacksNow() { if (!g_top_manager) { NOTREACHED() << "Tried to ProcessCallbacksNow without an AtExitManager"; return; } AutoLock lock(g_top_manager->lock_); while (!g_top_manager->stack_.empty()) { CallbackAndParam callback_and_param = g_top_manager->stack_.top(); g_top_manager->stack_.pop(); callback_and_param.func_(callback_and_param.param_); } } } // namespace base

防止由于程序意外退出资源得不到释放,使用在单键模式或程序启动时