单例模式学习笔记

1 单例模式(Singleton Pattern)介绍

　1.1 单例模式介绍

　　定义：确保某一类只有一个实例，而且自行实例化并向整个系统提供这个实例。

　　实现：通过使用private的构造函数确保了在一个应用中只产生一个实例，并且是自行实例化。

　　示例代码：

　　　　例1-1

1 public class Singleton01 {
2     //2、创建一个对象，在类加载的时候初始
3     private static final Singleton01 singleton01 = new Singleton01();
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton01(){
6
7     }
8     //3、对外提供一个静态方法，以获取实例对象
9     public static Singleton01 getSingleton(){
10         return singleton01;
11     }
12     //类中的其他方法
13     public void doSomething(){
14     }
15 }

　　1.2 单例模式的应用

　　1.2.1 优点

单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁创建、销毁时，而且创建或销毁时性能无法优化，单例模式的优势就非常明显。

单例模式可以避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

　　1.2.2 缺点

单例模式一般没有接口，扩展困难。

对测试不利，如果单例模式没有完成，是不能进行测试的。

　　1.2.3 使用场景

要求生成唯一序列号的环境。

在整个项目中需要一个共享访问点或共享数据，例如一个web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保存计数器的值，并确保是线程安全的。

创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源。

需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（当然，也可以直接声明为static的方式）。

windows的任务管理器，工厂模式中的工厂....

2 单例模式的实现方式

　　2.1 饿汉式（线程安全，调用效率高[因为不用加锁]，但是不能延时加载），如例1-1 。

　　2.2 懒汉式

　　当使用懒加载时（如例2-2-1），在高并发环境下，存在线程安全问题（图2-2-1），可能出现同时创建多个对象，需要对线程进行加锁（例2-2-2），此称为懒汉式，资源利用效率高，实现了懒加载，但是并发调用效率低，由于每次都要加载所有浪费系统资源。

　　例2-2-1：

1 public class Singleton02 {
2     //2、声明一个私有的静态变量
3     private static Singleton02 singleton02 ;
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton02(){
6     }
7     //3、对外提供一个静态方法，以获取实例对象
8     public static  Singleton02 getSingleton(){
9         //判断singleton02是否为空，为空赋值
10         if (singleton02 == null){
11             singleton02 = new Singleton02();
12         }
13         return singleton02;
14     }
15 }

　　图2-2-1

　　


　　例2-2-2：

1 public class Singleton02 {
2     //2、声明一个私有的静态变量
3     private static Singleton02 singleton02 ;
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton02(){
6     }
7     //3、对外提供一个静态方法，以获取实例对象
8     public static synchronized Singleton02 getSingleton(){
9         //判断singleton02是否为空，为空赋值
10         if (singleton02 == null){
11             singleton02 = new Singleton02();
12         }
13         return singleton02;
14     }
15 }

　　2.3 双重检测锁(由于编译器优化原因，和jvm底层模型问题，偶尔会出现问题，不建议使用)

　　例2-3-1

1 public class Singleton03 {
2     //2、声明一个私有的静态成员变量
3     private static Singleton03 singleton03;
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton03(){
6     }
7     //3、对外提供一个静态方法，以获取实例对象
8     public static Singleton03 getSingleton(){
9         //判断singleton03是否需要加锁
10         if (singleton03 == null){
11             synchronized (Singleton03.class){
12                 if (singleton03 == null){
13                     singleton03 = new Singleton03();
14                 }
15             }
16         }
17         return singleton03;
18     }

　　图2-3-1

　　　


　　2.4 静态内部类（常用）

　　　　外部类没有static，所以静态内部类不会再外部类加载的时候被初始化，所以实现了懒加载

　　　　线程安全，因为实例对象是在静态内部类加载的时候创建，所以天然是单例的。

　　例2-4-1

1 public class Singleton04 {
2
3     //1、私有化构造方法，现在以new的方式创建多个对象
4     private Singleton04(){
5     }
6     //2、创建一个静态内部类
7     private static class SingletonInstance{
8         //静态内部类加载的时候生成单例对象
9         public static Singleton04 singleton04 = new Singleton04();
10     }
11     //3、对外提供一个静态方法，以获取实例对象
12     public static Singleton04 getSingleton(){
13         //当调用该方法是，静态内部类才会被加载，对象才会new出来
14         return SingletonInstance.singleton04;
15     }
16 }

　　2.5 枚举（线程安全，天然就单例的，能避免反射和反序列化带来的问题，但是不能懒加载）

　　例2-5-1

1 public enum Singleton05 {
2     SINGLETON_05;
3     public void doSomething(){
4     }
5 }

1 public class Client {
2     public static void main(String[] args) {
3         Singleton05 singleton05_01 = Singleton05.SINGLETON_05;
4         Singleton05 singleton05_02 = Singleton05.SINGLETON_05;
5         Singleton05 singleton05_03 = Singleton05.SINGLETON_05;
6         System.out.println(singleton05_01);//SINGLETON_05
7         System.out.println(singleton05_02);//SINGLETON_05
8         System.out.println(singleton05_03);//SINGLETON_05
9         singleton05_01.doSomething();
10     }
11 }

3 防止反射破解单例

　　3.1反射破解单例示例：

　　例3-1-1

1 //破解类
2 public class Client {
3     public static void main(String[] args) throws Exception {
4
5         Singleton01 singleton1 = Singleton01.getSingleton();
6         Singleton01 singleton2 = Singleton01.getSingleton();
7         System.out.println(singleton1 == singleton2); //true
8
9         //暴力反射破解单例
10         Class<Singleton01> clazz = (Class<Singleton01>) Class.forName("com.pri.singleton_a.Singleton01");
11         Constructor<Singleton01> constructor = clazz.getDeclaredConstructor(null);
12         constructor.setAccessible(true);
13         Singleton01 singleton3 = constructor.newInstance(null);
14
15         System.out.println(singleton1 == singleton3); //false
16     }
17 }
18
19 //单例类
20 public class Singleton01 {
21     //2、创建一个对象，在类加载的时候初始
22     private static final Singleton01 singleton01 = new Singleton01();
23     //1、私有化构造方法，现在以new的方式创建多个对象
24     private Singleton01(){
25
26     }
27     //3、对外提供一个静态方法，以获取实例对象
28     public static Singleton01 getSingleton(){
29         return singleton01;
30     }
31     //类中的其他方法
32     public void doSomething(){
33     }
34 }

　　3.2 防止反射破解单例

　　在单例空参构造中添加判断，如

　　例3-2-1：

1 public class Singleton01 {
2     //2、创建一个对象，在类加载的时候初始
3     private static final Singleton01 singleton01 = new Singleton01();
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton01(){
6         if (singleton01 != null){
7             throw new RuntimeException("已有实例，不能再调用此方法实例化");
8         }
9     }
10     //3、对外提供一个静态方法，以获取实例对象
11     public static Singleton01 getSingleton(){
12         return singleton01;
13     }
14     //类中的其他方法
15     public void doSomething(){
16     }
17 }
18
19 //运行结果 ：Caused by: java.lang.RuntimeException: 已有实例，不能再调用此方法实例化

4 防止反序列化破解单例

　　4.1 反序列化破解单例

　　例4-1-1

1 //破解类
2 public class Client {
3     public static void main(String[] args) throws Exception {
4
5         Singleton01 singleton1 = Singleton01.getSingleton();
6         Singleton01 singleton2 = Singleton01.getSingleton();
7         System.out.println(singleton1 == singleton2); //true
8
9         /*//1、将对象序列化到文件
10         FileOutputStream out = new FileOutputStream("singleton.txt");
11         ObjectOutputStream oos = new ObjectOutputStream(out);
12         oos.writeObject(singleton1);
13
14         oos.close();
15         out.close();*/
16
17         //2、从文件中读取对象（反序列化）
18         FileInputStream input = new FileInputStream(new File("singleton.txt"));
19
20         ObjectInputStream ois = new ObjectInputStream(input);
21         Singleton01 singleton3 = (Singleton01) ois.readObject();
22
23         System.out.println(singleton1 == singleton3); //false
24     }
25 }
26
27 //单例类
28 public class Singleton01 implements Serializable {
29     //2、创建一个对象，在类加载的时候初始
30     private static final Singleton01 singleton01 = new Singleton01();
31     //1、私有化构造方法，现在以new的方式创建多个对象
32     private Singleton01(){
33         if (singleton01 != null){
34             throw new RuntimeException("已有实例，不能再调用此方法实例化");
35         }
36     }
37     //3、对外提供一个静态方法，以获取实例对象
38     public static Singleton01 getSingleton(){
39         return singleton01;
40     }
41     //类中的其他方法
42     public void doSomething(){
43     }
44 }

4.2 防止反序列化破解单例

　　在单例类中添加一个readResolve（）方法，如例4-2-1.

　　例4-2-1

1 public class Singleton01 implements Serializable {
2     //2、创建一个对象，在类加载的时候初始
3     private static final Singleton01 singleton01 = new Singleton01();
4     //1、私有化构造方法，现在以new的方式创建多个对象
5     private Singleton01(){
6         if (singleton01 != null){
7             throw new RuntimeException("已有实例，不能再调用此方法实例化");
8         }
9     }
10     //3、对外提供一个静态方法，以获取实例对象
11     public static Singleton01 getSingleton(){
12         return singleton01;
13     }
14     //类中的其他方法
15     public void doSomething(){
16     }
17
18     //反序列化时，直接return singleton01,不生成对象
19     private Object readResolve() throws ObjectStreamException{
20         return singleton01;
21     }
22 }