FilesExpand file tree

master

/

singleton_pattern_demo.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

228 lines (178 loc) · 7.29 KB

master

/

singleton_pattern_demo.py

Copy path

Top

File metadata and controls

• Code
• Blame

228 lines (178 loc) · 7.29 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

import threading

import time

from typing import Optional, Any

# Method 1: Using __new__ method

class SingletonMeta(type):

"""Metaclass for creating Singleton classes."""

_instances = {}

def __call__(cls, *args, **kwargs):

if cls not in cls._instances:

cls._instances[cls] = super().__call__(*args, **kwargs)

return cls._instances[cls]

class Logger(metaclass=SingletonMeta):

"""Logger singleton using metaclass approach."""

def __init__(self, name: str = "DefaultLogger"):

self.name = name

self.logs = []

print(f"Logger '{self.name}' initialized")

def log(self, message: str, level: str = "INFO") -> None:

"""Log a message."""

timestamp = time.strftime("%Y-%m-%d %H:%M:%S")

log_entry = f"[{timestamp}] {level}: {message}"

self.logs.append(log_entry)

print(log_entry)

def get_logs(self) -> list:

"""Get all logged messages."""

return self.logs.copy()

# Method 2: Using class variable and __new__

class DatabaseConnection:

"""Database connection singleton using __new__ approach."""

_instance = None

def __new__(cls, *args, **kwargs):

if cls._instance is None:

print("Creating new database connection...")

cls._instance = super().__new__(cls)

return cls._instance

def __init__(self, host: str = "localhost", port: int = 5432):

# __init__ is called every time, but we only set attributes once

if not hasattr(self, 'initialized'):

self.host = host

self.port = port

self.connected = False

self.initialized = True

print(f"Database connection configured for {host}:{port}")

def connect(self) -> None:

"""Simulate database connection."""

if not self.connected:

print(f"Connecting to database at {self.host}:{self.port}")

time.sleep(0.5) # Simulate connection time

self.connected = True

print("Connected successfully!")

else:

print("Already connected")

def disconnect(self) -> None:

"""Simulate disconnection."""

if self.connected:

print("Disconnecting from database...")

self.connected = False

print("Disconnected")

else:

print("Not connected")

def execute_query(self, query: str) -> str:

"""Simulate query execution."""

if not self.connected:

return "Error: Not connected to database"

return f"Executed: {query} -> Result: Mock data"

# Method 3: Decorator approach

def singleton(cls):

"""Decorator to make a class singleton."""

instances = {}

def get_instance(*args, **kwargs):

if cls not in instances:

instances[cls] = cls(*args, **kwargs)

return instances[cls]

return get_instance

@singleton

class ConfigurationManager:

"""Configuration manager singleton using decorator."""

def __init__(self, config_file: str = "config.json"):

self.config_file = config_file

self.settings = {}

self._load_config()

print(f"ConfigurationManager initialized with {config_file}")

def _load_config(self) -> None:

"""Simulate loading configuration."""

# In real implementation, this would load from file

self.settings = {

"debug": True,

"max_connections": 100,

"timeout": 30

}

def get_setting(self, key: str) -> Any:

"""Get a configuration setting."""

return self.settings.get(key, None)

def set_setting(self, key: str, value: Any) -> None:

"""Set a configuration setting."""

self.settings[key] = value

print(f"Setting updated: {key} = {value}")

# Thread-safe singleton (for demonstration)

class ThreadSafeSingleton:

"""Thread-safe singleton implementation."""

_instance = None

_lock = threading.Lock()

def __new__(cls, *args, **kwargs):

if cls._instance is None:

with cls._lock:

# Double-check locking

if cls._instance is None:

print("Creating thread-safe singleton instance...")

cls._instance = super().__new__(cls)

return cls._instance

def __init__(self, value: str = "default"):

if not hasattr(self, 'initialized'):

self.value = value

self.initialized = True

print(f"ThreadSafeSingleton initialized with value: {value}")

# Demonstration functions

def demonstrate_logger() -> None:

"""Demonstrate Logger singleton."""

print("\n--- Logger Singleton ---")

logger1 = Logger("AppLogger")

logger2 = Logger("DifferentName") # This should return the same instance

print(f"Same instance? {logger1 is logger2}")

print(f"Logger name: {logger1.name}") # Will be "AppLogger" from first call

logger1.log("Application started")

logger1.log("Processing data", "DEBUG")

logger1.log("Error occurred", "ERROR")

print(f"Total logs: {len(logger1.get_logs())}")

def demonstrate_database() -> None:

"""Demonstrate DatabaseConnection singleton."""

print("\n--- Database Connection Singleton ---")

db1 = DatabaseConnection("prod-db", 5432)

db2 = DatabaseConnection("dev-db", 3306) # Should return same instance

print(f"Same instance? {db1 is db2}")

print(f"Host: {db1.host}, Port: {db1.port}") # Will be from first call

db1.connect()

db2.connect() # Should show already connected

result = db1.execute_query("SELECT * FROM users")

print(result)

db1.disconnect()

def demonstrate_config() -> None:

"""Demonstrate ConfigurationManager singleton."""

print("\n--- Configuration Manager Singleton ---")

config1 = ConfigurationManager("app_config.json")

config2 = ConfigurationManager("other_config.json") # Same instance

print(f"Same instance? {config1 is config2}")

print(f"Config file: {config1.config_file}") # From first call

print(f"Debug setting: {config1.get_setting('debug')}")

config1.set_setting("new_setting", "value")

print(f"New setting: {config2.get_setting('new_setting')}") # Accessible from both

def demonstrate_thread_safe() -> None:

"""Demonstrate thread-safe singleton."""

print("\n--- Thread-Safe Singleton ---")

def create_singleton(value):

singleton = ThreadSafeSingleton(value)

print(f"Thread {threading.current_thread().name}: {singleton.value}")

# Create multiple threads trying to create singleton

threads = []

for i in range(3):

thread = threading.Thread(target=create_singleton, args=(f"value_{i}",))

threads.append(thread)

for thread in threads:

thread.start()

for thread in threads:

thread.join()

# Verify only one instance exists

s1 = ThreadSafeSingleton()

s2 = ThreadSafeSingleton()

print(f"Final check - Same instance? {s1 is s2}")

if __name__ == "__main__":

print("Demonstrating Singleton Design Pattern in Python:")

print("=" * 60)

demonstrate_logger()

demonstrate_database()

demonstrate_config()

demonstrate_thread_safe()

print("\nThe Singleton Pattern ensures a class has only one instance")

print("and provides a global point of access to that instance.")

print("Common uses: loggers, database connections, configuration managers.")