开始前，球球各位读者给个三连吧，有错误感谢指出，谢谢

单例模式也叫单个实例，也就是这个类只有且只能有一个实例对象，这样一个类就叫做“单例”；单例模式有很多种，这里只介绍“饿汉模式”和“懒汉模式”两种；

饿汉模式

唯一实例创建的时机非常早

//饿汉模式
class Singleton{
    //私有静态的实例对象，外部无法获取，随着类的记载而加载
    //类对象属性，保证只有一个
    private static Singleton singleton=new Singleton();
    //共有的静态方法，外界能够直接直接通过类名访问，获取该单例对象
    public static Singleton getSingleton(){
        return singleton;
    }
    //私有方法，确保外部无法创建该对象的实例
    private Singleton(){}
}
public class demo5 {
    public static void main(String[] args) {
        Singleton s1= Singleton.getSingleton();
        Singleton s2= Singleton.getSingleton();
        //s1，s2指向的是同一个类对象
        System.out.println(s1==s2);//true
        Singleton s3=new Singleton();//报错，外部无法再new一个实例对象
    }
}

懒汉模式

只有当该类第一次被实例化的才实例化，如果该类没有被实例化就不实例化，且要确保后续无法再次实例化，确保只有一个实例化对象；

//"懒汉模式"
class SingletonLazy{
    //首先实例对象要设置为空
    private static SingletonLazy singletonLazy=null;
    //共有的获取该类唯一实例对象的方法
    public static SingletonLazy getSingletonLazy(){
        if(singletonLazy==null){
            singletonLazy=new SingletonLazy();
        }
        return singletonLazy;
    }
    //私有的构造方法，外部无法创建该类的实例化对象
    private SingletonLazy(){}
}
public class demo6 {
    public static void main(String[] args) {
        SingletonLazy s1=SingletonLazy.getSingletonLazy();
        SingletonLazy s2=SingletonLazy.getSingletonLazy();
        //s1，s2指向的是同一个实例化对象；
        System.out.println(s1==s2);//true
        //无法创建实例化对象
        SingletonLazy s3=new SingletonLazy();
    }
}

两种模式的最大的区别就是唯一对象创建的实际不同，饿汉模式会在第一个时间创建，只要该类加载内存，唯一实例化对象就随着被创建，而懒汉模式只有当被第一次调用需要实例化对象是才会实例化唯一对象，如果不调用，就不创建；

如果程序中包含多个单例类，使用饿汉模式，刚开始就会扎堆创建很多个单例对象，可能会使得程序启动变慢，如果是懒汉模式，只有当被调用时被会实例化对象，实际是分散的，不容易感觉卡顿；

单例模式一般运用在类只需要一个实例化对象的时候，或者需要避免该类被实例化第二个对象；举个例子：你写的服务器，要从硬盘上加载100G的数据到内存中，肯定要写成一个类，封装上述加载操作，并且写一些获取/处理数据的逻辑方法，这样的类，就因该是单例的，一个实例化就要管理100g的数据，多个实例，就要加载N*100G的数据，这是没有必要，机器也是吃不消的；

 

单例模式在多线程如何保证线程安全

饿汉模式在多线程是安全的，但是懒汉模式在多线程是不安全的；

饿汉模式是安全的因为在线程还没有创建之前，唯一实例化对象就随着类的加载而创建了，所以后续无论是多少个线程的单例对象指向的都是同一个实例化对象；

懒汉模式之所以在多线程是不安全，是因为在该模式下的实例化对象是在程序运行中被创建的，这其中就有可能多个线程同时实例化对象，不安全那就要加锁，但是加锁在哪里又是一个需要考虑的问题，结合下面两个线程同时实例化对象的可能过程一起来了解一下吧

第一种情况：锁在new对象的时候

第二种情况：锁在判断对象是否为空的时候

第二种情况的优化

第二种情况无疑是可以在一定程度上确保线程安全的，但是针对第二种情况我们还可以再做优化，由于以上例子只是在只有两个线程访问时确保线程安全，如果有多个线程访问，这时候后续的每一个线程在获取实例化对象的，还是每次都要加锁然后再去判断对象是否为空，加锁的开销也是很大的，是一定程度上会拖慢程序的运行的，这使得加锁在一定程度上与低效挂钩，所以第二种情况的优化就是在进行一个判断singletonLazy是否为空，代码如下：

public static SingletonLazy getSingletonLazy(){
       if(singletonLazy==null){
           synchronized (singletonLazy){
               if(singletonLazy==null){
                   singletonLazy=new SingletonLazy();
               }
           }
       }
        return singletonLazy;
    }

还有一点补充，虽然这一点不会100%出现，就是编辑器对代码进行了优化，出现内存可见性的情况，即singletonLazy存在寄存器里，当线程创建了该类的唯一实例化对象时，singletonLazy并没有修改指向该对象，所以可以在上volatile关键字；

以下时懒汉模式在多线程依然保持安全完整代码：

//"懒汉模式"
class SingletonLazy{
    //首先实例对象要设置为空
    private static volatile SingletonLazy singletonLazy=null;
    //共有的获取该类唯一实例对象的方法
    public static SingletonLazy getSingletonLazy(){
       if(singletonLazy==null){
           synchronized (singletonLazy){
               if(singletonLazy==null){
                   singletonLazy=new SingletonLazy();
               }
           }
       }
        return singletonLazy;
    }
    //私有的构造方法，外部无法创建该类的实例化对象
    private SingletonLazy(){}
}