第3条：用私有构造器或者枚举类型强化Singleleton属性

实现Singleton模式，需要要把构造器保持为私有的，并导出公有的静态成员，以便允许客户端能够访问该类的唯一实例。

1.饿汉式

饿汉式(Eager mode)：单例对象是个 final域，在类加载期间，就实例化一个对象交给自己的引用instance，如：

// Singleton with Eager mode
public class SingletonA
{
    //实例化一个对象交给自己的引用
    private static final instance = new SingletonA();
    //私有化构造器
    private SingletonA(){}
    //返回单例对象
    public static SingletonA getInstance()
    {
        return instance;
    }
}

2.懒汉式

懒汉式(Lazy mode)公有的成员是个静态工厂方法，在调用取得实例方法的时候才会实例化对象
懒汉第1式：

//Singleton with Lazy mode
public class SingletonB
{
    private static instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)
            instance = new SingletonB();
        return instance;
    }
}

如果线程1进入了if语句，但还未实例化instance，此时，线程2访问到getInstance的if判断，因为instance还未实例化，所以也进入if内部；于是线程1和线程2，最后创建了两个实例。

懒汉第2式：同步锁

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

可以有效防止多线程在执行getInstance方法得到2个对象，但是：

只有在instance为null时，才必须要求同步。一旦singleton不为null，系统依旧花费同步锁开销

懒汉第3式：

public static SingletonB getInstance()
{

    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            instance = new SingletonB();//3
        }
        return instance;
}

这种写法减少了锁开销，但是依旧可能创建了2个对象。

线程1执行到1挂起，线程1认为singleton为null
线程2执行到1挂起，线程2认为singleton为null
线程1被唤醒执行synchronized块代码，走完创建了一个对象
线程2被唤醒执行synchronized块代码，走完创建了另一个对象

懒汉第4式：双重锁定检查（DCL）

public static SingletonB getInstance()
{

    if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
}

看是没有问题，但在instance = new SingletonB()这句中，却暗藏杀机，因为jvm在执行这句代码时，实际分为三步：开辟内存空间，赋值给引用，初始化数据。这是需要消耗时间。

懒汉最终式：volatile

volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。

//Singleton with Lazy mode
public class SingletonB
{
    private static volatile instance;
    private SingletonB(){}
    public static SingletonB getInstance()
    {
        if(instance == null)//1
        synchronized(SingletonB.class)//2
        {
            if(instance == null)
            {
                instance = new SingletonB();//3
            }
        }
        return instance;
    }
}

volatile变量具有synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile变量的最新值

3.Lazy initialization holder class模式(静态内部类加载方式)

根据JLS(Java Language Specification)中的规定，一个类在一个ClassLoader中只会被初始化一次，这点是JVM本身保证的

public class SingletonC
{
    private static instance;
    //私有化构造器
    private SingletonC(){}
    //返回单例对象
    public static SingletonC getInstance()
    {
        return SingletonHolder.INSTANCE;
    }
    private static class SingletonHolder
    {
        //单例对象实例
        static final SingletonC INSTANCE = new SingletonC();     
    }  
}

这种写法仍然使用JVM本身机制保证线程安全问题
由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的
同时读取实例的时候不会进行同步，没有性能缺陷
也不依赖JDK版本
从其他途径屏蔽构造单例对象的方法
直接new单例对象
一般加入一个private或者protected的构造函数

4.通过反射构造单例对象

需要在ReflectPermission(“suppressAccessChecks”) 权限下使用安全管理器（SecurityManager）的checkPermission方法来限制这种突破。 一般来说，不会真的去做这些事情，都是通过应用服务器进行后台配置实现

5.通过序列化构造单例对象

单例对象有必要实现Serializable接口，则应当同时实现readResolve()方法，以保证反序列化的时候得到原来的对象

public class Singleton implements Serializable 
{
    private static class SingletonHolder
    {
        static final Singleton INSTANCE = new Singleton();     
    }     
    public static Singleton getInstance()
    {     
        return SingletonHolder.INSTANCE; 
    }
    //private的构造函数用于避免外界直接使用new来实例化对象  
    private Singleton() {     
    }     
    //readResolve方法应对单例对象被序列化   
    private Object readResolve() {     
        return getInstance();     
    }     
}  

6.单例与枚举

按照《Effective Java 第二版》中的说法：单元素的枚举类型已经成为实现Singleton的最佳方法。用枚举来实现单例非常简单，只需要编写一个包含单个元素的枚举类型即可。

public enum SingletonEnum
{
    INSTANCE;
    private String field;
    public String getField()
    {
        return field;
    }
    public void setField(String field)
    {
        this.field = field;
    }
    @Override
    public String toString()
    {
        return "SingletonEnum{" +
            "field='" + field + '\'' +
            '}';
    }
}

自由序列化
保证只有一个实例(使用反射机制也无法多次实例化一个枚举量)
使用单元素的枚举类型实现Singleton时，通过反射机制去创建新的实例时会抛出异常。

Singleton Mode总结

优点

在内存中只有一个对象，节省内存空间
避免频繁的创建销毁对象，可以提高性能
避免对共享资源的多重占用
可以全局访问

适用场景

需要频繁实例化然后销毁的对象
创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
有状态的工具类对象。
频繁访问数据库或文件的对象。