Có một pattern mà gần như dev nào cũng gặp trong tuần đầu đi làm: một cái Config, một cái Logger, hay một DBConnection mà "ở đâu cũng gọi được". Đó là Singleton. Nó dễ viết, dễ dùng, và cũng dễ biến dự án của bạn thành một mớ khó gỡ. Bài này tôi nói cả hai mặt: Singleton là gì, làm thế nào trong Python, và vì sao bạn nên dè chừng nó.
Singleton là gì?
Singleton (mẫu đơn thể) là một Creational pattern với hai lời hứa gộp làm một:
- Chỉ một instance: dù bạn cố tạo class đó bao nhiêu lần, luôn nhận về đúng một đối tượng.
- Điểm truy cập toàn cục: mọi nơi trong chương trình đều lấy được đúng đối tượng đó qua một lối vào chung.
Người ta hay dùng nó cho những thứ nghe có vẻ "chỉ nên có một": file cấu hình đọc từ đĩa, bộ ghi log, một pool kết nối database. Ý tưởng là: mấy thứ này tốn công tạo, và cả app nên chia sẻ chung một cái.
Hình dung một căn phòng chỉ có một chìa khoá dùng chung, treo ở sảnh. Ai cần vào phòng cũng lấy đúng cái chìa đó, rất tiện, khỏi phải phát chìa cho từng người. Nhưng đúng vì ai cũng đụng vào một cái chìa, nên khi cái ổ khoá dở chứng, bạn gần như không thể biết ai vừa xoay nó và xoay lúc nào. Singleton cho bạn sự tiện lợi đó, kèm luôn cái phiền đó. Giữ lấy hình ảnh này, phần "mặt trái" bên dưới sẽ quay lại với nó.
Cách làm trong Python
Tôi show hai cách chạy được, kèm ưu nhược.
Cách 1: biến ở cấp module (Pythonic nhất)
Điều nhiều người không để ý: trong Python, bản thân một module đã là singleton rồi. Lần import đầu tiên, Python chạy file đó một lần rồi cache lại; các lần import sau dùng lại đúng đối tượng module đã nạp. Vậy nên chỉ cần tạo sẵn một đối tượng ở cấp module là bạn đã có "một instance dùng chung" mà không cần trò gì đặc biệt:
# Cach 1: module-level instance (Pythonic nhat)
# File config.py se chi chay 1 lan khi import lan dau
class _Config:
def __init__(self):
self.debug = False
self.db_url = "postgres://localhost/app"
# Tao san 1 instance o cap module
config = _Config()
# Cho ai import cung nhan dung 1 doi tuong nay
config.debug = True
print("debug =", config.debug)
print("db_url =", config.db_url)
Ở nơi khác bạn chỉ việc from config import config là dùng chung đúng đối tượng đó. Class _Config để dấu gạch dưới ngầm ý "đừng tự tạo nữa, dùng cái config có sẵn". Cách này gọn, rõ, không có phép thuật ngầm, và dễ đọc. Nhược điểm là Python không cấm ai đó cố tạo _Config() mới, nhưng thật ra hiếm khi cần cấm cứng như vậy.
Cách 2: override __new__
Nếu bạn muốn class tự đảm bảo "gọi bao nhiêu lần cũng ra một instance", hãy can thiệp vào __new__, tức bước tạo đối tượng trước cả __init__:
# Cach 2: override __new__ de chan tao them instance
class Logger:
_instance = None
def __new__(cls):
if cls._instance is None: # chua co thi tao
cls._instance = super().__new__(cls)
cls._instance.lines = [] # khoi tao 1 lan
return cls._instance # lan sau tra ve cung 1 cai
def log(self, msg):
self.lines.append(msg)
a = Logger()
b = Logger()
a.log("khoi dong")
b.log("xu ly request")
print("a is b ?", a is b) # cung 1 instance
print("so dong log:", len(a.lines))
print(a.lines)
a và b là cùng một đối tượng (a is b trả về True), nên log ghi qua cái nào cũng dồn về một chỗ. Cách này bó buộc chặt hơn cách 1, nhưng có một cái bẫy: __init__ vẫn chạy mỗi lần bạn gọi Logger(), nên nếu khởi tạo state trong __init__ thì lần gọi thứ hai sẽ ghi đè lên state cũ. Vì thế ở đây tôi khởi tạo lines ngay trong __new__. Còn muốn thread-safe (nhiều luồng cùng gọi lần đầu) thì phải thêm khoá (lock), nữa là phức tạp hơn.
Vì sao hay bị lạm dụng / mặt trái
Đây là phần quan trọng nhất của bài. Singleton hấp dẫn vì nó cho bạn một biến "gọi ở đâu cũng được". Nhưng "gọi ở đâu cũng được" chính là định nghĩa của biến toàn cục (global variable), thứ mà ngành phần mềm đã học cách sợ từ mấy chục năm trước. Singleton chỉ là biến toàn cục khoác áo class.
- Khó test. Đối tượng sống suốt vòng đời chương trình, không reset giữa các test. State rò rỉ từ test này sang test kia; và vì code gọi thẳng tới singleton, bạn khó thay nó bằng một bản giả (mock) để kiểm thử cô lập.
- Giấu phụ thuộc. Một hàm gọi
Config()bên trong thân hàm thì nhìn chữ ký (signature) không ai biết nó phụ thuộc vào config. Phụ thuộc bị giấu, người đọc phải mò vào ruột hàm mới thấy. - Rối trong đa luồng. Nhiều luồng cùng chạm vào một đối tượng chung dễ sinh race condition; và ngay cả bước "tạo lần đầu" cũng cần khoá để hai luồng không tạo ra hai instance.
- Vi phạm Single Responsibility. Class vừa lo nghiệp vụ của nó, vừa tự lo chuyện "chỉ được có một mình tôi" (quản vòng đời). Hai trách nhiệm bị nhét vào một chỗ, đúng cái mà chữ S trong SOLID khuyên tách ra.
Quay lại chuyện cái chìa khoá dùng chung. Đây là lúc thấy cái đau bằng code. Một test làm bẩn state, test sau lãnh đủ vì không có ai reset:
# Minh hoa mat trai: Singleton = global state, kho test
class Counter:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
cls._instance.value = 0
return cls._instance
def inc(self):
self.value += 1
# Test 1 tang len 1
c1 = Counter()
c1.inc()
print("Sau test 1:", Counter().value)
# Test 2 ky vong bat dau tu 0, nhung trang thai bi dinh tu test 1
c2 = Counter()
print("Dau test 2 (mong doi 0):", c2.value) # van la 1 -> test lien luy nhau
Test 2 mong đợi bắt đầu từ 0 nhưng nhận về 1, vì cái đối tượng chung còn giữ nguyên state của test 1. Ai vừa xoay chìa? Bạn không biết. Đây chính là lý do người ta lạm dụng Singleton: nó tiết kiệm vài dòng truyền tham số hôm nay, rồi bắt bạn trả lãi bằng những giờ debug các test "lúc xanh lúc đỏ" về sau.
Thay thế tốt hơn
Trong đa số trường hợp, thứ bạn thật sự cần không phải "cấm tạo hai instance", mà là "cả app dùng chung một đối tượng". Hai cái đó khác nhau. Muốn dùng chung, cứ tạo một đối tượng ở tầng ngoài cùng rồi truyền nó vào nơi cần, tức dependency injection. Phụ thuộc lộ rõ ở chữ ký, và test chỉ việc truyền bản giả vào:
# Thay the: truyen phu thuoc vao (dependency injection)
class Config:
def __init__(self, db_url):
self.db_url = db_url
class UserService:
def __init__(self, config): # phu thuoc duoc noi ro, khong goi global
self.config = config
def where(self):
return f"UserService dung {self.config.db_url}"
# Chay that: dung config that
real = Config("postgres://prod/app")
print(UserService(real).where())
# Test: thay bang config gia, khong dinh trang thai gi
fake = Config("sqlite://:memory:")
print(UserService(fake).where())
Để ý UserService nhận config qua constructor. Nhìn chữ ký là biết ngay nó cần config; test chỉ việc dựng một Config giả trỏ vào SQLite in-memory, không đụng tới database thật, không rò state. Đây đúng là tinh thần "phụ thuộc vào cái trừu tượng, truyền nó vào" mà tôi đã nói ở bài Program to interface & Composition over inheritance.
Còn nếu bạn thật sự chỉ cần trạng thái dùng chung đơn giản, không cần thay-thế-để-test, thì một biến ở cấp module (cách 1) đã là câu trả lời gọn nhất, không cần dựng nguyên bộ máy Singleton.
Khi nào (tạm) dùng được
Tôi không bảo bạn xoá sạch Singleton. Có vài chỗ nó tạm ổn:
- Đối tượng thật sự không có state, hoặc chỉ đọc. Một bảng cấu hình nạp một lần rồi chỉ đọc thì ít gây rắc rối hơn nhiều, vì cái đau chủ yếu đến từ state thay đổi được.
- Tài nguyên đắt và duy nhất về bản chất. Một connection pool tới database thì đúng là nên có một, và vòng đời của nó khớp với vòng đời app.
- Script nhỏ, đời ngắn. Một tool chạy một lần rồi thoát thì chi phí "khó test, đa luồng" gần như không phát sinh.
Ngược lại, hãy tránh Singleton khi: đối tượng có state đổi trong lúc chạy, khi bạn muốn viết unit test cô lập, khi có nhiều luồng cùng ghi, hoặc khi bạn thấy mình dùng nó chỉ để "khỏi phải truyền tham số". Cái lười đó là dấu hiệu rõ nhất của lạm dụng.
Trong hệ thống thật
Nói cho công bằng, có những chỗ mô hình một-thể-hiện thực sự hợp lý, và chúng khá phổ biến:
- Connection pool của cơ sở dữ liệu. Mở kết nối là việc đắt, và cả tiến trình nên xài chung một pool thì mới giới hạn được số kết nối đổ về database.
- Client HTTP dùng chung. Một client giữ sẵn keep-alive và pool socket; tạo client mới cho mỗi lần gọi là ném đi toàn bộ phần bắt tay TLS vừa trả tiền.
- Registry metrics. Các counter, histogram phải cùng đổ về một nơi thì lúc scrape mới ra một bức tranh thống nhất.
- Cache trong tiến trình. Nhiều bản sao cache là nhiều bản dữ liệu lệch nhau, lại tốn thêm bộ nhớ.
- Cấu hình đọc một lần lúc khởi động. Đọc file hoặc biến môi trường một lần rồi chỉ đọc ra, không sửa nữa.
Nhưng để ý kỹ: tất cả những thứ trên chỉ nói rằng nên có một thể hiện, chứ không nói rằng phải viết một class Singleton. Cách được ưa chuộng hơn trong code sản xuất là khởi tạo chúng ở composition root, tức chỗ ráp ứng dụng lúc khởi động, rồi tiêm xuống các tầng bên dưới (dependency injection); hoặc đơn giản hơn là để thể hiện đó nằm ở cấp module. Cả hai đều cho bạn đúng một pool, đúng một client, mà không phải rải getInstance() khắp nơi trong code.
Trade-off
Gói lại cho gọn: chọn Singleton là chọn cả hai vế dưới đây, không có chuyện lấy một bỏ một.
Được:
- Kiểm soát được tài nguyên đắt: pool, client, cache chỉ tạo một lần rồi dùng lại suốt đời tiến trình.
- Truy cập tiện, không phải luồn tham số qua nhiều tầng hàm chỉ để nó tới được nơi thật sự cần.
- Tránh trạng thái mâu thuẫn do nhiều bản sao cùng tồn tại và mỗi bản giữ một phiên bản dữ liệu.
- Điểm khởi tạo rõ ràng: chỉ đúng một chỗ biết cách dựng thứ đó lên.
Phải trả giá:
- Trạng thái toàn cục trá hình: đoạn code nào cũng sửa được nó, và bạn không biết ai vừa sửa.
- Phụ thuộc bị giấu khỏi chữ ký hàm, người đọc phải mò vào thân hàm mới biết hàm đó cần gì.
- Test dính state giữa các ca chạy, lại khó thay bằng bản giả vì code gọi thẳng tới thể hiện thật.
- Rủi ro khởi tạo đồng thời trong đa luồng: không có khoá thì hai luồng vẫn có thể dựng ra hai thể hiện.
- Vòng đời gắn chặt với tiến trình, nên khó tắt hoặc khởi tạo lại có kiểm soát (nạp lại cấu hình, đóng pool lúc shutdown).
Nếu vế trên quan trọng với bạn mà vế dưới thì không, cứ dùng. Còn nếu bạn đang gật đầu với cả hai vế, hãy lấy phần "được" bằng composition root, đừng lấy bằng Singleton.
Tóm tắt
- Singleton = một instance duy nhất + điểm truy cập toàn cục. Hay dùng cho config, logger, connection pool.
- Trong Python, biến ở cấp module là cách "singleton" tự nhiên nhất (module vốn đã là singleton). Cách
__new__chặt hơn nhưng kèm bẫy__init__chạy lại và chuyện thread-safety. - Mặt trái: Singleton là global state trá hình, khó test, giấu phụ thuộc, rối đa luồng, vi phạm Single Responsibility. Đây là pattern bị lạm dụng nhất.
- Thay thế nên ưu tiên: dependency injection (truyền phụ thuộc vào) để lộ rõ phụ thuộc và dễ test; hoặc module-level nếu chỉ cần dùng chung đơn giản.
- Chỉ tạm chấp nhận với đối tượng chỉ đọc, tài nguyên duy nhất về bản chất, hoặc script nhỏ. Tránh khi có state đổi, cần test, hay đa luồng.
- Kai