[color=green][size=medium][b]Java之设计模式之Singleton[/b][/size][/color]

Java Singleton 单例设计模式属于四大设计模式之生产设计模式的一种。
该设计模式看似简单,但是涉及到许多注意点。

[size=medium][b]一、Java Singleton 简介[/b][/size]

Java Singleton 单例设计只允许在JVM中产生类的一个实例对象。
因此这样的类不能提供对外的构造方法产生实例,而是提供一个 public 方法,
返回(指向)某个实例的引用。

Java Singleton 单例设计常用于:
1、Logging(日志)
2、Driver(驱动)
3、Caching(缓存)
4、Thread Pool(线程池)
5、Abstract Factory(抽象工厂)
6、Builder(构建器)
7、Prototype(原型设计)
8、Facade Design Pattern

在 core java 中也有出现单例模式的设计:
java.lang.Runtime
java.awt.Desktop


[size=medium][b]二、实现 Java Singleton [/b][/size]

实现单例需要符合下列三点:
1、private 的构造方法。阻止除本类外的其他类对该类进行实例的构建。
2、private , static 的属性。这就是那个单例。
3、public static 的方法,用于对外返回单例。


单例的实现有以下几种方式:

按初始化分:
1、Eager initializtion (急初始化)
2、Static block initializtion (静态块初始化)
3、Lazy initializtion (懒初始化)

按线程安全分:
4、Thread Safe Singleton(线程安全式单例)
5、Bill Push Singleton(Bill Push 单例)


下面将逐一讲解:

[b]1、Eager initializtion (急初始化)[/b]

急初始化模式下,单例在 Class 被 JVM 加载时即被创建。

优点:
-容易实现。

缺点:
-该类未被使用到时也被初始化。
-不能进行异常处理。

点评:
如果使用较少的资源,可以使用此方法。
多数情形下,如 File System,Database Connection,应避免使用此方法。

代码:

public class EagerInitializedSingleton {

    private static final EagerInitializedSingleton instance 
                             = new EagerInitializedSingleton();

    //私有构造方法,避免其它类在该类外部构造此类的实例。
    private EagerInitializedSingleton(){}

    public static EagerInitializedSingleton getInstance(){
        return instance;
    }
}





[b]2、Static block initializtion (静态块初始化)[/b]



静态块初始化方法跟急初始化差不多,只是可以在静态块中处理异常。


public class StaticBlockSingleton {

    private static StaticBlockSingleton instance;

    private StaticBlockSingleton(){}

    //static block initialization for exception handling
    static{
        try{
            instance = new StaticBlockSingleton();
        }catch(Exception e){
            throw new RuntimeException("Exception occured in creating singleton instance");
        }
    }

    public static StaticBlockSingleton getInstance(){
        return instance;
    }
}




[b]3、Lazy initializtion (懒初始化)[/b]



懒初始化单例设计模式,是在对外的 public 方法中生成实例对象的。


只需加一个是否为空的判断即可。



public class LazyInitializedSingleton {

    private static LazyInitializedSingleton instance;

    private LazyInitializedSingleton(){}

    public static LazyInitializedSingleton getInstance(){
        if(instance == null){
            instance = new LazyInitializedSingleton();
        }
        return instance;
    }
}



上面3种单例设计方式,在单线程的环境下可以正常工作。


但是,在多线程的环境下不行:当多个线程同时运行在 if 块内,


可能会产生多个实例对象。



下面讲述多线程环境下的单例模式。



[b]4、Thread Safe Singleton(线程安全式单例)[/b]



最简单的实现是给对外公开的 public 的方法增加 synchronized 修饰符。



说明:[url=http://lixh1986.iteye.com/blog/2351243]关于 synchronized修饰符 [/url]



这样一次只能有一个线程可以访问该方法。


public class ThreadSafeSingleton {

    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton(){}

    public static synchronized ThreadSafeSingleton getInstance(){
        if(instance == null){
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }

}



上面的方法在功能实现角度上是没有任何问题的。但是有一缺陷:效率比较低。


其实,只需对实例第一次产生时进行 synchroinized 即可。



改进:


public class ThreadSafeDoubleCheckingSingleton {

    private static ThreadSafeDoubleCheckingSingleton instance;

    private ThreadSafeDoubleCheckingSingleton(){}

    public static ThreadSafeDoubleCheckingSingleton getInstance(){
        if(instance == null){
            synchronized(ThreadSafeDoubleCheckingSingleton.class){
                if(instance == null){
                    instance = new ThreadSafeDoubleCheckingSingleton();
                }
            }
        }
        return instance;
    }

}




[b]5、Bill Push Singleton(Bill Push 单例)[/b]



在 Java 1.5 之前,java 内存模型有很多问题。


尤其是线程很多的情况下,上面的实现方式会莫名其妙的失效。



于是乎,Bill Push 提出了单例模式的另一种实现方式:借助内部类。


public class BillPughSingleton {

    private BillPughSingleton(){}

    private static class SingletonHelper{
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance(){
        return SingletonHelper.INSTANCE;
    }
}



内部类何时被初始化?


当类被 JVM 装载时,内部类不会被装载,直到 getInstance() 方法被调用。




这是被最广泛使用的线程安全的单例模式。


因为它不需要任何的 synchronized 修饰符。




[size=medium][b]三、Java Singleton 之继续讨论[/b][/size]



[b]1、Using Reflection to destroy Signleton Pattern[/b]



使用反射来破坏单例设计模式:


当使用反射机制生成类的实例时,上述单例设计方法便失效了。


public class ReflectionSingletonTest {

    public static void main(String[] args) throws Exception{
        EagerInitializedSingleton instanceOne = 
                                   EagerInitializedSingleton.getInstance();        
        EagerInitializedSingleton instanceTwo = null;

        Constructor constructor = EagerInitializedSingleton.class.getDeclaredConstructor();
        constructor.setAccessible(true);
        instanceTwo = (EagerInitializedSingleton) constructor.newInstance();

        System.out.println(instanceOne.hashCode());
        System.out.println(instanceTwo.hashCode());
    }
}



上述两个 hashCode() 值是不同的。




[b]2、Enum Singleton(枚举式单例)[/b]



为了克服使用反射所带来的问题, Joshua Bloch 建议使用 Enum 实现单例。


因为 Java 可以保证 enum value 只会被初始化一次。


既于 enum 的值都是 public 的,这种方式可以作为单例的实现之一。



缺点:


不够灵活。


急初始化,不能懒初始化。


public enum EnumSingleton {

    INSTANCE;

    public static void doSomething(){
        System.out.println("do something...");
    }
}




[b]3、Serializtion and Singleton(单例序列化)[/b]



在分布式系统中,有时候需要对单例进行序列化(实现 Serializable 接口),


以便在系统磁盘中(或网络传输中)保存单例的状态,然后在后续的某个点取得具状态的单例。



在反序列化单例时,可能会使得到的实例与原来的不同(如果单例仅仅实现 Serializable 接口)。


解决方案是重写 Serializtion API 中的 readResolve() 方法。



import java.io.Serializable;

public class SerializedSingleton implements Serializable{

    private static final long serialVersionUID = -7604766932017737115L;

    private SerializedSingleton(){}

    private static class SingletonHelper{
        private static final SerializedSingleton instance = new SerializedSingleton();
    }

    public static SerializedSingleton getInstance(){
        return SingletonHelper.instance;
    }

    // This will fix the de-serialization issue
    private Object readResolve() {
         // Return the available instance instead.
        return getInstance();   
    }

}

/*

    readResolve() is used for replacing the object read from the stream. 
    The only use I've ever seen for this is enforcing singletons; 
    when an object is read, replace it with the singleton instance. 
    This ensures that nobody can create another instance by serializing 
    and de-serializing the singleton.

*/




测试类:



import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class SerializedSingletonTest {

    public static void main(String[] args) 
            throws FileNotFoundException, IOException, ClassNotFoundException {
        SerializedSingleton instanceOne = SerializedSingleton.getInstance();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream("filename.ser"));
        out.writeObject(instanceOne);
        out.close();

        //deserailize from file to object
        ObjectInput in = new ObjectInputStream(new FileInputStream("filename.ser"));
        SerializedSingleton instanceTwo = (SerializedSingleton) in.readObject();
        in.close();

        System.out.println("instanceOne hashCode = "+instanceOne.hashCode());
        System.out.println("instanceTwo hashCode = "+instanceTwo.hashCode());

    }

}


-