设计模式——单例模式

单例模式

@author lisiwen

@createTime 2019/12/30

​ **单例模式(Singleton)：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。

​ 通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象。一个最好的办法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

代码示例

Singleton.java

/**
 * @ProjectName: designpattern
 * @ClassName: Singleton
 * @Description: Singleton类，定义一个GetInstance操作，允许客户访问它的唯一实例。GetInstance是一个静态方法，主要负责创建自己的唯一实例。（懒汉模式）线程不安全，延迟初始化，严格意义上不是不是单例模式
 * @Author: lisiwen
 * @Date: 2019/12/30 9:13
 **/
public class Singleton {
    private static Singleton singleton;

    /**
     * @Description 构造方法让其privatre，这就堵死了外接利用new创建此类实例的可能。
     * @Date 2019/12/30 9:19
     * @param
     * @Return
     **/
    private Singleton() {
    }

    /**
     * @Description 此方法是获得本类实例的唯一全局访问点
     * @Date 2019/12/30 9:19
     * @param
     * @Return singleton.Singleton
     **/
    public static Singleton GetInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

Main.java

/**
 * @ProjectName: designpattern
 * @ClassName: Main
 * @Description: 客户端代码
 * @Author: lisiwen
 * @Date: 2019/12/30 9:15
 **/
public class Main {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.GetInstance();
        Singleton singleton2 = Singleton.GetInstance();
        //比较两次实例化后对象的结果是十里相同
        if (singleton1 == singleton2) {
            System.out.println("两个对象是相同的实例");
        }
    }
}
// 控制台输出
两个对象是相同的实例

单例模式好处

单例模式因为Singleton类封装它的唯一实例，这样它可以严格地控制客户怎样访问他以及何时访问它。简单的说就是对唯一实例的受控访问。

多线程时的单例

1. 双重锁模式

   ​ 双重检查模式，进行了两次的判断，第一次是为了避免不要的实例，第二次是为了进行同步，避免多线程问题。由于singleton=new Singleton()对象的创建在JVM中可能会进行重排序，在多线程访问下存在风险，使用volatile修饰signleton实例变量有效，解决该问题。

SingletonDoubleLock.java

/**
 * @ProjectName: designpattern
 * @ClassName: SingletonDoubleLock
 * @Description: 支持多线程（双重锁模式），线程安全，延迟初始化。这种方式采用双锁机制，安全且在多线程情况下能保持高性能
 * @Author: lisiwen
 * @Date: 2019/12/30 13:48
 **/
public class SingletonDoubleLock {
    /**
     * 由于singleton=new Singleton()对象的创建在JVM中可能会进行重排序，在多线程访问下存在风险，使用volatile修饰signleton实例变量有效，解决该问题。
     */
    private volatile static SingletonDoubleLock singleton;

    private SingletonDoubleLock() {
    }

    public static SingletonDoubleLock getSingleton() {
        // 先判断实例是否存在，不存在加锁处理。
        if (singleton == null) {
            //在同一时刻加了锁的那部分程序只有一个线程可以进入
            synchronized (SingletonDoubleLock.class) {
                if (singleton == null) {
                    singleton = new SingletonDoubleLock();
                }
            }
        }
        return singleton;
    }
}

2. 静态内部类单例模式

   ​ 只有第一次调用getInstance方法时，虚拟机才加载 Inner 并初始化instance ，只有一个线程可以获得对象的初始化锁，其他线程无法进行初始化，保证对象的唯一性。目前此方式是所有单例模式中最推荐的模式，但具体还是根据项目选择。

SingletonStaticInnerClass.java

/**
 * @ProjectName: designpattern
 * @ClassName: SingletonStaticInnerClass
 * @Description: 静态内部类单例模式
 * @Author: lisiwen
 * @Date: 2019/12/30 13:55
 **/
public class SingletonStaticInnerClass {
    private SingletonStaticInnerClass() {
    }

    public static SingletonStaticInnerClass getInstance() {
        return Inner.instance;
    }

    private static class Inner {
        private static final SingletonStaticInnerClass instance = new SingletonStaticInnerClass();
    }
}

3. 静态初始化

   ​ 这种静态初始化的方式是在自己被加载时就将自己实例化，所以被形象的称之为饿汉式单例类，原先的单例模式处理方式是要在第一次被引用时，才会将自己实例化，所以被称之为懒汉式单例模式。

SingletonInitiateStatic.java

/**
 * @ProjectName: designpattern
 * @ClassName: SingletonInitiateStatic
 * @Description: 静态初始化单例模式（饿汉模式） 线程安全，比较常用，但容易产生垃圾，因为一开始就初始化
 * @Author: lisiwen
 * @Date: 2019/12/30 13:59
 **/
public class SingletonInitiateStatic {

    private static SingletonInitiateStatic instance = new SingletonInitiateStatic();

    private SingletonInitiateStatic() {
    }

    public static SingletonInitiateStatic getInstance() {
        return instance;
    }
}