Java单例总结
形而上 Lv4
 2022-04-12      2.5k 字  11 分钟

单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局的访问点。

隐藏其所有的构造方法。

属于创建型模式。

单例模式的适用场景

确保任何情况下都绝对只有一个实例。

ServletContext、ServletConfig、ApplicationContext、DBPool

饿汉式

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
31
32
33
34
35
36
37
38
39
40
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * 优点：执行效率高，性能高，没有任何的锁
 * 缺点：可能会造成内存浪费、反射单例失效、序列化失效
 */
public class HungrySingleton {
    //static 类加载的时候就创建，final：不可被覆盖。
    private static final HungrySingleton hungrysingleton = new HungrySingleton();

    private HungrySingleton(){};

    public static HungrySingleton getInstance(){
        return hungrysingleton;
    }


    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(HungrySingleton.getInstance());
            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<HungrySingleton> declaredConstructor = HungrySingleton.class.getDeclaredConstructor();
                    HungrySingleton hungrySingleton = declaredConstructor.newInstance();
                    System.out.println(hungrySingleton);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

懒汉式

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
31
32
33
34
35
36
37
38
39
40
41
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * 优点：节约了内存
 * 缺点：线程不安全,synchronized性能低， 存在锁等待，反射锁失效、序列化失效
 */
public class LazySimpleSingleton {
    private static LazySimpleSingleton instance;
    private LazySimpleSingleton(){}

    public static synchronized LazySimpleSingleton getInstance(){
        if(instance == null){
            instance = new LazySimpleSingleton();
        }
        return instance;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(LazySimpleSingleton.getInstance());
            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<LazySimpleSingleton> declaredConstructor = LazySimpleSingleton.class.getDeclaredConstructor();
                    LazySimpleSingleton lazySimpleSingleton = declaredConstructor.newInstance();
                    System.out.println(lazySimpleSingleton);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

双重校验懒汉式

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * 双重检查：1、检查是否要阻塞；2、检查是否创建实例。
 * 优点：安全且在多线程情况下能保持高性能,
 * 第一个if判断避免了其他无用线程竞争锁来造成性能浪费，
 * 第二个if判断能拦截除第一个获得对象锁线程以外的线程。
 * 缺点：但是可读性不高，代码不够优雅，反射失效
 */
public class LazyDoubleCheckSingleton {
    //volatile:解决了指令重排序问题（指令执行顺序不一定按代码来执行）。
    private volatile static LazyDoubleCheckSingleton instance;
    //私有化防实例化
    private LazyDoubleCheckSingleton(){}

    public static LazyDoubleCheckSingleton getInstance(){
        //检查是否需要阻塞
        if(instance == null){
            synchronized (LazyDoubleCheckSingleton.class){
                //检查是否需要重新创建实例
                if(instance == null){
                    instance = new LazyDoubleCheckSingleton();
                    //指令重排序问题
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(LazyDoubleCheckSingleton.getInstance());
            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<LazyDoubleCheckSingleton> declaredConstructor = LazyDoubleCheckSingleton.class.getDeclaredConstructor();
                    LazyDoubleCheckSingleton lazyDoubleCheckSingleton = declaredConstructor.newInstance();
                    System.out.println(lazyDoubleCheckSingleton);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

双重校验懒汉防反射

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * 双重检查：1、检查是否要阻塞；2、检查是否创建实例。
 * 优点：安全且在多线程情况下能保持高性能,
 * 第一个if判断避免了其他无用线程竞争锁来造成性能浪费，
 * 第二个if判断能拦截除第一个获得对象锁线程以外的线程。
 * 一定程度上解决了反射问题，反射会报错
 * 缺点：但是可读性不高，代码不够优雅
 */
public class LazyDoubleCheckSingleton2 {
    //volatile:解决了指令重排序问题（指令执行顺序不一定按代码来执行）。
    private volatile static LazyDoubleCheckSingleton2 instance;
    //私有化防实例化
    private LazyDoubleCheckSingleton2(){
        if(LazyDoubleCheckSingleton2.instance != null ){
            throw new RuntimeException("不允许非法的访问");
        }
    }

    public static LazyDoubleCheckSingleton2 getInstance(){
        //检查是否需要阻塞
        if(instance == null){
            synchronized (LazyDoubleCheckSingleton2.class){
                //检查是否需要重新创建实例
                if(instance == null){
                    instance = new LazyDoubleCheckSingleton2();
                    //指令重排序问题
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(LazyDoubleCheckSingleton2.getInstance());
            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<LazyDoubleCheckSingleton2> declaredConstructor = LazyDoubleCheckSingleton2.class.getDeclaredConstructor();
                    LazyDoubleCheckSingleton2 lazyDoubleCheckSingleton2 = declaredConstructor.newInstance();
                    System.out.println(lazyDoubleCheckSingleton2);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

枚举单例

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * INSTANCE，是单例模式的唯一实例。
 * increment,getCount方法永远是一个实例的方法，（方法内部线程不安全，方法是一个）
 *
 * 优点：
 * 使用枚举实现单例模式是线程安全的。
 * 在多线程环境中，多个线程可以同时访问单例对象，但是由于枚举的特殊性质，只有一个实例对象被创建，所以不会出现线程安全问题。
 *
 * 使用枚举实现单例模式可以避免序列化和反序列化的问题。
 * 在 Java 中，当一个类被序列化并在另一个 JVM 中反序列化时，它会创建一个新的对象。
 * 如果使用枚举实现单例模式，则不需要担心这个问题，因为枚举实例是在加载枚举类型时由 JVM 创建的，并且它们是全局可访问的，因此不会出现创建多个实例的情况。
 *
 * 使用枚举实现单例模式可以防止反射攻击。
 * 在 Java 中，反射机制可以通过 Class 类来获取对象的构造函数并创建新的对象。
 * 如果使用枚举实现单例模式，则可以避免这种攻击，因为枚举类型的构造函数是私有的，不能通过反射来调用。
 *
 * 使用枚举实现单例模式可以使代码更加简洁明了。
 * 枚举类型本身就是单例的，因此不需要编写任何特殊的代码来实现单例模式。
 * 并且具有有意义的名称和明确定义的值，这可以减少代码量和提高代码的可读性。
 *
 * 缺点：非延时加载
 */
public enum EnumSingleton {
    INSTANCE;

    private int count = 0;
    public void increment(){
        count++;
    }

    public int getCount(){
        return count;
    }

    public static EnumSingleton getInstance(){
        return INSTANCE;
    }

    public static void main(String[] args) throws InterruptedException {
        EnumSingleton.getInstance().increment();
        EnumSingleton.getInstance().increment();
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(EnumSingleton.getInstance().getCount());

            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor();
                    EnumSingleton enumSingleton = declaredConstructor.newInstance();
                    System.out.println(enumSingleton.getCount());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

内部类单例

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.concurrent.TimeUnit;

/**
 * 利用了classloader机制来保证初始化 instance 时只有一个线程，线程安全；
 * 只有通过显式调用 getInstance 方法时，才会显式装载静态内部类，从而实例化instance，延迟加载。
 *
 * 缺点： 反射失效
 *
 */
public class InnerSingleton {

    private InnerSingleton(){}

    private static class SingletonHolder{
        private static final InnerSingleton INSTANCE = new InnerSingleton();
    }

    public static InnerSingleton getInstance(){
        return SingletonHolder.INSTANCE;
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(InnerSingleton.getInstance());
            }).start();
            //多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<InnerSingleton> declaredConstructor = InnerSingleton.class.getDeclaredConstructor();
                    InnerSingleton innerSingleton = declaredConstructor.newInstance();
                    System.out.println(innerSingleton);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

容器思想单例

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package h.xd.java;

import java.lang.reflect.Constructor;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * 容器模型下的单例，利用多线程安全的hashMap  + sync 机制，实现
 * 缺点： 反射失效，需要锁
 */
public class ContainerSingleton {
    private ContainerSingleton(){}
    private static Map<String,Object> ioc = new ConcurrentHashMap<String, Object>();
    public static synchronized Object getInstance(String className){
        Object instance = null;
        if(!ioc.containsKey(className)){
            try{
                instance = Class.forName(className).newInstance();
                ioc.put(className,instance);
            }catch (Exception e){
                e.printStackTrace();
            }
            return  instance;
        }else {
            return ioc.get(className);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 20; i++) {
            //多线程实例化
            new Thread(()->{
                System.out.println(ContainerSingleton.getInstance("h.xd.java.ContainerSingleton"));
            }).start();
//            多线程反射实例化
            new Thread(()->{
                try {
                    Constructor<ContainerSingleton> declaredConstructor = ContainerSingleton.class.getDeclaredConstructor();
                    ContainerSingleton enumSingleton = declaredConstructor.newInstance();
                    System.out.println(enumSingleton);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }
}

防序列化单例

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package h.xd.java;

import java.io.*;
import java.util.concurrent.TimeUnit;

public class SerializableSingleton implements Serializable {

    //序列化
    //把内存中的对象的状态转化为字节码的形式
    //把字节码通过IO输出流，写到磁盘！
    //永久的保存下来
    public final static  SerializableSingleton INSTANCE = new SerializableSingleton();

    private SerializableSingleton(){}

    public static SerializableSingleton getInstance(){
        return INSTANCE;
    }


    /**
     * 防止序列化，对象重复创建
     * @return
     */
    public Object readResolve(){
        return INSTANCE;
    }


    public static void main(String[] args) throws InterruptedException {
        SerializableSingleton instance = SerializableSingleton.getInstance();
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream("SerializableSingleton.obj");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance);
            oos.flush();
            oos.close();

            System.out.println(instance);
            for (int i = 0; i < 20; i++) {
                //多线程实例化
                new Thread(() -> {
                    FileInputStream fis = null;
                    SerializableSingleton instance1 = null;
                    try {
                        fis = new FileInputStream("SerializableSingleton.obj");
                        ObjectInputStream ois = new ObjectInputStream(fis);
                        instance1 =(SerializableSingleton) ois.readObject();
                        ois.close();

                        System.out.println(instance1);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }).start();
            }
            TimeUnit.SECONDS.sleep(2);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

线程内部只有一个实例的单例

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
31
32
33
34
35
36
package h.xd.java;

import java.util.concurrent.TimeUnit;

/**
 * 线程内部，单例，
 * 缺点：多线程失效、反射失效、序列化失效
 */
public class ThreadLocalSingleton {

    private static final ThreadLocal<ThreadLocalSingleton> INSTANCE =
            ThreadLocal.withInitial(ThreadLocalSingleton::new);


    private ThreadLocalSingleton(){}


    public static ThreadLocalSingleton getInstance(){
        return INSTANCE.get();
    }

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 1; i++) {
            //多线程实例化
            new Thread(() -> {
                System.out.println(ThreadLocalSingleton.getInstance());
                System.out.println(ThreadLocalSingleton.getInstance());
                System.out.println(ThreadLocalSingleton.getInstance());
                System.out.println(ThreadLocalSingleton.getInstance());
            }).start();
        }
        TimeUnit.SECONDS.sleep(2);
    }

}

单例模式要点

  1. 私有化构造器,防直接实例化
  2. 保证线程安全
  3. 按需选择延迟加载和非延时加载
  4. 防止序列化和反序列化破坏单例
  5. 防御反射攻击单例
  • 本文标题：Java单例总结
  • 本文作者：形而上
  • 创建时间：2022-04-12 12:34:56
  • 本文链接：https://deepter.gitee.io/2022_04_12_java_singleton/
  • 版权声明：本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！