Kalau kamu sudah mulai menulis program Python yang lebih besar, kamu mungkin bertanya-tanya: bagaimana caranya memastikan sebuah objek hanya dibuat satu kali di seluruh aplikasi? Misalnya untuk koneksi database, logger, atau pengaturan konfigurasi. Jawabannya adalah salah satu pola desain paling populer: Singleton.

Artikel ini menjelaskan Singleton secara sederhana — apa itu, bagaimana implementasinya di Python, dan kapan sebaiknya kamu memakainya (atau justru menghindarinya).

Apa itu Design Pattern?

Design pattern adalah solusi yang sudah teruji untuk masalah yang sering muncul dalam pemrograman. Ibarat resep masakan: bukan kode jadi, tapi pola yang bisa kamu adaptasi ke masalahmu sendiri. Ada tiga kelompok besar: creational (pembuatan objek), structural (susunan objek), dan behavioral (komunikasi antar objek).

Singleton termasuk kelompok creational — pola yang mengatur cara sebuah objek dibuat.

Apa itu Singleton?

Singleton adalah pola yang memastikan sebuah kelas hanya memiliki satu instance dan menyediakan satu titik akses global ke instance tersebut. Sederhananya: tidak peduli berapa kali kamu meminta objeknya, kamu selalu mendapat objek yang sama.

Pola ini umumnya dipakai untuk objek yang seharusnya memang hanya ada satu: koneksi database, logger, manajer konfigurasi, atau connection pool.

Implementasi Sederhana di Python

Di Python, cara paling sederhana membuat Singleton adalah dengan menimpa metode __new__ — metode yang dipanggil sebelum objek benar-benar dibuat.

python
class DatabaseConnection:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if not hasattr(self, 'initialized'):
            self.connection = "Terhubung ke database"
            self.initialized = True


# Bukti keduanya objek yang sama
a = DatabaseConnection()
b = DatabaseConnection()

print(a is b)          # True
print(a.connection)    # "Terhubung ke database"

Perhatikan: kita menyimpan instance di atribut kelas _instance, lalu mengembalikan instance yang sama setiap kali __new__ dipanggil. Kita juga menjaga __init__ tidak menjalankan ulang inisialisasi dengan penanda initialized.

Versi Thread-Safe

Kode di atas cukup untuk banyak kasus, tapi bisa bermasalah kalau programmu memakai thread — dua thread bisa saja membuat dua instance secara bersamaan. Kalau kamu baru belajar concurrency, kami juga punya panduan lengkap Async/Await di Python. Solusi untuk Singleton adalah menambahkan lock.

python
import threading

class ConfigManager:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        if not hasattr(self, 'loaded'):
            self.settings = {"host": "localhost", "port": 5432}
            self.loaded = True

Pola double-checked locking di atas memastikan hanya satu thread yang membuat instance, sementara thread lain langsung memakai instance yang sudah ada.

Dalam praktiknya, modul Python sendiri pada dasarnya sudah bersifat Singleton — modul hanya di-load sekali per proses. Jadi untuk kasus sederhana, variabel level modul sering kali sudah cukup.

Kapan Memakai Singleton?

Singleton cocok untuk:

  • Koneksi database — membuka koneksi berulang kali itu mahal.
  • Logger — satu logger untuk seluruh aplikasi.
  • Konfigurasi aplikasi — satu sumber kebenaran untuk pengaturan.
  • Connection pool — mengelola kumpulan koneksi.

Kapan Sebaiknya Dihindari?

Singleton juga punya sisi gelap. Ia sering dianggap anti-pattern karena:

  • Sulit diuji — state global membuat unit test saling bergantung. Pelajari cara mengetesnya di tutorial Pytest untuk pemula.
  • Menyembunyikan dependensi — objek memakai Singleton secara diam-diam.
  • Menyulitkan paralelisme — satu instance dipakai banyak thread sekaligus.

Banyak developer modern lebih memilih dependency injection sebagai gantinya: objek menerima dependensinya lewat parameter, bukan mengambilnya dari Singleton global.

Jangan jadikan Singleton solusi untuk semua masalah. Kalau kamu terus-terusan butuh Singleton, mungkin ada yang salah dengan desain aplikasimu — pertimbangkan dependency injection.

FAQ Singleton

Apakah Singleton membuat program lebih cepat?

Tidak selalu. Manfaat utamanya adalah penghematan sumber daya (misalnya satu koneksi database, bukan banyak), bukan kecepatan. Untuk objek ringan, Singleton justru tidak perlu.

Apakah modul Python itu Singleton?

Ya, dalam praktiknya. Modul Python hanya di-import dan dieksekusi sekali per proses, lalu di-cache di sys.modules. Jadi variabel level modul bersifat global tunggal — mirip Singleton.

Apakah Singleton sulit diuji?

Bisa, karena state global-nya membuat satu test bisa memengaruhi test lain. Solusinya: reset instance di setUp, atau gunakan dependency injection agar objek bisa disuntikkan mock saat testing.

Kesimpulan

Singleton adalah pola yang sederhana tapi kuat: memastikan sebuah kelas hanya punya satu instance dan satu titik akses global. Cocok untuk koneksi database, logger, dan konfigurasi — tapi jangan dipakai berlebihan, karena ia bisa membuat kode sulit diuji.

Mulailah dari contoh di atas, lalu coba implementasikan di proyekmu sendiri. Kalau ingin mendalami pola lain, Factory dan Observer adalah dua pola berikutnya yang paling sering dipakai.