2023.5.8 单例设计模式

单例设计模式

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

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式的结构

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

单例类。只能创建一个实例的类
访问类。使用单例类

单例模式的实现

单例设计模式分类两种：

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

饿汉式-方式1（静态变量方式）

 1 package com.xing.singleton.demo1;
 2 
 3 /**
 4  * @ClassName: Singleton
 5  * @Description: 饿汉式： 静态成员变量
 6  */
 7 public class Singleton {
 8 
 9     //1，私有构造方法
10     private Singleton() {}
11 
12     //2，在本类中创建本类对象
13     private static Singleton instance = new Singleton();
14 
15     //3，提供一个公共的访问方式，让外界获取该对象
16     public static Singleton getInstance() {
17         return instance;
18     }
19 }

Test

 1 package com.xing.singleton.demo1;
 2 
 3 public class Test {
 4     public static void main(String[] args) {
 5         //创建Singletion类的对象
 6         Singleton instance = Singleton.getInstance();
 7 
 8         Singleton instance1 = Singleton.getInstance();
 9 
10         //判断获取到的两个是否是同一个对象
11         System.out.println(instance == instance1);//true
12     }
13 }

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

饿汉式-方式2（静态代码块方式）

 1 package com.xing.singleton.demo2;
 2 /**
 3  * @ClassName: Singleton
 4  * @Description: 饿汉式 ： 静态代码块
 5  */
 6 public class Singleton {
 7 
 8     //私有构造方法
 9     private Singleton() {}
10 
11     //声明Singleton类型的变量
12     private static Singleton instance; //null
13 
14     //在静态代码块中进行赋值
15     static {
16         instance = new Singleton();
17     }
18 
19     //对外提供获取该类对象的方法
20     public static Singleton getInstance() {
21         return instance;
22     }
23 }

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

懒汉式-方式1（线程不安全）

 1 /**
 2  * 懒汉式
 3  *  线程不安全
 4  */
 5 public class Singleton {
 6     //私有构造方法
 7     private Singleton() {}
 8 
 9     //在成员位置创建该类的对象
10     private static Singleton instance;
11 
12     //对外提供静态方法获取该对象
13     public static Singleton getInstance() {
14 
15         if(instance == null) {
16             instance = new Singleton();
17         }
18         return instance;
19     }
20 }

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

懒汉式-方式2（线程安全）

 1 package com.xing.singleton.demo3;
 2 
 3 /**
 4  * @ClassName: Singleton
 5  * @Description: 懒汉式
 6  */
 7 public class Singleton {
 8 
 9     //私有构造方法
10     private Singleton() {}
11 
12     //声明Singleton类型的变量instance
13     private static Singleton instance; //只是声明一个该类型的变量，并没有进行赋值
14 
15     //对外提供访问方式
16     public static synchronized Singleton getInstance() {
17         //判断instance是否为null，如果为null，说明还没有创建Singleton类的对象
18         //如果没有,那么创建一个并返回，如果有，直接返回
19         if(instance == null) {
20             //线程1进入判断后发生等待，线程2获取到cpu的执行权，也会进入到该判断里面
21             instance = new Singleton();
22         }
23         return instance;
24     }
25 }

说明：该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

懒汉式-方式3（双重检查锁）

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

 1 /**
 2  * 双重检查方式
 3  */
 4 public class Singleton { 
 5 
 6     //私有构造方法
 7     private Singleton() {}
 8 
 9     private static Singleton instance;
10 
11    //对外提供静态方法获取该对象
12     public static Singleton getInstance() {
13         //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实例
14         if(instance == null) {
15             synchronized (Singleton.class) {
16                 //抢到锁之后再次判断是否为null
17                 if(instance == null) {
18                     instance = new Singleton();
19                 }
20             }
21         }
22         return instance;
23     }
24 }

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

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

 1 /**
 2  * 双重检查方式
 3  */
 4 public class Singleton {
 5 
 6     //私有构造方法
 7     private Singleton() {}
 8 
 9     //volatile保证指令有序
10     private static volatile Singleton instance;
11 
12    //对外提供静态方法获取该对象
13     public static Singleton getInstance() {
14         //第一次判断，如果instance不为null，不进入抢锁阶段，直接返回实际
15         if(instance == null) {
16             synchronized (Singleton.class) {
17                 //抢到锁之后再次判断是否为空
18                 if(instance == null) { 
19                     instance = new Singleton();
20                 }
21             }
22         }
23         return instance;
24     }
25 }

　　　　小结： 添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

懒汉式-方式4（静态内部类方式）

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

 1 package com.xing.singleton.demo5;
 2 
 3 /**
 4   * @ClassName: Singleton
 5   * @Description: 静态内部类方式
 6   */
 7 public class Singleton {
 8 
 9     //私有构造方法
10     private Singleton() {}
11 
12     //定义一个静态内部类
13     private static class SingletonHolder {
14         //在内部类中声明并初始化外部类的对象
15         private static final Singleton INSTANCE = new Singleton();
16     }
17 
18     //提供公共的访问方式
19     public static Singleton getInstance() {
20         return SingletonHolder.INSTANCE;
21     }
22 }

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

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

饿汉式-枚举方式

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

 1 /**
 2  * 枚举方式
 3  */
 4 public enum Singleton {
 5     INSTANCE;
 6 }
 7 Test
 8 
 9 package com.xing.singleton.demo6;
10 
11 public class Test {
12     public static void main(String[] args) {
13         Singleton instance = Singleton.INSTANCE;
14         Singleton instance1 = Singleton.INSTANCE;
15 
16         System.out.println(instance == instance1);//true
17     }
18 }

存在的问题

问题演示

破坏单例模式：以静态代码块为例其它也一样

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是序列化和反射。

序列化反序列化

Singleton类：

 1 //需要序列化
 2 public class Singleton implements Serializable {
 3 
 4     //私有构造方法
 5     private Singleton() {}
 6 
 7     private static class SingletonHolder {
 8         private static final Singleton INSTANCE = new Singleton();
 9     }
10 
11     //对外提供静态方法获取该对象
12     public static Singleton getInstance() {
13         return SingletonHolder.INSTANCE;
14     }
15 }

Test类：

 1 package com.xing.singleton.demo7;
 2 
 3 
 4 import java.io.FileInputStream;
 5 import java.io.FileOutputStream;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 
 9 /**
10  * @Description: 测试使用序列化破坏单例模式
11  * 桌面路径： C:\Users\LXingTou\Desktop
12  */
13 public class Test {
14     public static void main(String[] args) throws Exception {
15         writeObject2File();//对象需要序列化
16         readObjectFromFile();//com.xing.singleton.demo7.Singleton@7530d0a
17         readObjectFromFile();//com.xing.singleton.demo7.Singleton@27bc2616
18     }
19 
20     //向文件中写数据（对象）
21     public static void writeObject2File() throws Exception {
22         //1,获取Singleton对象
23         Singleton instance = Singleton.getInstance();
24         //2,创建对象输出流对象
25         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\LXingTou\\Desktop\\a.txt"));
26         //3,写对象
27         oos.writeObject(instance);
28         //4,释放资源
29         oos.close();
30     }
31 
32     //从文件读取数据（对象）
33     public static void readObjectFromFile() throws Exception {
34         //1,创建对象输入流对象
35         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\LXingTou\\Desktop\\a.txt"));
36         //2,读取对象
37         Singleton instance = (Singleton) ois.readObject();
38 
39         System.out.println(instance);
40 
41         //释放资源
42         ois.close();
43     }
44 
45 
46 }

上面代码读取对象不同，表明序列化和反序列化已经破坏了单例设计模式。

反射

Singleton类：

 1 package com.xing.singleton.demo8;
 2 import java.io.Serializable;
 3 
 4 /**
 5  * @ClassName: Singleton
 6  * @Description: 静态内部类方式
 7  */
 8 public class Singleton{
 9 
10     //私有构造方法
11     private Singleton() {}
12 
13     private static class SingletonHolder {
14         private static final Singleton INSTANCE = new Singleton();
15     }
16 
17     //对外提供静态方法获取该对象
18     public static Singleton getInstance() {
19         return SingletonHolder.INSTANCE;
20     }
21 }

Test类：

 1  package com.xing.singleton.demo8;
 2   
 3   import java.lang.reflect.Constructor;
 4   
 5   /**
 6    * @Description: 测试使用反射破坏单例模式
 7    */
 8   public class Test {
 9       public static void main(String[] args) throws Exception {
10           //1,获取Singleton的字节码对象
11           Class<Singleton> clazz = Singleton.class;
12           //2,获取无参构造方法对象
13           Constructor<Singleton> cons = clazz.getDeclaredConstructor();
14           //3,取消访问检查
15           cons.setAccessible(true);
16           //4,创建Singleton对象
17           Singleton s1 = cons.newInstance();
18           Singleton s2 = cons.newInstance();
19           System.out.println(s1 == s2); //如果返回的是true，说明并没有破坏单例模式，如果是false，说明破坏了单例模式
20       }
21 }

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

注意：枚举方式不会出现这两个问题。

问题的解决

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

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

Singleton类：

 1 public class Singleton implements Serializable {
 2 
 3     //私有构造方法
 4     private Singleton() {}
 5 
 6     private static class SingletonHolder {
 7         private static final Singleton INSTANCE = new Singleton();
 8     }
 9 
10     //对外提供静态方法获取该对象
11     public static Singleton getInstance() {
12         return SingletonHolder.INSTANCE;
13     }
14     
15     /**
16      * 下面是为了解决序列化反序列化破解单例模式
17      */
18     private Object readResolve() {
19         return SingletonHolder.INSTANCE;
20     }
21 }

源码解析：

ObjectInputStream类

 1 public final Object readObject() throws IOException, ClassNotFoundException{
 2     ...
 3     // if nested read, passHandle contains handle of enclosing object
 4     int outerHandle = passHandle;
 5     try {
 6         Object obj = readObject0(false);//重点查看readObject0方法
 7     .....
 8 }
 9     
10 private Object readObject0(boolean unshared) throws IOException {
11     ...
12     try {
13         switch (tc) {
14             ...
15             case TC_OBJECT:
16                 return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法
17             ...
18         }
19     } finally {
20         depth--;
21         bin.setBlockDataMode(oldMode);
22     }    
23 }
24     
25 private Object readOrdinaryObject(boolean unshared) throws IOException {
26     ...
27     //isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，
28     obj = desc.isInstantiable() ? desc.newInstance() : null; 
29     ...
30     // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
31     if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
32         // 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量
33         // 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。
34         Object rep = desc.invokeReadResolve(obj);
35         ...
36     }
37     return obj;
38 }

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

 1 package com.xing.singleton.demo8;
 2 
 3 
 4 /**
 5  * @ClassName: Singleton
 6  * @Description: 静态内部类方式
 7  */
 8 public class Singleton {
 9 
10     private static boolean flag = false;
11 
12     //私有构造方法
13     private Singleton() {
14         // 防止多线程
15         synchronized (Singleton.class) {
16             //解决反射破坏单例模式
17             //判断flag的值是否是true，如果是true，说明非第一次访问构造方法，直接抛一个异常，如果是false的话，说明第一次访问
18             if (flag) {
19                 throw new RuntimeException("不能创建多个对象");
20             }
21             //将flag的值设置为true
22             flag = true;
23         }
24     }
25 
26     //定义一个静态内部类
27     private static class SingletonHolder {
28         //在内部类中声明并初始化外部类的对象
29         private static final Singleton INSTANCE = new Singleton();
30     }
31 
32   //提供公共的访问方式
33     public static Singleton getInstance() {
34       return SingletonHolder.INSTANCE;
35     }
36 }

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

JDK源码解析-Runtime类

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

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

 1 public class Runtime {
 2     private static Runtime currentRuntime = new Runtime();
 3 
 4     /**
 5      * Returns the runtime object associated with the current Java application.
 6      * Most of the methods of class <code>Runtime</code> are instance
 7      * methods and must be invoked with respect to the current runtime object.
 8      *
 9      * @return  the <code>Runtime</code> object associated with the current
10      *          Java application.
11      */
12     public static Runtime getRuntime() {
13         return currentRuntime;
14     }
15 
16     /** Don't let anyone else instantiate this class */
17     private Runtime() {}
18     ...
19 }

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

使用Runtime类中的方法

 1 package com.xing.singleton.demo9;
 2 
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 
 6 public class RuntimeDemo {
 7     public static void main(String[] args) throws IOException {
 8         //获取Runtime类的对象
 9         Runtime runtime = Runtime.getRuntime();
10 
11         //调用runtime的方法exec, 参数要的是一个命令
12         Process process = runtime.exec("ipconfig");
13         //调用process对象的获取输入流的方法
14         InputStream is = process.getInputStream();
15         byte[] arr = new byte[1024 * 1024 * 100];
16         //读取数据
17         int len = is.read(arr);//返回读到的字节的个数
18         //将字节数组转换为字符串输出到控制台
19         System.out.println(new String(arr,0,len,"GBK"));
20     }
21 }

posted @ 2023-05-08 17:36 暴躁C语言阅读(38) 评论(0) 收藏举报

刷新页面返回顶部

暴躁C语言

2023.5.8 单例设计模式

单例设计模式

单例模式的结构

单例模式的实现

存在的问题

问题演示

问题的解决

JDK源码解析-Runtime类

公告