设计模式（二）单例模式

单例模式：保证只有一个对象，每次获取对象获取到的都是同一个对象。
单例模式是我们程序中最常见的设计模式，很多工具类都设计成单例模式，spring中的bean也有单例，单他不是真正的单例。
单例模式总结下来有几种写法，他们共性就是私有的构造方法。

• 懒汉式

package com.designPattern.singleton;

/**
 * 线程安全的 低效率的 懒加载
 * 直接在方法上加互斥锁 synchronized 。简单粗暴
 * 但是效率低。不加锁线程不安全，是错误代码
 */
public class SafeLazy {
    private static SafeLazy safeLazy;
    private SafeLazy(){};
    public static  synchronized  SafeLazy getInstance(){
        if(safeLazy==null){
            return new SafeLazy();
        }
        return safeLazy;
    }

• 饿汉模式

package com.designPattern.singleton;

/**
 * 饿汉模式 由于太饿了就在初始化的时候创建对象。
 * 饿汉模式是线程安全的，但是不适合单例的大对象。
 * 或者是不常用的对象。
 */
public class Singleton {
    private static  Singleton singleton = new Singleton();
    private Singleton(){};
    public  static Singleton getInstance(){
        return singleton;
    }
}

• （双重检查锁）线程安全的懒汉模式

package com.designPattern.singleton;

/**
 * 双重校验锁
 * 保证了线程的安全，
 * 效率比方法上互斥锁要高效，适合并发。
 * 当判断到没有实例化之后，
 * 再加锁保证线程安全判断是否仍然没有实例化
 */
public class DoubleSafeLazy {
    private static  DoubleSafeLazy safeLazy ;
    private  DoubleSafeLazy (){}
    public static DoubleSafeLazy getInstance(){
        if(safeLazy == null ){
            synchronized (DoubleSafeLazy.class){
                if(safeLazy==null){
                    safeLazy = new DoubleSafeLazy();
                }
            }
        }
        return safeLazy;
    }
}

• 内部类的方式

package com.designPattern.singleton;

/**
 * 内部类的方式
 * 借用了外部类装载的时候，内部类不装载的特性。
 */
public class InnerSingleton {
    public static final   InnerSingleton getInstance() {
        return InnerSingletonBuilder.singleton;
    }
    private  InnerSingleton (){}
    private final  static class InnerSingletonBuilder {
        private  static InnerSingleton singleton = new InnerSingleton();
    }
}

• 枚举的方式
  这种非常不常见，暂时不上代码。

另外有必要说一下spring的单例，spring的单例是在spring容器初始化的时候，会把bean对象创建好，放入上下文中，已一个map的形式存储， key 是bean的id，value是bean的实例对象。当每次取bean的实例的时候从map中获取，这样的单例是指的spring容器中的单例，不是真正的单例。