【设计模式】单例模式

1. 概述

所谓单例模式，就是采取一些方法保证在整个的软件系统中，某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。

比如 Hibernate 的 SessionFactory，它充当数据存储源的代理，并负责创建 Session 对象。SessionFactory并不是轻量级的，一般情况下，一个项目通常只需要一个 SessionFactory 就够了，这时就会用到单例模式。

2. 常见的几种单例模式写法

1) 饿汉式 —— 静态常量，线程安全

创建单例步骤

• 1. 构造器私有化（防止外部new对象）；
• 2. 类的内部创建对象；
• 3. 向外暴露一个静态公共方法；

代码实现

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {
	
	/**
	 * 2. 本类内部创建对象实例
	 */
	private final static Singleton instance = new Singleton();

	/**
	 * 1. 构造器私有化，防止外部new
	 */
	private Singleton () {
	}

	/**
	 * 3. 向外暴露一个静态公共方法，用于获取单例对象
	 */
	public static Singleton getInstance() {
		return instance;
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

优缺点说明
（1）优点：这种方法比较简单，就是在类装载的时候就完成实例化，避免了线程同步问题；
（2）缺点：在类装载的时候就完成实例化，没有达到 lazy loading 的效果。如果从始至终从未使用过这个单例，则会造成内存的浪费；
（3）这种方式基于classloader机制，避免了多线程的同步问题。不过，instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方法（或者其他的静态方法）导致了类装载，这时候初始化instance就没有达到 lazy loading 的效果；
（4）结论：这种单例模式可用，可能造成内存的浪费。

2) 饿汉式 —— 静态代码块，线程安全

创建单例对象步骤

1）构造器私有化，防止外部new；

2）在静态代码块执行时，创建单例对象；

3）向外暴露一个静态公共方法，用于获取单例对象。

代码实现

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 2. 在静态代码块执行时，创建单例对象
     */
    static {
        instance = new Singleton();
    }

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

	/**
     * 3. 向外暴露一个静态公共方法，用于获取单例对象
     */
    public static Singleton getInstance() {
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

优缺点说明

1）这种方式和上面的方式其实是类似的，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候就执行静态代码块中的代码，初始化类的实例。优点和缺点跟上面是一样的。

2）结论：这种单例模式可用，但是可能造成内存浪费。

3) 懒汉式 —— 非同步方法，线程不安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 提供了一个静态的公有方法，当使用到改方法时，才去创建 instance
     * 即懒汉式
     */
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

优缺点说明

1）起到了 Lazy Loading 的效果，但是只能在单线程下使用；

2）如果在多线程下，一个线程进入了 if (instance == null) 判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时就会产生多个实例。所以在多线程环境下不可使用这种方式；

3）结论：在实际开发中，不要使用这种方式。

4) 懒汉式 —— 同步方法，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 加入了同步代码，解决了线程不完全问题
     */
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

优缺点说明

1）解决了线程不安全问题；

2）效率太低了，每个线程再想获得类的实例的时候，执行了 getInstance() 方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接 return 就行了。对方法进行同步效率太低；

3）结论：在实际开发中，不推荐这种方式；

5) 懒汉式 —— 同步代码块，线程不安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 加入了同步代码，解决了线程不完全问题
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

说明

这种方式是错误的，不能起到单例的作用，在实际开发中不会采用这种方式。

当一个线程执行了 if (instance == null) 就切换到了另外一个线程，这另外一个线程执行了创建单例对象的代码，释放了锁，当再切回前一个线程时，仍然会再进入同步代码块去执行创建单例对象的代码，这样就不是单例对象了，因此该法不可取。

6) 双重检查，线程安全

注意加了 volatile 关键字，防止未初始化完成读取不到instance。

创建单例对象步骤

1）构造器私有化，防止外部new对象；

2）提供了一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
同时保证了性能（推荐使用）；

package cn.edu.pku.singleton;
/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    private static volatile Singleton instance;

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 提供了一个静态的公有方法，加入双重检查代码，解决线程安全问题，同时解决懒加载问题
	 * 同时保证了性能（推荐使用）
     */
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

优缺点说明

1）Double-Check概念是多线程开发中常使用到的，如代码中所示，我们进行了两次 if (instance == null) 检查，这样就可以保证线程安全了；

2）这样，实例化代码只用执行一次，后面再次访问时，判断 if (instance == null)，直接 return 实例化对象，也避免了反复执行同步代码，保证了性能；

3）线程安全；延迟加载；性能较高；

4）结论：在实际开发中，推荐使用这种方式。

7) 静态内部类，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/21
 */
public class Singleton {

    /**
     * 1. 构造器私有化，防止外部new
     */
    private Singleton() {
    }

    /**
     * 2. 静态内部类，在调用 getInstance 方法时才会被加载，并且加载过程是线程安全的
     */
    private  static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

优缺点说明

1）外部类被装载时，它里面的静态内部类不会被装载；

2）调用外部类的 getInstance() 方法时会导致静态内部类的装载，并且只会装载一次，而且在装载时是线程安全的；

3）既能达到懒加载的效果，同时也是线程安全的，推荐使用。

8) 枚举，线程安全

package cn.edu.pku.singleton;

/**
 * @author yumu
 * @date 2022/1/23
 */
public class SingletonTest {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.INSTANCE;
        Singleton instance2 = Singleton.INSTANCE;
        System.out.println(instance1.hashCode());
        System.out.println(instance2.hashCode());
        System.out.println(instance1 == instance2);
    }
}

enum Singleton {
    /**
     * 属性
     */
    INSTANCE;
    public void say() {
        System.out.println("ok~");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

优缺点说明

1）借助JDK1.5中添加的枚举来实现单例模式，不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象；

2）这种方式是 Effective Java 的作者 Josh Bloch 提倡的方式；

3）推荐使用；

3. 单例模式在JDK中的源码分析

在JDK中，java.lang.Runtime 就是经典的单例模式 —— 饿汉式。

4. 单例模式注意事项和细节说明

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

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

3）单例模式使用的场景：需要频繁的进行创建和销毁对象；创建对象时耗时较多或耗费资源过多（即重量级对象），但又经常用到的对象；工具类对象；频繁访问数据库或文件的对象（比如数据源、Session工厂等）。

5. 参考文献