Design Patterns – Singleton Pattern Nedir?

Design Patterns

Bu yazıda SingletonPattern nedir? Hangi amaç ile kullanılır? Ne gibi durumlarda kullanmamız gerekir? Konularından bahsedeceğim.

Yapacağımız uygulamada bir sınıfımızdan sadece bir nesne oluşturulmasını sağlamak istediğimizde uygulayacağımız Design Pattern, Singleton Pattern’dir. Uygulamamızda oluşturacağımız bu nesne Singleton Pattern sayesinde ikinci bir nesnenin oluşturulmasını engelleyecektir.

Uygulamamızda ne gibi durumlarda kullanılmalı diye soracak olursanız uygulama ayarları gerektiren işlemlerde, bağlantı işlemlerinde kullanılabilmektedir.

Örnek bir uygulama yapalım. Uygulamamız tek bir nesne üretecek ve ikinci kez üretilmesini engelleyecek Singleton Pattern örneği olacak.

Singleton Pattern yaparken farklı yaklaşımlar mevcuttur. Bu farklı yaklaşımları örnekler üzerinde inceleyeceğiz.

Eager Initialization

Bu yaklaşımımızda uygulamamız ayağa kalkarken nesnemiz oluşturulmaktadır.

public class SingletonOrnek {

    private static SingletonOrnek nesne = new SingletonOrnek();

    private SingletonOrnek() {
    }

    public static SingletonOrnek getNesne() {
        return nesne;
    }
}

Classımızda oluşan nesnemiz uygulama oluşturulduğunda bir değişken oluşturulur.

Static Block Initialization

Eager Initialization’un aynısı diyebiliriz. Uygulama başladığında nesnemiz oluşturulur ancak burada oluşturulmuş ya da oluşturalacak nesnemiz üzerinde kontrol mekanizması oluşturabiliriz.

public class SingletonOrnek {

    private static SingletonOrnek nesne;

    static { 
       try {
           nesne= new SingletonOrnek();
           } catch (IOException e) {
              throw new RuntimeException("Hata", e);
           }
    }
    
    private SingletonOrnek() {
    }

    public static SingletonOrne getNesne() {
        return nesne;
    }
}

Static bir nesne oluşturarak hata işlemlerini yakalabilmekteyiz.

Lazy Initialization

Bu Singleton Pattern yaklaşımında nesnemiz biz isteğimiz zaman oluşturulmakta ve aynı nesnenin oluşup oluşmadığı kontrol ederek eğer oluşmadıysa nesnenin oluşturulmasını sağlamaktayız.

public class SingletonOrnek {

private static SingletonOrnek nesne;

    private SingletonOrnek() {
    }

    public static SingletonOrnek getNesne() {
      if (null == nesne) {
          nesne= new SingletonOrnek();
       }
      return nesne;
    }
}

Bu sayede “aynı nesnenin ikinci kez” oluşturulmasının da önüne geçiyoruz.

Lazy Initialization ve Double Check Locking

Uygulamamızda Lazy Initialization yapısı kullanarak bir Singleton Pattern oluşturduk. Uygulamamızda ikinci kez nesnemizin oluşturulmasını engellemek için kontrol mekanizmasını genişlettiğimiz yaklaşımdır.

public class DoubleCheckedLocking {

	private volatile static DoubleCheckedLocking nesne;

	private DoubleCheckedLocking() {
        }

	public static DoubleCheckedLocking getNesne() {
		if (nesne== null) {
			synchronized (DoubleCheckedLocking.class) {
				if (nesne == null) {
					nesne = new DoubleCheckedLocking();
				}
			}
		}
		return nesne;
	}
}

Bill Pugh Singleton

Bu yaklaşımda static nested class oluşturarak nesnemizin üretilmesini sağlamaktayız.

public class SingletonBillPugh {
 
    private SingletonBillPugh() {
    }
 
    private static class SingletonHolder {
        public static final SingletonBillPugh nesne = new SingletonBillPugh();
    }
 
    public static SingletonBillPugh getInstance() {
        return SingletonHolder.instance;
    }
}

Thread Safe Singleton

Bu yaklaşımda uygulamamıza birden çok aynı anda nesne oluşturulması işleminde aynı anda istek gelse bile sadece birtanesinin işlenmesi sonra diğerini işleme alarak nesnemiz oluştuysa tekrar oluşturulmasını engellemek için yapıtığımız bir Singleton Pattern yaklaşımıdır.

public class ThreadSafeSingleton {

    private static ThreadSafeSingleton nesne;
    
    private ThreadSafeSingleton(){}
    
    public static synchronized ThreadSafeSingleton getNesne(){

        if(nesne== null){
            nesne = new ThreadSafeSingleton();
        }
        return nesne;
    }
    
}

Bu yaklaşımda uygulamamızda bu nesne için oluşturmak isteyen birden fazla isteği synchronized yaparak sıraya sokuyoruz ve oluşmadı ise nesnemizi oluşturuyoruz.

2 Comments

  1. Eager’i TypeScript ile şöyle denedim. Olmuş mu? (:

    class SingletonExample {
    private static nesne = new SingletonExample();

    private SingletonExample() {

    }

    public static getNesne() {
    return this.nesne
    }

    public getPlayer() {
    console.log(“Player”);
    }
    }

    class TestSingleton {
    constructor() {
    var ref = SingletonExample.getNesne();

    ref.getPlayer();
    }
    }

    new TestSingleton();

  2. Allah köməyiniz olsun. Çox gözəl izah etmisiniz!

Leave a Reply

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Burak KUTBAY 2010 - 2019
%d blogcu bunu beğendi: