设计模式之单例模式（创建型）

最新推荐文章于 2025-08-16 22:37:45 发布

置顶微笑-jack

最新推荐文章于 2025-08-16 22:37:45 发布

阅读量194

点赞数 1

CC 4.0 BY-SA版权

分类专栏：设计模式文章标签：设计模式单例线程安全单例序列化懒汉式

本文链接：https://blog.youkuaiyun.com/a942846446/article/details/86442034

设计模式专栏收录该内容

1 篇文章

订阅专栏

本文深入探讨了单例模式的各种实现方式，包括饿汉式、懒汉式、线程安全的懒汉式、DoubleCheckLocking、静态内部类、静态代码块、枚举等，分析了它们在高并发和序列化场景下的表现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

单例模式是非常常见的一种设计模式，而单例模式有很多种实现方式，你是否都了解呢？如何在高并发多线程的情况下依旧保证线程的安全性呢？在序列化和反序列化后依旧是单例对象呢？在不同场景下应该使用哪些实现方式？

什么是单例模式？

单例简单来讲就是单一实例，保证全局只有这一个类的对象，可被复用，减少了内存的消耗，减少了GC回收的次数

1.饿汉式单例

饿汉式单例是指在方法调用前，类创建的时候实例就已经创建好了。下面是实现代码：

package com.example.jack.designmode.singleton;

class Singleton1 {

    private static Singleton1 singleton1 = new Singleton1();

    private Singleton1() {}

    static Singleton1 getInstance() {
        return singleton1;
    }
}

这样就实现了饿汉式单例，来看看在饿汉式单例在多线运行的情况吧！

package com.example.jack.designmode.singleton;

class MyThread extends Thread {

    @Override
    public void run() {
        System.out.println(Singleton1.getInstance().hashCode());
    }

    public static void main(String[] args) {

        MyThread[] myThreads = new MyThread[10];
        for (int i = 0; i < myThreads.length; i++) {
            myThreads[i] = new MyThread();
        }

        for (MyThread thread : myThreads) {
            thread.start();
        }
    }
}

以下是运行结果：

378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546

每个hashCode都是一样的，说明是线程安全的

小结：饿汉式单例线程安全、高并发效率高，没有延迟加载

2.懒汉式单例

懒汉式单例是指在类创建的时候没有创建，方法调用时，去创建实例。下面是实现代码：

package com.example.jack.designmode.singleton;

class Singleton2 {

    private static Singleton2 singleton2 = null;

    private Singleton2() {}

    static Singleton2 getInstance() {
        if (singleton2 == null) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

这样就实现了懒汉式单例，加个延时模拟下耗时效果，来看看在懒汉式单例在多线运行的情况吧！

390233048
390233048
260208698
260208698
1084879695
1084879695
1532375396
1532375396
1532375396
138130691

hashCode有不一致的，说明线程不安全

小结：懒汉式单例线程不安全、高并发效率高，延迟加载

3.线程安全的懒汉式单例

想要保证线程安全需要加上synchronized关键字，进行加锁操作，具体实现如下：

package com.example.jack.designmode.singleton;

class Singleton3 {

    private static Singleton3 singleton3 = null;

    private Singleton3() {}

    static Singleton3 getInstance() {
        synchronized (Singleton3.class) {
            // 注意：里面的判断是一定要加的，否则出现线程安全问题
            if (singleton3 == null) {
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                singleton3 = new Singleton3();
            }
        }
        return singleton3;
    }
}

运行效果如下：

1732326040
1732326040
1732326040
1732326040
1732326040
1732326040
1732326040
1732326040
1732326040
1732326040

每个hashCode都是一样的，说明是线程安全的，但是加锁了，运行效率变低了

小结：懒汉式单例加锁线程安全、高并发效率低，延迟加载

4.Double Check Locking 双检查锁机制

从例2的运行结果来看，并不是每个线程都需要加锁，只对需要锁的部分代码加锁就好了，这样可以提高运行效率，并使用volatile关键字保其可见性和防止指令重排序

package com.example.jack.designmode.singleton;

class Singleton4 {

    //使用volatile关键字保其可见性和防止指令重排序
    volatile private static Singleton4 singleton4 = null;

    private Singleton4() {}

    /**
     * 使用双重检查进一步做了优化，可以避免整个方法被锁，只对需要锁的代码部分加锁，可以提高执行效率。
     */
    static Singleton4 getInstance() {
        if (singleton4 == null) {
            synchronized (Singleton4.class) {
                // 注意：里面的判断是一定要加的，否则出现线程安全问题
                if (singleton4 == null) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }

运行效果如下：

378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546
378778546

每个hashCode都是一样的，说明是线程安全的，只对需要加锁的部分加锁，提高了效率

小结：懒汉式单例双检查锁机制线程安全、高并发效率比饿汉式低，比懒加载单次检查高，延迟加载

5.静态内部类实现单例

静态内部类在创建类的时候没有创建实例，方法调用时，去调用静态内部类，静态内部类创建的时候创建实例。下面是实现代码：

package com.example.jack.designmode.singleton;

/**
 * Created by jack on 2018/10/31.
 * Copyright  2018 jack.huang@dadaabc.com. All rights reserved.
 */
class Singleton5 {

    private static class SingletonHandler {
        private static Singleton5 instance = new Singleton5();
    }

    private Singleton5() {}

    static Singleton5 getInstance() {
        return SingletonHandler.instance;
    }
}

运行效果如下：

211315415
211315415
211315415
211315415
211315415
211315415
211315415
211315415
211315415
211315415

每个hashCode都是一样的，说明是线程安全的，也没有加锁

小结：静态内部类实现单例，线程安全、高并发效率，延迟加载

6.静态代码块实现单例

静态代码块单例也是饿汉式的一种，静态代码块也是在类加载的时候就加载了，和第一种方式没什么区别，下面是实现代码：

package com.example.jack.designmode.singleton;

/**
 * Created by jack on 2018/10/31.
 * Copyright  2018 jack.huang@dadaabc.com. All rights reserved.
 */
class Singleton6 {

    private static Singleton6 instance;

    static {
        instance = new Singleton6();
    }

    private Singleton6() {}

    static Singleton6 getInstance() {
        return instance;
    }
}

运行效果如下：

1195510409
1195510409
1195510409
1195510409
1195510409
1195510409
1195510409
1195510409
1195510409
1195510409

每个hashCode都是一样的，说明是线程安全的，也没有加锁

小结：静态代码块实现单例，线程安全、高并发效率

6.单例实现序列化

有时单例使用的场景会被序列化，在反序列化时，ObjectInputStream 因为利用反射机制调用了 readObject --> readObject0 --> readOrdinary --> CheckResolve。在readOrdinady中调用了invokeReadResolve()，该方法使用反射机制创建新的对象，从而破坏了单例唯一性，下面是实现：

package com.example.jack.designmode.singleton;

import java.io.Serializable;

/**
 * Created by jack on 2018/10/31.
 * Copyright  2018 jack.huang@dadaabc.com. All rights reserved.
 */
class Singleton6 implements Serializable {

    private static Singleton6 instance;

    static {
        instance = new Singleton6();
    }

    private Singleton6() {}

    static Singleton6 getInstance() {
        return instance;
    }
}

上面是实现序列化的单例，下面是流的操作

package com.example.jack.designmode.singleton;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

class MyThread extends Thread {

    @Override
    public void run() {
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        System.out.println(Singleton6.getInstance().hashCode());
        //Write Obj to file
        ObjectOutputStream oos;
        oos = new ObjectOutputStream(new FileOutputStream("/Users/jack/Desktop/test.txt"));
        oos.writeObject(Singleton6.getInstance());
        //Read Obj from file
        File file = new File("/Users/jack/Desktop/test.txt");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton6 newInstance = (Singleton6) ois.readObject();
        System.out.println(newInstance.hashCode());
    }
}

运行结果如下：

1956725890
1828972342

很明显，生成了新的实例，破坏了单例，那要怎么做呢？加上private Object readResolve()，把当前的对象传回去

package com.example.jack.designmode.singleton;

import java.io.Serializable;

/**
 * Created by jack on 2018/10/31.
 * Copyright  2018 jack.huang@dadaabc.com. All rights reserved.
 */
class Singleton6 implements Serializable {

    private static Singleton6 instance;

    static {
        instance = new Singleton6();
    }

    private Singleton6() {}

    static Singleton6 getInstance() {
        return instance;
    }

    private Object readResolve() {
        return instance;
    }
}

运行结果如下：

1956725890
1956725890

小结：单例有序列化的操作，需要实现序列化，并加上private Object readResolve()，把当前的对象传回去，防止反序列化时被破坏

7.使用枚举实现单例

写法非常简单，请看以下代码：

package com.example.jack.designmode.singleton;

/**
 * Created by jack on 2018/10/31.
 * Copyright  2018 jack.huang@dadaabc.com. All rights reserved.
 */
enum Singleton7 {
    INSTANCE
}

多线程情况运行结果：

484896255
484896255
484896255
484896255
484896255
484896255
484896255
484896255
484896255
484896255

每个hashCode都是一样的，说明是线程安全的，也没有加锁

序列化情况运行结果：

1956725890
1956725890

小结：使用枚举实现单例，线程安全，高并发效率高，序列化和反序列化安全

以上就是单例的几种实现方式

思考与总结：

1.饿汉式VS懒汉式

同学A:饿汉式是在类加载的时候就实例化了，在去使用的时候直接用就好了，效率相对高。而且因为创建时间较早，即使在多线程的情况在也不需要考虑线程安全问题，我觉得饿汉式比较有优势！

同学B:懒汉式是在方法调用的时候才去实例化对象，这样可以有效的避免了内存浪费。虽然在多线程的情况下，有多个线程同时在实例化对象，可能会产生多个对象，造成线程不安全。但是可以加线程锁和双重判断解决这个问题，就是效率相对低。如果在类中还有其它静态方法或变量，饿汉式调用静态方法或变量，也是会实例化对象，造成内存浪费！

点评：

饿汉式优点：效率高、线程安全缺点：过早占用内存、可能有其它情况产生不必要的实例化，造成内存浪费

懒汉式优点：延时加载节省内存缺点：线程不安全，需要加线程锁、效率低、代码复杂

结论：各有优略，适合不同场景使用

2.静态内部类

静态内部类就好像饿汉式和懒汉式的结合体，延时加载节省内存、效率高、线程安全

3.序列化的情况下

以上三种都需要private Object readResolve()，把当前的对象传回去

4.枚举

优点效率高、线程安全、序列化/反序列化安全、能抵御反射攻击缺点：不能延时加载

以上三种都不能防止反射