Giriş
Singleton ile yapılamaması gereken bazı şeyler şöyle.
1. Singleton reflection ile yaratılmamalı
2. Singleton Clone yapılamamalı
3. Singleton Serializable olmamalı
1 - Static Alan Yöntemi
Açıklaması şöyle.
Singleton ile yapılamaması gereken bazı şeyler şöyle.
1. Singleton reflection ile yaratılmamalı
2. Singleton Clone yapılamamalı
3. Singleton Serializable olmamalı
1 - Static Alan Yöntemi
Açıklaması şöyle.
Bu yöntem en basit olanıIn eager initialization, the instance of Singleton Class is created at the time of class loading, this is the easiest method to create a singleton class but it has a drawback that instance is created even though client application might not be using it.
Örnek
Şöyle yaparız.
Örnek
Şöyle yaparız. Yine static alan kullanılıyor, tek farkı sınıf yüklenince çalışan static constructor kullanılması.
4. Static ve Syncronized Yöntemi
Şöyle yaparız. Yine static alan kullanılıyor, tek farkı staticalanın ilk getInstance() çağrısında ilklendirilmesi.
class Single {
private final static Single sing = new Single();
private Single() {
}
public static Single getInstance() {
return sing;
}
}class XSingleton extends Singleton {
}Örnek
Şöyle yaparız. Yine static alan kullanılıyor, tek farkı sınıf yüklenince çalışan static constructor kullanılması.
public class SingletonConnection {
private static Connection connection = null ;
static
{
connection = ...;
}
public static Connection getConnection() throws Exception {
return connection;
}
}
3 - Holder Yöntemi
Holder Singleton yazısına taşıdım.4. Static ve Syncronized Yöntemi
Şöyle yaparız. Yine static alan kullanılıyor, tek farkı staticalanın ilk getInstance() çağrısında ilklendirilmesi.
private static YourObject instance;
public static synchronized YourObject getInstance() {
if (instance == null) {
instance = new YourObject();
}
return instance;
}
Bu yöntemde enum şeklinde bir sınıf kullanılıyor. Java 1.5'ten sonra bu yöntemin kullanılması tavsiye ediliyor. Enum olduğu için sınıf otomatik olarak Serializable da oluyor. Bu yöntemin JVM'in kendi içinde kullandığı bir kilit ile bu nesneyi yarattığı dolayısıyla thread-safe olduğu belirtilmiş. Joshua Bloch şöyle yazıyor.
6. Double Checked Locking
Eğer multi thread ortamda lazy singleton kullanmak istersek şöyle yaparız. Nesne volatile tanımlanmalıdır! Volatile tanımlanınca "partially initialized object" sıkıntısı olmuyor. Yani
you get an ironclad guarantee that there can be no instances besides the declared constants. The JVM makes this guarantee, and you can depend on it.Şöyle yaparız.
public enum UserActivity {
INSTANCE;
public void dostuff() {
...
}
}
// use it as ...
UserActivity.INSTANCE.doStuff();Eğer multi thread ortamda lazy singleton kullanmak istersek şöyle yaparız. Nesne volatile tanımlanmalıdır! Volatile tanımlanınca "partially initialized object" sıkıntısı olmuyor. Yani
single == null kontrolü ve single = new ... satırları yer değiştirmiyor.
class MultithreadedSingle {
private static volatile MultithreadedSingle single;
private MultithreadedSingle() {
}
public static MultithreadedSingle getInstance() {
if(single==null){
synchronized(MultithreadedSingle.class){
if(single==null){
single= new MultithreadedSingle();
}
}
}
return single;
}
}private static final Object lock = new Object();
private static volatile YourObject instance;
public static YourObject getInstance() {
YourObject r = instance;
if (r == null) {
synchronized (lock) { // While we were waiting for the lock, another
r = instance; // thread may have instantiated the object.
if (r == null) {
r = new YourObject();
instance = r;
}
}
}
return r;
}if (_instance == null) { // L1
synchronized (Singleton.class) { // L2
if (_instance == null) { // L3
_instance = new Singleton();// L4
}
}
}Dolayısıyla hata olur. synchronized kelimesinden sonra ikinci null kontrolü Thread 2'nin yeni bir instance yaratmasını engeller. İşte bu yüzden ismi "Double Checked"1. Thread 1 L1'e gelir ve _instance null'dır
2. Thread 2 L1'e gelir ve _instance null'dır
3. Thread 1 L2'de mutex'i kilitler
4. Thread 2 L2'de mutex'i kilitlemeye çalışır ama bloke olur
5. Thread 1 yeni bir instance yaratır ve L4'te atar
6. Thread 1 L2'de kilitlediği mutex'i bırakır
7. Thread 2 L2'de mutex'i kilitler
8. Thread 2 yeni bir instance yaratır ve L4'te atar
9. Thread 2 L2'de kilitlediği mutex'i bırakır
Yanlış bir kod şöyle
class SharedObject {
private static final Object LOCK = new Object(); //Volatile değil
private static SharedObject instance = null;
public static SharedObject retrieve() {
if (instance == null) {
synchronized (LOCK) {
//Burada ikinci null kontrolü yapılmıyor
instance = create();
}
}
return instance;
}
private static SharedObject create() {
return new SharedObject();
}
}7 - ClassLoader ile beraber private static final field
Bu yöntem Java 1.5'ten önce kullanılıyor. Final bir sınıf ve içinde private static final bir nesne yaratılıyor. private static final olduğu için JVM nesneyi lazy ve thread-safe olarak yaratır. Serializationpublic final class Foo implements Serializable {
private static final long serialVersionUID = 1L;
private static class FooLoader {
private static final Foo INSTANCE = new Foo();
}
private Foo() {
if (FooLoader.INSTANCE != null) {
throw new IllegalStateException("Already instantiated");
}
}
public static Foo getInstance() {
return FooLoader.INSTANCE;
}
@SuppressWarnings("unused")
private Foo readResolve() {
return FooLoader.INSTANCE;
}
}
