设计模式-单例模式

单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

• 优点：
  1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
  2、避免对资源的多重占用（比如写文件操作）。

• 缺点
  没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

懒汉模式

类加载的时候不初始化单例对象，第一次调用的时候才进行初始化操作。

• 实现

public class SingletonLazy {

    private static SingletonLazy singleTest = null;



    /**
     * 第一种方式
     * 线程不安全，多线程下存在安全问题
     * @return
     */
    public SingletonLazy getinstall(){
        if (singleTest == null){
            singleTest = new SingleTest();
        }
        return singleTest;
    }

    /**
     * 第二种实现方式
     *  通过加锁 synchronized 保证单例
     * 采用synchronized 对方法加锁有很大的性能开销
     * 解决办法：锁粒度不要这么大
     * @return
     */
     public static synchronized SingletonLazy getinstall(){
         if (singleTest == null) {
             singleTest = new SingletonLazy();
         }
         return singleTest;
    }



    /**
     * 第三种实现方式
     * DCL 双重检查锁定 （Double-Checked-Locking）,在多线程情况下保持高性能
     * 这是否安全，instance = new SingletonLazy(); 并不是原子性操作
     * 1、分配空间给对象
     * 2、在空间内创建对象
     * 3、将对象赋值给引用instance
     *
     * 假如线程 1-》3-》2顺序，a线程1、3执行完会把值写会主内存，b线程就能读取到instance最新的值为null，b线程拿到的是一个被赋予了默认值但是未初始化的对象，刚刚可以通过锁的检索！
     * (指令重排)
     * @return
     */
    public static SingletonLazy getinstall(){
        if (singleTest == null) {
            synchronized (SingletonLazy.class) {
                if (singleTest == null){
                    singleTest = new SingletonLazy();
                }
            }
        }
        return singleTest;
    }


    /**
     * 第四种实现方式
     * volatile是Java提供的关键字，它具有可见性和有序性，
     * 指令重排序是JVM对语句执行的优化，只要语句间没有依赖，那JVM就有权对语句进行优化
     * 禁止了指令重排
     */
    private static volatile SingletonLazy instance;
    public static  SingletonLazy getInstance(){
        //第一重检查
        if(instance == null){
            // A、B ，锁定
            synchronized (SingletonLazy.class){
                //第二重检查
                if(instance == null) {
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

饿汉模式

类加载的时候实例化单例对象

• 优点
  没有加锁，执行效率会提高。

• 缺点
  类加载时就初始化，浪费内存。

• 实现

public class Singleton {  
	//类加载的时候初始化
    private static Singleton instance = new Singleton();  
    private Singleton (){}  
    public static Singleton getInstance() {  
    return instance;  
    }  
}