也许我误解了单例模式，但我的解决方案是简单实用的（Python？）。这段代码实现了两个目标

使Foo的实例可以在任何地方访问（全局）。Foo只能存在一个实例。

这就是代码。

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

输出

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!

我更喜欢这个解决方案，我发现它非常清晰和直接。例如，如果其他线程已经创建了它，它将使用双重检查。需要考虑的另一件事是确保反序列化不会创建任何其他实例。https://gist.github.com/werediver/4396488

import threading


# Based on tornado.ioloop.IOLoop.instance() approach.
# See https://github.com/facebook/tornado
class SingletonMixin(object):
    __singleton_lock = threading.Lock()
    __singleton_instance = None

    @classmethod
    def instance(cls):
        if not cls.__singleton_instance:
            with cls.__singleton_lock:
                if not cls.__singleton_instance:
                    cls.__singleton_instance = cls()
        return cls.__singleton_instance


if __name__ == '__main__':
    class A(SingletonMixin):
        pass

    class B(SingletonMixin):
        pass

    a, a2 = A.instance(), A.instance()
    b, b2 = B.instance(), B.instance()

    assert a is a2
    assert b is b2
    assert a is not b

    print('a:  %s\na2: %s' % (a, a2))
    print('b:  %s\nb2: %s' % (b, b2))

我会把我的扔到戒指里。这是一个简单的装饰器。

from abc import ABC

def singleton(real_cls):

    class SingletonFactory(ABC):

        instance = None

        def __new__(cls, *args, **kwargs):
            if not cls.instance:
                cls.instance = real_cls(*args, **kwargs)
            return cls.instance

    SingletonFactory.register(real_cls)
    return SingletonFactory

# Usage
@singleton
class YourClass:
    ...  # Your normal implementation, no special requirements.

我认为它比其他一些解决方案有好处：

它清晰简洁（在我看来；D）。它的作用是完全封闭的。你不需要改变YourClass的实现。这包括不需要为类使用元类（请注意，上面的元类在工厂中，而不是“真实”类）。它不依赖猴子修补任何东西。它对呼叫者是透明的：调用者仍然只是简单地导入YourClass，它看起来像一个类（因为它是），并且他们正常使用它。无需使调用者适应工厂函数。YourClass（）实例化的仍然是您实现的YourClass的真实实例，而不是任何类型的代理，因此不会产生任何副作用。isinstance（例如，YourClass）和类似的操作仍按预期工作（尽管这个位确实需要abc，因此排除了Python＜2.6）。

一个缺点确实出现在我身上：真实类的类方法和静态方法不能通过隐藏它的工厂类透明地调用。我很少使用这种方法，我从来没有遇到过这种需要，但通过在工厂上使用一个自定义元类来实现__getattr__（），将所有的属性访问委托给真实类，这很容易纠正。

我实际上发现了一个更有用的相关模式（我并不是说这类事情经常需要），那就是“唯一”模式，用相同的参数实例化类会得到相同的实例。即“每个参数一个”。上述内容很好地适应了这一点，变得更加简洁：

def unique(real_cls):

    class UniqueFactory(ABC):

        @functools.lru_cache(None)  # Handy for 3.2+, but use any memoization decorator you like
        def __new__(cls, *args, **kwargs):
            return real_cls(*args, **kwargs)

    UniqueFactory.register(real_cls)
    return UniqueFactory

尽管如此，我还是同意一般的建议，如果你认为你需要这些东西中的一件，你真的应该停下来问问自己是否真的需要。

使用模块。它只导入一次。在其中定义一些全局变量-它们将是单例的“属性”。添加一些函数-单例的“方法”。

如果要将实例用作属性，可以使用元类。例如

class SingletonMeta(type):
    def __init__(cls, *args, **kwargs):
        super().__init__(*args, **kwargs)
        cls._instance = None
        cls._locker = threading.Lock()

    @property
    def instance(self, *args, **kwargs):
        if self._instance is None:
            with self._locker:
                if self._instance is None:
                    self._instance = self(*args, **kwargs)
        return self._instance


class MyClass(metaclass=SingletonMeta):
    def __init__(self):
        # init here
        pass


# get the instance
my_class_instance = MyClass.instance

也许我误解了单例模式，但我的解决方案是简单实用的（Python？）。这段代码实现了两个目标

使Foo的实例可以在任何地方访问（全局）。Foo只能存在一个实例。

这就是代码。

#!/usr/bin/env python3

class Foo:
    me = None

    def __init__(self):
        if Foo.me != None:
            raise Exception('Instance of Foo still exists!')

        Foo.me = self


if __name__ == '__main__':
    Foo()
    Foo()

输出

Traceback (most recent call last):
  File "./x.py", line 15, in <module>
    Foo()
  File "./x.py", line 8, in __init__
    raise Exception('Instance of Foo still exists!')
Exception: Instance of Foo still exists!