Python singleton pattern example

The examples in this article describe the Python singleton mode. Share it with everyone for your reference, the details are as follows:

Single case mode: Ensures that a class has only one instance and provides a global access to it access point.

Ways to achieve only one instance of a class:

1. Let a global variable enable an object to be accessed, but it cannot prevent multiple objects from being instantiated externally. .

2, let the class itself save its only instance, this class can guarantee that no other instances can be created.

Singleton mode in multi-threading: Lock-double lock

Hungry-style singleton class: When the class is loaded Instantiate yourself (static initialization). The advantage is that it avoids the security issues of multi-threaded access, but the disadvantage is that it occupies system resources in advance.

Lazy singleton class: It will only instantiate itself when it is referenced for the first time. Avoid occupying system resources at the beginning, but there are security issues with multi-threaded access.

Example:

#encoding=utf-8
#单例模式
def PrintInfo(info):
#  print unicode(info,'utf-8').decode('gbk')
  print info.decode('utf-8').encode('utf-8')
import threading
#单例类
class Singleton():
  instance=None
  mutex=threading.Lock()
  def _init__(self):
    pass
  @staticmethod
  def GetInstance():
    if(Singleton.instance==None):
      Singleton.mutex.acquire()
      if(Singleton.instance==None):
        PrintInfo('初始化实例')
        Singleton.instance=Singleton()
      else:
        PrintInfo('单例已经实例化')
      Singleton.mutex.release()
    else:
      PrintInfo('单例已经实例化')
    return Singleton.instance
def clientUI():
  Singleton.GetInstance()
  Singleton.GetInstance()
  Singleton.GetInstance()
  return
if __name__=='__main__':
  clientUI();

Result:

初始化实例 单例已经实例化 单例已经实例化

Additional explanation @staticmethod When mentioning classmethod in Python, staticmethod must be mentioned, not because there is any relationship between the two, but to allow users to distinguish so that they can write code more clearly. In C++, we understand that functions accessed directly through the class name are called static functions of the class, that is, static-modified functions. It can be seen that classmethod and staticmethod in C++ are the same concept. So what is the difference between the two in python? Let’s first look at how the two are declared in python code

class MyClass:
 ...
 @classmethod # classmethod的修饰符
 def class_method(cls, arg1, arg2, ...):
  ...
 @staticmethod # staticmethod的修饰符
 def static_method(arg1, arg2, ...):
  ...

For the parameters of classmethod, the class name needs to be passed implicitly, but the staticmethod parameter does not. The class name needs to be passed. In fact, this is the biggest difference between the two.

Both can be called through class names or class instance objects. Because the emphasis is on classmethod and staticmethod, it is best to use class names when writing code. It is a good programming habit.

The static method is set up to be defined in the class. Generally speaking, it is rarely used in this way. You can use module-level functions to replace it. Since it is to be defined in a class, the author must have considered it.

For classmethod, it can be redefined through subclasses.

Mention class-level functions, and also mention class-level variables

class MyClass:
 i = 123 # class-level variable
 def __init__(self):
 self.i = 456 # object-level variable
 ...

In order to clearly distinguish the above two i, the last A good way is to consider that everything in python is object, so i=123 belongs to class object, and i=456 belongs to class instance object

For more articles related to Python singleton mode examples, please pay attention to PHP Chinese website !