单例模式

最近在review代码的时候发现一个假单例模式， 从而想总结下单例模式。假单例模式代码如下：

public class RuleContext {

    private static RuleContext ruleContext = new RuleContext();

    private ThreadLocal<List<Map<String, Object>>> ruleErrors = new ThreadLocal();
    
    public RuleContext() {
    }

    public static RuleContext getInst() {
        return ruleContext;
    }
}

从代码中可以看出类的构造函数（第七行）是public类型，不能保证只有一个实例。

一、单例模式定义

从上面假单例代码中可以看出，单例模式保证一个类仅有一个实例，并且提供一个全局访问点。有以下几个特点：

      1、单例类只能有一个实例

      2、单例类必须自己实例化

      3、提供一个全局访问点

二、基本实现思路

   1、将类的构造方法定义为私有方法，这样其它地方就不能够通个构造方法来实例化该类对象，只有通过该类的静态方法来获得该类的实例

   2、在该类内部提供一个静态方法，当调用该方法时，判断类的实例是否为空，不为空则返回，为空则实例化对象

三、实现方式

   1、懒汉式， 线程不安全

    懒汉顾名思义：懒惰，当程序第一次访问单件模式实例时才进行创建。

/**
 * <Description> <br>
 *
 * @author jy<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2019年04月01日 <br>
 * @since R9.0<br>
 * @see com <br>
 */
public class SingletonDemo {
    // 利用静态变量来记录唯一实例
    private static SingletonDemo singletonDemo;

    // 私有构造方法
    private SingletonDemo() {

    }

    // 在该类内部提供一个静态方法获取实例
    public static SingletonDemo getInstance() {
        if (singletonDemo == null) {
            singletonDemo = new SingletonDemo();
        }
        return singletonDemo;
    }
}

 此实现方式为线程不安全，当两个线程同时访问getInstance方法时会初始化不同的实例，原因在于方法没有加synchronized锁，严格意义上此实现方式不为单例模式

   2、懒汉式，线程安全

   这种实现方式只需要在前一种方式中获取实例方法上加锁，效率低下，但是做到延迟加载，节省内存，代码如下

public class SingletonDemo {
    // 利用静态变量来记录唯一实例
    private static SingletonDemo singletonDemo;

    // 私有构造方法
    private SingletonDemo() {

    }

    // 在该类内部提供一个静态方法获取实例,加锁保证保证单例，效率会低下，每次都会
    public static synchronized  SingletonDemo getInstance() {
        if (singletonDemo == null) {
            singletonDemo = new SingletonDemo();
        }
        return singletonDemo;
    }
}

  3、饿汉式，线程安全

   饿汉：类加载时就初始化，基于 classloader 机制避免了多线程的同步问题，不用加锁，效率高，不能够延迟加载，浪费内存

public class SingletonDemo2 {
    // 利用静态变量来记录唯一实例
    private static SingletonDemo2 singletonDemo = new SingletonDemo2();

    // 私有构造方法
    private SingletonDemo2() {

    }

    // 在该类内部提供一个静态方法获取实例,
    public static SingletonDemo2 getInstance() {
        return singletonDemo;
    }
}

4、双重检锁，线程安全

public class SingletonDemo1 {
    /*
     * 利用静态变量来记录SingletonDemo1的唯一实例
     * volatile 关键字确保：当singleInstance变量被初始化成Singleton实例时，
     * 多个线程正确地处理singleInstance变量,实际上让cpu指令禁止指令重排
     */
    private volatile static SingletonDemo1 singleInstance;

    private SingletonDemo1() {

    }
  
    public static SingletonDemo1 getSingleInstance() {
        if (singleInstance == null) {
            synchronized (SingletonDemo1.class) {
                if (singleInstance == null) {
                    singleInstance = new SingletonDemo1();
                }
            }
        }
        return singleInstance;
    }
}

5、静态内部类，线程安全

public class SingletonDemo5 {
    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final SingletonDemo5 INSTANCE = new SingletonDemo5();
    }

    // 私有构造
    private SingletonDemo5() {
    }

    // 静态方法
    public static final SingletonDemo5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

6、枚举、线程安全

public enum Singleton6 {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}