概念：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。

这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1 、单例模式的结构

单例模式的主要有以下角色：

单例类。只能创建一个实例的类

访问类。使用单例类

2 、单例模式的实现

单例设计模式分类两种：

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

2.1、饿汉式（静态变量方式）

package com.jie.creator.singleton.demo01;
/**
 * @description:饿汉式:静态变量创建类的对象
 * @author: jie 
 * @time: 2022/1/29 14:43
 */
public class Singleton {
    /**
     * @description:构造器私有化，避免外部创建对象
     */
    private Singleton() {}

    /**
     * @description:在本类中创建本类对象,static修饰，保障其能够被静态方法访问
     */
    private static Singleton instance = new Singleton();

    /**
     * @description:外部直接调用静态方法实例化对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}

package com.jie.creator.singleton.demo01;
/**
 * @description:测试类
 * @author: jie
 * @time: 2022/1/29 14:44
 */
public class Test {
    public static void main(String[] args) {
        //1、创建Singleton类的对象
        Singleton singleton = Singleton.getInstance();

        Singleton singleton1 = Singleton.getInstance();

        //判断获取到的两个是否是同一个对象
        System.out.println(singleton==singleton1);
    }
}

结果为true,说明singleton和singleton1在内存储中是同一块内存地址，那么它俩是同一个对象。

该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

2.2、饿汉式（静态代码块方式）

package com.jie.creator.singleton.demo02;
/**
 * @description:饿汉式:在静态代码块中创建该类对象
 * @author: jie 
 * @time: 2022/1/29 15:59
 */
public class Singleton {

    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}

    /**
     * @description:在成员位置创建该类的对象
     */
    private static Singleton instance;
    /**
     * @description:在静态代码块中进行赋值
     */
    static {
        instance = new Singleton();
    }

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}

package com.jie.creator.singleton.demo02;


/**
 * @description:测试类
 * @author: jie
 * @time: 2022/1/29 16:04
 */
public class Test {
    public static void main(String[] args) {
        //1、创建Singleton类的对象
        Singleton singleton = Singleton.getInstance();

        Singleton singleton1 = Singleton.getInstance();

        //判断两次获取到的Singleton对象是否是同一个对象
        System.out.println(singleton==singleton1);
    }
}

结果为true,说明singleton和singleton1在内存储中是同一块内存地址，那么它俩是同一个对象。

该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的静态变量方式基本上一样，当然该方式也存在内存浪费问题。

2.3、懒汉式(线程不安全)

package com.jie.creator.singleton.demo03;
/**
 * @description:懒汉式:线程不安全
 * @author: jie 
 * @time: 2022/1/29 16:19
 */
public class Singleton {
    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}

    /**
     * @description:在成员位置创建该类的对象,当前只是声明了一个该类型的变量，并没有进行赋值
     */
    private static Singleton instance;

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        //判断instance是否为Null.如果为null，说明还没有创建Singleton类的对象
        //如果没有创建，创建一个并返回，如果有直接返回
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

package com.jie.creator.singleton.demo03;



/**
 * @description:测试类
 * @author: jie
 * @time: 2022/1/29 16:04
 */
public class Test {
    public static void main(String[] args) {
        //1、创建Singleton类的对象
        Singleton singleton = Singleton.getInstance();

        Singleton singleton1 = Singleton.getInstance();

        //判断两次获取到的Singleton对象是否是同一个对象
        System.out.println(singleton==singleton1);
    }
}

结果为true,说明singleton和singleton1在内存储中是同一块内存地址，那么它俩是同一个对象。

从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，就会出现线程安全问题。

2.4、懒汉式(线程安全)

package com.jie.creator.singleton.demo04;
/**
 * @description:懒汉式:线程安全
 * @author: jie
 * @time: 2022/1/29 16:49
 */
public class Singleton {
    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}

    /**
     * @description:在成员位置创建该类的对象,当前只是声明了一个该类型的变量，并没有进行赋值
     */
    private static Singleton instance;

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static synchronized Singleton getInstance() {
        //判断instance是否为Null.如果为null，说明还没有创建Singleton类的对象
        //如果没有创建，创建一个并返回，如果有直接返回
        if(instance == null) {
            instance = new Singleton(); 
        }
        return instance;
    }
}

该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。

从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

2.5、懒汉式（双重检查锁）

讨论一下懒汉模式中加锁（synchronized）的问题，对于 getInstance() 方法来说，绝大部分的操作都是读操作，读操作是线程安全的，所以我们没必让每个线程必须持有锁才能调用该方法，我们需要调整加锁的时机。由此也产生了一种新的实现模式：双重检查锁模式

package com.jie.creator.singleton.demo05;

/**
 * @description:懒汉式:双重检查方式
 * @author: jie
 * @time: 2022/1/29 16:56
 */
public class Singleton {

    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}
    /**
     * @description:在成员位置创建该类的对象,当前只是声明了一个该类型的变量，并没有进行赋值
     */
    private static Singleton instance;

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
		//第一次判断，如果instance的值不为null，不需要抢占锁，直接返回对象
        if(instance == null) {
            synchronized (Singleton.class) {
                //第二次判断，抢到锁之后再次判断是否为null
                if(instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

添加 volatile 关键字之后的双重检查锁模式能够保证在多线程的情况下线程安全也不会有性能问题。

2.6、懒汉式（静态内部类）

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

package com.jie.creator.singleton.demo06;
/**
 * @description:懒汉式:静态内部类
 * @author: jie
 * @time: 2022/1/29 17:47
 */
public class Singleton {

    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}
    /**
     * @description:定义一个静态内部类
     */
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

第一次加载Singleton类时不会去初始化INSTANCE，只有第一次调用getInstance，虚拟机加载SingletonHolder并初始化INSTANCE，这样不仅能确保线程安全，也能保证 Singleton 类的唯一性。

静态内部类单例模式是一种优秀的单例模式，是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下，保证了多线程下的安全，并且没有任何性能影响和空间的浪费。

2.7 、枚举方式

枚举类实现单例模式是极力推荐的单例实现模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分的利用了枚举的这个特性来实现单例模式，枚举的写法非常简单，而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

package com.jie.creator.singleton.demo07;

/**
 * @description:枚举方式
 * @author: jie
 * @time: 2022/1/29 18:21
 */
public enum Singleton {
    INSTANCE;
}

package com.jie.creator.singleton.demo07;
/**
 * @description:测试类
 * @author: jie
 * @time: 2022/1/29 18:24
 */
public class Test {
    public static void main(String[] args) {
        //1、创建Singleton对象
        Singleton singleton = Singleton.INSTANCE;
        Singleton singleton1 = Singleton.INSTANCE;

        //2、判断内存地址是否相同
        System.out.println(singleton==singleton1);
    }
}

3、存在的问题

3.1 问题演示

破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式（因为枚举方式是基于JVM底层的一个实现，它已经把所有的问题解决掉了）除外。有两种方式，分别是序列化和反射。

3.1.1 序列化反序列化

package com.jie.creator.singleton.demo08;

import java.io.Serializable;

/**
 * @description:懒汉式:静态内部类
 * @author: jie
 * @time: 2022/1/29 17:47
 */
public class Singleton implements Serializable {

    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}
    /**
     * @description:定义一个静态内部类
     */
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

package com.jie.creator.singleton.demo08;


import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * @description:测试使用序列化反序列化破坏单例模式
 * 桌面路径 C:\Users\jie\Desktop
 * @author: jie
 * @time: 2022/1/29 18:51
 */
public class Test {
    public static void main(String[] args) throws Exception{
        //调用写入操作
        writeObject2File();
        //调用读取操作
        Singleton s1 = readObjectFromFile();
        Singleton s2 = readObjectFromFile();
        //判断地址是否相同
        System.out.println(s1==s2);
    }
    /**
     * @description:从文件读取数据（对象）
     * @author: jie
     * @time: 2022/1/29 19:04
     */
    public static Singleton readObjectFromFile()throws Exception{
        //1、创建对象输入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\jie\\Desktop\\a.txt"));
        //2、读取对象
        Singleton singleton = (Singleton) ois.readObject();
        //释放资源
        ois.close();
        return singleton;
    }

    /**
     * @description:向文件中写数据（对象）
     * @author: jie
     * @time: 2022/1/29 18:55
     */
    public static void writeObject2File() throws Exception{
        //1、获取Singleton对象
        Singleton instance = Singleton.getInstance();
        //2、创建对象(输出流对象)
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\jie\\Desktop\\a.txt"));
        //3、写对象
        oos.writeObject(instance);
        //4、释放资源
        oos.close();
    }
}

测试结果：

上面代码运行结果是false，表明序列化和反序列化已经破坏了单例设计模式。

3.1.2 反射

package com.jie.creator.singleton.demo09;

import java.io.Serializable;

/**
 * @description:懒汉式:静态内部类
 * @author: jie
 * @time: 2022/1/29 17:47
 */
public class Singleton implements Serializable {

    /**
     * @description:私有构造方法，避免外部创建对象
     */
    private Singleton() {}
    /**
     * @description:定义一个静态内部类
     */
    private static class SingletonHolder {
        //在内部类中声明并初始化外部类的对象
        private static final Singleton INSTANCE = new Singleton();
    }

    /**
     * @description:对外提供静态方法获取该对象
     */
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

package com.jie.creator.singleton.demo09;

import java.lang.reflect.Constructor;

/**
 * @description:测试使用反射破坏单例模式
 * @author: jie 
 * @time: 2022/1/29 19:26
 */
public class Test {
    public static void main(String[] args) throws Exception{
        //1、获取Singleton的字节码对象
        Class clazz = Singleton.class;
        //2、获取无参构造方法对象
        Constructor cons = clazz.getDeclaredConstructor();
        //3、取消访问检查
        cons.setAccessible(true);
        //4、创建Singleton对象
        Singleton s1 = (Singleton) cons.newInstance();
        Singleton s2 = (Singleton) cons.newInstance();
        //判断，如果返回的是true，说明并没有破坏单例模式，如果是false,说明破坏了单例模式
        System.out.println(s1==s2);
    }
}

测试结果：

上面代码运行结果是false，表明反射已经破坏了单例设计模式

3.2 问题的解决

3.2.1 序列化、反序列方式破坏单例模式的解决方法

在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

看一下测试类的测试结果： ?

上面readResolve()方法注释说了，当进行反序列化时，会自动调用该方法，它就会自动调用吗？我们现在要去研究一下它底层的一个原理，看一下它底层是不是这样。

看哪一个方法的底层代码呢？其实就是readObject()方法。

因为它是用来读取对象的，那它读取的时候是new出来的？还是调用Singleton里面的readResolve()方法呢？马上来看看。

源码解析：

ObjectInputStream类

按住CTRL点进去。 ?

ok,这里呢是简单的去看了一下源码。

3.2.2 反射方式破解单例的解决方法

测试结果： ?

这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此操作。

4、JDK源码解析-Runtime类

在我们JDK源码里面，哪些类用到了单例设计模式呢？在这里就给大家介绍一个类——Runtime

Runtime类就是使用的单例设计模式。

通过源代码查看使用的是哪种单例模式?

从上面源代码中可以看出Runtime类使用的是饿汉式（静态变量）方式来实现单例模式的。

那我们可以写个测试类用一下Runtime类中的方法,大家可以复制运行一下。

package com.jie.creator.singleton.demo10;

import java.io.InputStream;

/**
 * @description:使用Runtime类中的方法
 * @author: jie 
 * @time: 2022/1/29 21:48
 */
public class Test {
    public static void main(String[] args) throws Exception{
        //获取Runtime类对象
        Runtime runtime = Runtime.getRuntime();
        //调用Runtime对象的方法 exec,参数要的是一个命令
        Process exec = runtime.exec("ipconfig");
        //调用process对象的获取输入流的方法
        InputStream is = exec.getInputStream();
        //定义一个字节数组
        byte[] arr = new byte[1024*1024*100];
        //读取数据 返回读到的字节的个数
        int len = is.read(arr);
        //将字节数组转换为字符串输出到控制台
        System.out.println(new String(arr,0,len,"GBK"));
    }
}

5.总结

单例中两种饿汉式(静态变量,静态代码)可用，但是存在性能问题

单例中两种懒汉式(线程不安全，线程安全)不推荐，存在线程安全问题，线程安全方法的方式解决了线程的问题，但是性能极差

最后三种单例模式（双重检查锁，静态内部类，枚举方式）值得推荐

注意事项

系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能

当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用 new

应用

jdk源码中Runtime类

tomcat中ApplicationContext类

session 工厂