设计模式之单例模式

最新推荐文章于 2025-05-16 19:06:27 发布

经常健身的文安

最新推荐文章于 2025-05-16 19:06:27 发布

阅读量922

点赞数

文章标签：单例模式 java c++

本文链接：https://blog.youkuaiyun.com/m0_46702468/article/details/121733030

版权

本文详细介绍了Java中的单例模式，包括饿汉式和懒汉式的实现，以及它们的优缺点。讨论了线程安全问题，并提出双重检查锁和静态内部类实现的高效线程安全单例模式，强调了在多线程环境下保证单例的正确性与性能的重要性。

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

一、为什么要有单例模式？

在日常开发中遇到日志管理、打印机、数据库连接池、应用配置等场景，只需要有一个对应的实例对象即可，有多个对象时，会导致执行混乱的情况，同时也会造成资源浪费，垃圾回收频繁。

二、如何实现单例模式

单例模式的简单实现（饿汉式）

我们实现一般的对象时，都是直接通过New Object（）的方式，通过对象的构造方法实例化对象，那我们把对象的构造方法私有化，只有对象自己可以访问，不就可以让外界无法直接实例化对象，这就可以给单例模式创造了条件。

如下代码

public class Singleton {

    // 定义Singleton只能被实例化一次
    private static final Singleton singleton=new Singleton();

    // 定义Singleton变量为私有，无法从外界访问
    private Singleton() {
    }

    // 暴露创建Singleton的方法，让外界可以通过静态方法获取对象的实例
    public static Singleton getInstance() {
        return singleton;
    }

    public void getMethod() {
        System.out.println("singleton方法");
    }
}

测试

public class SingletonTest {
    public static void main(String[] args) {
        /*
        尝试去
        new Singleton();
        提示对象构造方法未私有，不可以直接实例化
         */
        Singleton singleton = Singleton.getInstance();
        singleton.getMethod();
        System.out.println("singleton类id："+singleton);
    }
}

返回结果

singleton方法
singleton类id：com.wenan.design.singleton.Singleton@6d6f6e28

以上，就是单例模式的实现，这个单例模式，也称为“饿汉式单例模式”，简单说就是类加载时就实例化对象。
饿汉式模式有以下优点：

线程安全：由于对象的实例只能由对象内部创建，并且只创建1个对象，所有的线程，都只能够使用这一个对象，确保线程安全。
没有使用锁，执行效率高

当然，也有缺点：

类加载时就初始化对象，浪费内存

懒汉式

懒汉式，顾名思义，就是在类加载的时候，不对实例进行初始化，而是当第一次被调用的时候再进行初始化

不加锁情况下的懒汉式

public class Singleton {

    private static  Singleton singleton;

    // 定义Singleton变量为私有，无法从外界访问
    private Singleton() {
    }

    // 暴露创建Singleton的方法，让外界可以访问
    public static Singleton getInstance() {
        // 当实例没有的时候，就创建实例，并把实例赋值给singleton
        if (singleton == null) {
            singleton = new Singleton();
        }
        // 当已经有实例的时候，直接返回实例
        return singleton;
    }

    public void getMethod() {
        System.out.println("singleton方法");
    }
}

测试：

public class SingletonTest {
    public static void main(String[] args) {
        // 创建线程1
        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    Singleton instance = Singleton.getInstance();
                    System.out.println("线程1：第" + i + "次调用" + instance);
                }
            }
        });

        // 创建线程2
        Thread thread2= new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    Singleton instance = Singleton.getInstance();
                    System.out.println("线程2：第" + i + "次调用" + instance);
                }
            }
        });
        
        thread1.start();
        thread2.start();

    }
}

结果

线程1：第0次调用com.wenan.design.singleton.Singleton@1e542a06
线程2：第0次调用com.wenan.design.singleton.Singleton@55f9807a
线程1：第1次调用com.wenan.design.singleton.Singleton@55f9807a
线程2：第1次调用com.wenan.design.singleton.Singleton@55f9807a
线程1：第2次调用com.wenan.design.singleton.Singleton@55f9807a
线程2：第2次调用com.wenan.design.singleton.Singleton@55f9807a
。。。

通过不加锁的方式进行获取对象实例的方式，在多线程的情况下，还是会出现类被实例化2次的问题。

对上述代码进行加锁synchronized

public class Singleton {

    private static  Singleton singleton;

    // 定义Singleton变量为私有，无法从外界访问
    private Singleton() {
    }

    // 暴露创建Singleton的方法，让外界可以访问
    public static synchronized Singleton getInstance() {
        // 当实例没有的时候，就创建实例，并把实例赋值给singleton
        if (singleton == null) {
            singleton = new Singleton();
        }
        // 当已经有实例的时候，直接返回实例
        return singleton;
    }

    public void getMethod() {
        System.out.println("singleton方法");
    }
}

测试：

public class SingletonTest {
    public static void main(String[] args) {
        // 创建线程1
        Thread thread1 = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    Singleton instance = Singleton.getInstance();
                    System.out.println("线程1：第" + i + "次调用" + instance);
                }
            }
        });

        // 创建线程2
        Thread thread2= new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 1000; i++) {
                    Singleton instance = Singleton.getInstance();
                    System.out.println("线程2：第" + i + "次调用" + instance);
                }
            }
        });
        
        thread1.start();
        thread2.start();

    }
}

结果

线程1：第0次调用com.wenan.design.singleton.Singleton@3d9d3b82
线程1：第1次调用com.wenan.design.singleton.Singleton@3d9d3b82
线程1：第2次调用com.wenan.design.singleton.Singleton@3d9d3b82
线程1：第3次调用com.wenan.design.singleton.Singleton@3d9d3b82
线程1：第4次调用com.wenan.design.singleton.Singleton@3d9d3b82
。。。

这样保证了线程安全，对象只会被实例化一次，但因为要枷锁，会影响执行效率，当线程数量增加时，每个线程要使用该实例，都需要等其他线程使用完，释放锁，才可以拿到实例。

双重检查锁实现

public class Singleton {

    private static volatile Singleton singleton;

    // 定义Singleton变量为私有，无法从外界访问
    private Singleton() {
    }

    // 暴露创建Singleton的方法，让外界可以访问
    public static Singleton getInstance() {
        // 当实例没有的时候，就创建实例，并把实例赋值给singleton
        if (singleton == null) {
            // 在内部加锁
            synchronized (Singleton.class){
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        // 当已经有实例的时候，直接返回实例
        return singleton;
    }

    public void getMethod() {
        System.out.println("singleton方法");
    }
}

这种加锁方式，在多线程的情况下，可以使用，并且高性能。

登记式静态内部类

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

public class Singleton {

    private static class SingletonHolder{
        private static final Singleton singleton = new Singleton();
    }

    // 定义Singleton变量为私有，无法从外界访问
    private Singleton() {
    }

    // 暴露创建Singleton的方法，让外界可以访问
    public static Singleton getInstance() {
        return SingletonHolder.singleton;
    }

    public void getMethod() {
        System.out.println("singleton方法");
    }
}

这种方式和饿汉式的实现方法不同，饿汉式在类加载时就初始化了实例，而这种方式利用了ClassLoader的特性，Singleton 类被加载了，但里面的静态类SingletonHolder还没有被使用，里面的Singleton实例就不会初始化