设计模式之单例（java语言）

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

Singleton通过将构造方法限定为private避免了类在外部被实例化，在同一个虚拟机范围内，Singleton的唯一实例只能通过getInstance()方法访问（事实上，通过Java反射机制是能够实例化构造方法为private的类的，那基本上会使所有的Java单例实现失效。此问题在此处不做讨论。）

单例模式有以下特点：

1. 单例类只能有一个实例
2. 单例类必须自己创建自己的唯一实例
3. 单例类必须给所有其他对象提供这一实例

单例模式有以下有点：

1. 由于只有一个实例，故可以减少内存开销
2. 可以避免对资源的多重占用，避免对同一资源进行多种操作
3. 设置了全局的资源访问，可以优化和共享全局资源访问

单例模式的几种实现方法

• 懒汉单例

public class Singleton {
    private static Singleton single=null;
    private Singleton() {    }
    public static Singleton getInstance() {
        if(single==null) {
            single=new Singleton();
        }
        return single;
    }
}
特点：在第一次调用的时候实例化自己
优点：在需要的时候才去加载
缺点：在多线程的环境下，会出现线性不安全的情况

懒汉式单例的实现没有考虑线程安全问题，它是线程不安全的，并发环境下很可能出现多个Singleton实例，要实现线程安全，有以下三种方式，都是对getInstance这个方法改造，保证了懒汉式单例的线程安全.

1.1 在getInstance方法上加同步
public class Singleton {
    private static Singleton single=null;
    private Singleton() {    }
    public static synchronized Singleton getInstance() {
        if(single==null) {
            single=new Singleton();
        }
        return single;
    }
}
优点：解决了线性同步问题
缺点：每次调用都要判断同步锁，导致效率低

1.2 双重检查锁
public class Singleton {
    private static Singleton single=null;
    private Singleton() {    }
    public static Singleton getInstance() {
        if(single==null) {
            synchronized(Singleton.class) {
                if(single==null) {
                    single=new Singleton();
                }
            }
        }
        return single;
    }
}
优点：在并发量不高、安全性不高的情况下可以很好的运行,在getInstance中做了两次null检查，
确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
缺点：在不同的编译环境下可能出现不同的问题

1.3 静态内部类
public class Singleton {
    private static class Holder {
        private static final Singleton INSTANCE=new Singleton();
    }
    private Singleton() {    }
    public static final Singleton getInstance() {
        return Holder.INSTANCE;
    }
}
优点：延迟加载、线性安全、减少内存消耗
这种比上面1.1、1.2都好一些，既实现了线程安全，又避免了同步带来的性能影响。

• 饿汉单例

public class Singleton {
    private Singleton() {}
    private static final Singleton single=new Singleton();
    //静态工厂方法
    public static Singleton getInstance() {
        return single;
    }
}
特点：在类初始化时，已经自行实例化
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

• 枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {    }
}
它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象，可谓是很坚强的壁垒啊，不过，个人认为由于1.5中才加入enum特性，用这种方式写不免让人感觉生疏，在实际工作中，我也很少看见有人这么写过。

饿汉式和懒汉式区别 ：

• 饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，
• 而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
• 饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
• 懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1.1、1.2、1.3，这三种实现在资源加载和性能方面有些区别。