我用Singletons作为面试测试。

当我让开发人员说出一些设计模式时，如果他们只能说出Singleton，他们就不会被录用。

但是当我需要像Singleton这样的东西时，我经常使用Schwarz Counter来实例化它。

Meyers单例模式在大多数情况下工作得足够好，在某些情况下，寻找更好的模式并不一定值得。只要构造函数永远不会抛出，并且单例对象之间没有依赖关系。

单例对象是全局可访问对象(从现在开始是GAO)的实现，尽管并非所有的GAO都是单例对象。

日志记录器本身不应该是单例的，但是理想情况下，记录日志的方法应该是全局可访问的，以便将日志消息的生成位置与日志记录的位置或方式分离。

延迟加载/延迟计算是一个不同的概念，单例通常也实现了这一点。它自身也有很多问题，尤其是线程安全问题，如果出现异常而失败，那么在当时看来是个好主意，结果却并不是那么好。(有点像字符串中的COW实现)。

考虑到这一点，goa可以像这样初始化:

namespace {

T1 * pt1 = NULL;
T2 * pt2 = NULL;
T3 * pt3 = NULL;
T4 * pt4 = NULL;

}

int main( int argc, char* argv[])
{
   T1 t1(args1);
   T2 t2(args2);
   T3 t3(args3);
   T4 t4(args4);

   pt1 = &t1;
   pt2 = &t2;
   pt3 = &t3;
   pt4 = &t4;

   dostuff();

}

T1& getT1()
{
   return *pt1;
}

T2& getT2()
{
   return *pt2;
}

T3& getT3()
{
  return *pt3;
}

T4& getT4()
{
  return *pt4;
}

它不需要那么粗糙地完成，显然，在包含对象的加载库中，您可能需要一些其他机制来管理它们的生命周期。(将它们放在加载库时获得的对象中)。

至于我什么时候使用单例对象?我用它们做了两件事 -一个单例表，指示哪些库已经被dlopen加载 -日志记录器可以订阅的消息处理程序，您可以向其发送消息。信号处理程序特别要求。

单身让你有能力在一个职业中结合两种坏特性。这在任何方面都是错误的。

单例可以给你:

对对象的全局访问，以及 这种类型只能创建一个对象的保证

第一点很简单。全局变量通常不好。除非真的需要，否则永远不要让对象具有全局可访问性。

第二点可能听起来很有道理，但让我们想想。上次你**不小心*创建了一个新对象而不是引用一个现有对象是什么时候?因为它被标记为c++，所以让我们使用该语言中的一个示例。你经常不小心写东西吗

std::ostream os;
os << "hello world\n";

当你打算写信的时候

std::cout << "hello world\n";

当然不是。我们不需要防范这种错误，因为这种错误根本不会发生。如果确实如此，正确的反应是回家睡12-20个小时，希望你能感觉好点。

如果只需要一个对象，只需创建一个实例。如果一个对象应该是全局可访问的，则将其设置为全局。但这并不意味着不可能创建它的其他实例。

“只有一个实例是可能的”约束并不能真正保护我们免受可能的错误。但这确实使我们的代码很难重构和维护。因为我们经常会发现我们需要不止一个实例。我们确实有不止一个数据库，不止一个配置对象，我们确实需要几个记录器。举一个常见的例子，我们的单元测试可能希望能够在每次测试中创建和重新创建这些对象。

So a singleton should be used if and only if, we need both the traits it offers: If we need global access (which is rare, because globals are generally discouraged) and we need to prevent anyone from ever creating more than one instance of a class (which sounds to me like a design issue). The only reason I can see for this is if creating two instances would corrupt our application state - probably because the class contains a number of static members or similar silliness. In which case the obvious answer is to fix that class. It shouldn't depend on being the only instance.

如果你需要全局访问一个对象，把它设置为全局的，比如std::cout。但是不要限制可以创建的实例的数量。

如果您确实需要将一个类的实例数量限制为一个，并且无法安全地处理创建第二个实例，那么就强制执行。但不要让它在全球范围内都可以使用。

如果你确实需要这两个特性，那么1)让它成为单例，2)让我知道你需要它做什么，因为我很难想象这样的情况。

下面是实现线程安全的单例模式的更好方法，在析构函数本身释放内存。但我认为析构函数应该是可选的，因为单例实例将在程序终止时自动销毁:

#include<iostream>
#include<mutex>

using namespace std;
std::mutex mtx;

class MySingleton{
private:
    static MySingleton * singletonInstance;
    MySingleton();
    ~MySingleton();
public:
    static MySingleton* GetInstance();
    MySingleton(const MySingleton&) = delete;
    const MySingleton& operator=(const MySingleton&) = delete;
    MySingleton(MySingleton&& other) noexcept = delete;
    MySingleton& operator=(MySingleton&& other) noexcept = delete;
};

MySingleton* MySingleton::singletonInstance = nullptr;
MySingleton::MySingleton(){ };
MySingleton::~MySingleton(){
    delete singletonInstance;
};

MySingleton* MySingleton::GetInstance(){
    if (singletonInstance == NULL){
        std::lock_guard<std::mutex> lock(mtx);
        if (singletonInstance == NULL)
            singletonInstance = new MySingleton();
    }
    return singletonInstance;
}

关于我们需要使用单例类的情况可以是- 如果我们想在整个程序执行过程中维护实例的状态 如果我们参与写入应用程序的执行日志，其中只需要使用文件的一个实例....等等。 这将是值得赞赏的，如果有人可以建议在我上面的代码优化。

我用Singletons作为面试测试。

当我让开发人员说出一些设计模式时，如果他们只能说出Singleton，他们就不会被录用。