1 、单例模式的结构

2 、单例模式的实现

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

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

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

2.4、懒汉式(线程安全)

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

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

2.7 、枚举方式

3、存在的问题

3.1 问题演示

3.1.1 序列化反序列化

3.1.2 反射

3.2 问题的解决

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

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

4、JDK源码解析-Runtime类

5.总结

6、代码仓库地址

概念：

单例模式（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) {//第二次判断，抢到锁之后再次判断是否为nullif(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 工厂

6、代码仓库地址

创建者模式案例代码: 用来装创建者模式的案例代码

单例设计模式（Singleton）附带案例代码仓库相关推荐

单例设计模式singleton
简单引入单例设计模式作为最简单,最常用的设计模式.一般是这两中写法,这两种写法教科书所谓的标准写法,但是实际上存在不少问题.后面介绍标准写法,以规避这些问题. 1.懒汉式: /*** 问题在于,当多 ...
Java设计模式—单例设计模式(Singleton Pattern)完全解析
转载请注明出处:http://blog.csdn.net/dmk877/article/details/50311791 相信大家都知道设计模式,听的最多的也应该是单例设计模式,这种模式也是在开发中用 ...
单例设计模式-静态内部类
静态内部类静态内部类应用实例代码演示 package com.atguigu.principle.singleton.type07;/** * @author victor * @site htt ...
面试官最喜欢考的设计模式---单例设计模式
一.讲在前面的废话笔者曾经多次面试都遇到了这个问题,请你说一下软件的设计模式,一般我们都会把23种模式例举几个出来,如果没有说错,你一定会列举单例设计模式,这样的话你就中了面试官的圈套了.接下来的一 ...
Java查漏补缺（08）关键字:static、单例设计模式、理解main方法、类的成员之四:代码块、final关键字、抽象类、接口、内部类、枚举类、注解、包装类
Java查漏补缺(08)关键字:static.单例设计模式.理解main方法.类的成员之四:代码块.final关键字.抽象类.接口.内部类.枚举类.注解.包装类本章专题与脉络 1. 关键字:stat ...
单例设计模式八种方式——5) 懒汉式(线程安全，同步代码块) 6) 双重检查 7) 静态内部类 8) 枚举
懒汉式(线程安全,同步代码块)应用实例优缺点说明: 1) 这种方式,本意是想对第四种实现方式的改进,因为前面同步方法效率太低, 改为同步产生实例化的的代码块 2) 但是这种同步并不能起到线程同步的作 ...
单例设计模式介绍||单例设计模式八种方式——1) 饿汉式(静态常量) 2) 饿汉式（静态代码块） 3) 懒汉式(线程不安全) 4) 懒汉式(线程安全，同步方法)
单例模式单例设计模式介绍所谓类的单例设计模式,就是采取一定的方法保证在整个的软件系统中,对某个类只能存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法). 比如Hibernate的 ...
设计模式的征途—1.单例（Singleton）模式
单例模式属于创建型模式的一种,创建型模式是一类最常用的设计模式,在软件开发中应用非常广泛.创建型模式将对象的创建和使用分离,在使用对象时无需关心对象的创建细节,从而降低系统的耦合度,让设计方案更易于修 ...
Java笔记017-类变量和类方法、理解main方法语法、代码块、单例设计模式、final关键字
目录面向对象编程(高级部分) 类变量和类方法类变量-提出问题传统方法解决问题分析: 类变量快速入门类变量内存布局什么是类变量如何定义类变量定义语法: 如何访问类变量定义语法: 类变量使 ...

单例设计模式（Singleton）附带案例代码仓库

1 、单例模式的结构

2 、单例模式的实现

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

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

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

2.4、懒汉式(线程安全)

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

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

2.7 、枚举方式

3、存在的问题

3.1 问题演示

3.1.1 序列化反序列化

3.1.2 反射

3.2 问题的解决

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

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

4、JDK源码解析-Runtime类

5.总结

6、代码仓库地址

单例设计模式（Singleton）附带案例代码仓库相关推荐

最新文章

热门文章

单例设计模式（Singleton）附带案例代码仓库

1 、单例模式的结构

2 、单例模式的实现

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

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

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

2.4、懒汉式(线程安全)

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

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

2.7 、枚举方式

3、 存在的问题

3.1 问题演示

3.1.1 序列化反序列化

3.1.2 反射

3.2 问题的解决

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

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

4、JDK源码解析-Runtime类

5.总结

6、代码仓库地址

单例设计模式（Singleton）附带案例代码仓库相关推荐

最新文章

热门文章

3、存在的问题