Java设计模式之单例模式

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

使用场景
确保某个类有且只有一个对象的场景，例如创建一个对象需要消耗的资源过多，如要访问 IO 和数据库等资源。

单例模式分3种:懒汉式单例，饿汉式单例，登记式单例。
特点:
1.单例类只能有一个实例
2.单例类必须自己创建自己的唯一实例
3.单例类必须给所有其他对象提供这一实例

在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。

懒汉式单例:

public class Singleton {
    //1.创建私有化构造方法
    private Singleton(){
    }

    //2.创建静态实例
    private static Singleton single=null;

    //3获取单例对象的方法
    public static Singleton getInstance(){
        if(single==null){
            single=new Singleton();
        }
        return single;
    }
}

懒汉式单例(多线程同步):

public class Singleton {
    //1.创建私有化构造方法
    private Singleton(){
    }

    //2.创建静态实例
    private static Singleton single=null;

    //3.获取单例对象的方法
  public static synchronized Singleton getInstance(){
        if(single==null){
            single=new Singleton();
        }
        return single;
    }
}

此方法采用在方法上面加入synchronized，效率比较低，不推荐使用。

懒汉式单例(多线程同步)(双重检查锁定)

public class Singleton {
    //1.创建私有化构造方法
    private Singleton(){
    }

    //2.创建静态实例
    private static volitale Singleton single=null;

    //3获取单例对象的方法
public static Singleton getInstance(){
        if(single==null){
            synchronized (Singleton.class) {
                if(single==null){
                    single=new Singleton();
                }
            }
        }
        return single;
    }
}

懒汉式单例(多线程同步)(内部静态类)

public class Singleton {

    //1.创建私有化构造方法
        private Singleton(){
    }

    //2.创建内部静态类
     private static class LazyHolder{
        private static final Singleton INSTANCE=new Singleton();
    }

    //3.获取单例对象的方法
    public static Singleton getInstance(){
        return LazyHolder.INSTANCE;
    }
}

推荐使用此方法进行单例模式。

饿汉式单例:

    public class Singleton {
    //1.创建私有化构造方法
        private Singleton(){
        }
    //2.创建静态实例
    private static final Singleton singleton=new Singleton();

    //获取单例对象的方法
    public static Singleton getInstance(){
        return singleton;
    }
}

登记式单例:

public class Singleton {
    //创建静态的Map集合
    private static Map<String,Singleton> map=new HashMap<>();

    static{
        Singleton single=new Singleton();
        map.put(single.getClass().getName(), single);
    }

    private Singleton(){
    }

     //静态工厂方法,返还此类惟一的实例
    public static Singleton getInstance(String name) {
        if(name == null) {
            name = Singleton3.class.getName();
        }
        if(map.get(name) == null) {
            try {
                map.put(name, (Singleton3) Class.forName(name).newInstance());
            } catch (InstantiationException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
        return map.get(name);
    }
}

登记式单例实际上维护了一组单例类的实例，将这些实例存放在一个Map（登记薄）中，对于已经登记过的实例，则从Map直接返回，对于没有登记的，则先登记，然后返回。

饿汉式和懒汉式区别
从名字上来说，饿汉和懒汉，
饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，
而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。
另外从以下两点再区分以下这两种方式：

1、线程安全：
饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，
懒汉式本身是非线程安全的，为了实现线程安全有几种写法，分别是上面的1、2、3，这三种实现在资源加载和性能方面有些区别。

什么是线程安全？
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
或者说：一个类或者程序所提供的接口对于线程来说是原子操作，或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题，那就是线程安全的。

2、资源加载和性能：
饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，
而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。
至于1、2、3这三种实现又有些区别，
第1种，在方法调用上加了同步，虽然线程安全了，但是每次都要同步，会影响性能，毕竟99%的情况下是不需要同步的，
第2种，在getInstance中做了两次null检查，确保了只有第一次调用单例的时候才会做同步，这样也是线程安全的，同时避免了每次都同步的性能损耗
第3种，利用了classloader的机制来保证初始化instance时只有一个线程，所以也是线程安全的，同时没有性能损耗，所以推荐使用第三种方法。

优点
由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁地创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
由于单例模式只生成一个实例，所以减少了系统的性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决；
单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

缺点
单例模式一般没有接口，扩展很困难，若要扩展，除了修改代码基本上没有第二种途径可以实现。

参考:
Android 设计模式源码解析