Singleton Pattern is a common software design pattern. The main purpose of this pattern is to ensure that only one instance of a class exists. Singleton objects come in handy when you want only one instance of a class in the whole system.
For example, the configuration information of a server program is stored in a file, and the client reads the configuration file information through an AppConfig class. If the contents of the configuration file need to be used in many places during the running of the program, that is, instances of AppConfig objects need to be created in many places, which will lead to multiple AppConfig instance objects in the system, which will seriously waste memory resources, especially when there are many contents of the configuration file. In fact, for classes like AppConfig, we want only one instance object to exist during the program running.
In Python, we can implement singleton mode in many ways:
1. Use the module
You can refer to the user-defined add, delete, modify and query component site object, which is an obvious simple profit mode
In fact, Python's module is a natural singleton mode, because when the module is imported for the first time, it will generate a. pyc file. When it is imported for the second time, it will directly load the. pyc file without executing the module code again. Therefore, we only need to define the relevant functions and data in a module to obtain a singleton object. If we really want a singleton class, we can consider doing this:
-
# mysingleton.py
-
class My_Singleton(object):
-
def foo(self):
-
pass
-
-
my_singleton = My_Singleton()
Save the above code in the file mysingleton.py, and then use it as follows:
-
from mysingleton
import my_singleton
-
-
my_singleton.foo()
2. Use new
-
#Python learning communication QQ group:
579817333
-
from django.test
import TestCase
-
-
# Create your tests here.
-
class Singleton:
-
def __init__(self,name):
-
self.name=name
-
-
def __new__(cls, *args, **kw):
-
if not hasattr(cls,
'_instance'):
-
orig = super(Singleton, cls)
-
cls._instance = orig.__new__(cls)
-
return cls._instance
-
-
one = Singleton(
'aa')
-
two = Singleton(
'bb')
-
print(one.name)
-
print(one.name)
-
-
-
-
two.a =
3
-
print(one.a)
-
# one and two are exactly the same. You can use id(), ==, is detection
-
print(id(one))
-
print(id(two))
-
print(one == two)
-
print(one is two)
Lock
-
import time
-
import threading
-
class Singleton(object):
-
_instance_lock = threading.Lock()
-
def __init__(self):
-
time.sleep(
1)
-
print(self)
-
-
-
def __new__(cls, *args, **kwargs):
-
with cls._instance_lock:
-
if not hasattr(Singleton,
'_instance'):
-
Singleton._instance=object.__new__(cls)
-
return Singleton._instance
-
-
-
-
def task():
-
obj = Singleton()
-
-
for i in
range(
10):
-
t=threading.Thread(target=task)
-
t.start()
3. Implement singleton mode by using class:
a. Cannot support multi-threaded singleton mode
-
class Singleton(object):
-
-
@classmethod
-
def instance(cls,*args,**kwargs):
-
if not hasattr(Singleton,
'_instance'):
-
-
Singleton._instance=Singleton()
-
return Singleton._instance
-
-
-
a=Singleton.instance()
-
b=Singleton.instance()
-
print(a==b)#True
But let's try with multithreading
-
import time
-
class Singleton(object):
-
def __init__(self):
-
time.sleep(
1)
-
-
@classmethod
-
def instance(cls,*args,**kwargs):
-
if not hasattr(Singleton,
'_instance'):
-
-
Singleton._instance=Singleton()
-
return Singleton._instance
-
-
-
# a=Singleton.instance()
-
# b=Singleton.instance()
-
#
print(a==b)
-
import threading
-
def task():
-
-
obj = Singleton.instance()
-
print(obj)
-
-
-
for i in
range(
10):
-
t=threading.Thread(target=task)
-
t.start()
result:
-
D:\virtualenv\envs\vuedjango\Scripts\python.exe D:/test/flaskTest/flaskpro3/Singleton mode/class.py
-
<__main__.Singleton object at
0x0000022E579C6E80>
-
<__main__.Singleton object at
0x0000022E579AB898>
-
<__main__.Singleton object at
0x0000022E579EC6A0>
-
<__main__.Singleton object at
0x0000022E579DB1D0>
-
<__main__.Singleton object at
0x0000022E579EC5C0>
-
<__main__.Singleton object at
0x0000022E579D1FD0>
-
<__main__.Singleton object at
0x0000022E579D9C50>
-
<__main__.Singleton object at
0x0000022E579C6F60>
-
<__main__.Singleton object at
0x0000022E579D1EB8>
-
<__main__.Singleton object at
0x0000022E579DB2B0>
-
-
Process finished with exit code
0
b. Solve the above problems and realize the single column mode supporting multithreading:
-
import time
-
import threading
-
class Singleton(object):
-
_instance_lock = threading.Lock()
-
def __init__(self):
-
-
time.sleep(
1)
-
-
@classmethod
-
def instance(cls,*args,**kwargs):
-
with cls._instance_lock:
-
if not hasattr(Singleton,
'_instance'):
-
Singleton._instance=Singleton()
-
return Singleton._instance
-
return Singleton._instance
-
-
def task():
-
-
obj = Singleton.instance()
-
print(obj)
-
-
-
for i in
range(
10):
-
t=threading.Thread(target=task)
-
t.start()
result:
-
D:\virtualenv\envs\vuedjango\Scripts\python.exe D:/test/flaskTest/flaskpro3/Singleton mode/class.py
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
<__main__.Singleton object at
0x000001BADB56F320>
-
-
Process finished with exit code
0
Question:
To create an instance, you can only call Singleton.instance(), not Singleton()
4, Implementation based on metaclass
1. The object is the init of the class when creating the object__ Method is executed automatically, and the object () executes the of the class_ call_ Method 2. The class is created by type. When creating the class, type_ init_ Method is executed automatically, and class () executes type_ call_ Method (class's _new method, class's init method)
-
#Python learning communication QQ group:
579817333
-
# The first
0 step: implement
type of __init__ Method class is
type [object]
-
class Foo:
-
def __init__(self):
-
pass
-
-
def __call__(self, *args, **kwargs):
-
pass
-
-
# The first
1 step: implement
type of __call__ method
-
#
1.1 call Foo Class (yes)
type Object) __new__Method to create an object.
-
#
1.2 call Foo Class (yes)
type Object) __init__Method to initialize an object.
-
obj = Foo()
-
# The first
2 Step: Execute Foodef __call__ method
-
obj()
-
class SingletonType(
type):
-
def __init__(self,*args,**kwargs):
-
print(
1)
-
super(SingletonType,self).__init__(*args,**kwargs)
-
-
def __call__(cls, *args, **kwargs):
-
print(
2)
-
obj = cls.__new__(cls,*args, **kwargs)
-
cls.__init__(obj,*args, **kwargs) # Foo.__init__(obj)
-
return obj
-
-
class Foo(metaclass=SingletonType):
-
def __init__(self,name):
-
print(
4)
-
self.name = name
-
def __new__(cls, *args, **kwargs):
-
print(
3)
-
return object.__new__(cls)
-
-
obj1 = Foo(
'name')
Implementation of singleton
-
import threading
-
class Singleton(
type):
-
_instance_lock=threading.Lock()
-
def __call__(cls, *args, **kwargs):
-
with cls._instance_lock:
-
if not hasattr(cls,
'_instance'):
-
cls._instance=super(Singleton, cls).__call__(*args, **kwargs)
-
return cls._instance
-
-
-
class Foo(metaclass=Singleton):
-
def __init__(self,name):
-
self.name=name
-
-
-
obj1 = Foo(
'name')
-
obj2 = Foo(
'name')
-
print(obj1,obj2)
(end)
