一、简介

单例模式是确保一个类只有一个实例，并提供全局访问点（本质上与静态类不一致）。

构造函数私有，防止在外部被new
内部必须提供一个静态的方法，让外部调用

二、基本实现

实现单例模式，通常有2种方式：懒汉式、饿汉式
饿汉式：类加载时自动创建单例，线程安全。
懒汉式：有需要时，才创建单例，线程不安全。
静态内部类：保证线程安全，有需要时，才创建单例
容器管理：静态代码块中进行实例化
饿汉式

public class Singleton {

    //随着类加载对象已经存在
    private static Singleton mSingleton=new Singleton();

    //防止被实例化
    private Singleton() {
    }

    public static Singleton getmSingleton() {
        return mSingleton;
    }
}

懒汉式

public class Singleton {

    //**volatile作用：一、防止重排序（1、开辟内存空间2、初始化对象3、变量赋值）二 、线程可见性（某一个线程改变了公共变量，短时间内另一个 线程可能是不可见的）**
    private static volatile Singleton mSingleton;

    //防止new创建
    private Singleton() {
    }

    /**
     * synchronized 线程锁，避免多线程并非造成的问题,不放在方法上，是为了提高效率
     */
    public static Singleton getmSingleton() {
        if (mSingleton == null) {
            synchronized (Singleton.class) {
                if (mSingleton == null) {
                    mSingleton = new Singleton();
                }
            }
        }
        return mSingleton;
    }
}

静态内部类

public class Singleton {

    //防止new创建
    private Singleton() {
    }

    public static Singleton getmSingleton() {
        return SingleHolder.mSingleton;
    }

    public static class SingleHolder() {
        private static volatile Singleton mSingleton=new Singleton();
    }
}

容器管理

public class Singleton {

  private static Map<String,Object> mSingleMap=new HashMap<>();

  static{
      mSingleMap.put("single",new Singleton())
  }

    //防止new创建
    private Singleton() {
    }

    public static Singleton getmSingleton() {
        return  (Singleton)(mSingleMap.get("single"));
    }

}