单例模式的实现

最新推荐文章于 2023-04-22 22:00:04 发布

一字码

最新推荐文章于 2023-04-22 22:00:04 发布

阅读量2.6k

点赞数

分类专栏：设计模式文章标签：设计模式 java 多线程面试

本文链接：https://blog.csdn.net/code_ang/article/details/117083158

版权

设计模式专栏收录该内容

4 篇文章 1 订阅

订阅专栏

一、什么是单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

需要注意：
1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。

实现说明：

1、私有化该类的构造方法，构造方法私有化，其他的类或代码无法通过调用该类的构造方法来实现该类，必须通过调用该类提供的静态方法实例化方法来实例化。
2、该类提供一个静态的实例化自己的方法，如果该类已经实例化，就直接提供实例化的引用，如果没有实例化，就创建一个实例化引用，并赋予该类保持的引用。

下面是单例模式的结构图：
在这里插入图片描述
二、单例模式的优点和缺点
优点：
1、单例模式可以保证内存里只有一个实例，减少了内存的开销。
2、可以避免对资源的多重占用。
3、单例模式设置全局访问点，可以优化和共享资源的访问。
缺点：
1、单例模式一般没有接口，扩展困难。如果要扩展，则除了修改原来的代码，没有第二种途径，违背开闭原则。
2、在并发测试中，单例模式不利于代码调试。在调试过程中，如果单例中的代码没有执行完，也不能模拟生成一个新的对象。
3、单例模式的功能代码通常写在一个类中，如果功能设计不合理，则很容易违背单一职责原则。

三、单例模式的应用场景

在计算机系统中，有 Windows 的回收站、操作系统中的文件系统、多线程中的线程池、显卡的驱动程序对象、打印机的后台处理服务、应用程序的日志对象、数据库的连接池、网站的计数器、Web 应用的配置对象、应用程序中的对话框、系统中的缓存等常常被设计成单例。

适用场景：

1.需要生成唯一序列的环境
2.需要频繁实例化然后销毁的对象。
3.创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
4.方便资源相互通信的环境

二、多种方式实现单例
1、懒汉方式
在类初始化的时候就不会实例化，只有在需要的时候才会实例化一个引用。

方法实现：

/**
 * 懒汉单例方式
 */
public class LazySingleton {
    /**
     * 添加 volatile 是保证在线程中同步
     */
    private static  LazySingleton instance = null;
    /**
     * 私有化无参构造
     */
    private LazySingleton(){
    }
    /**
     *  加synchronized 也是为了线程安全
     */
    public static  LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return  instance;
    }
}

测试类：

public static void main(String[] args) throws Exception {
        //ptMethod();
        //fsMethod();
        threadDemo();
    }

    /**
     * 普通方法
     */
    public static void ptMethod(){
        System.out.println("普通方法！");
        LazySingleton la1 = LazySingleton.getInstance();
        LazySingleton la2 = LazySingleton.getInstance();
        System.out.println(la1==la2);
    }
    /**
     * 反射
     */
    public static void fsMethod() throws Exception{
        System.out.println("反射方法！");
        Class<LazySingleton> cl = LazySingleton.class;
        Constructor<LazySingleton> cla = cl.getDeclaredConstructor();
        cla.setAccessible(true);
        LazySingleton la1 = LazySingleton.getInstance();
        LazySingleton la2 = cla.newInstance();
        System.out.println(la1== la2);
    }

    /**
     * 多线程
     */
    private static  void threadDemo(){
        System.out.println("多线程");
        for (int i = 0; i < 5; i++) {
            new Thread(){
                @Override
                public void run() {
                    System.out.println(LazySingleton.getInstance());
                }
            }.start();
        }
    }

执行结果：

普通方法：
在这里插入图片描述
反射方法：

多线程方法:

结论：
从上面的测试代码中可以看出，懒汉方式在普通方法中调用是线程安全的，用反射调用是非线程安全的，多线程也是不安全的。解决线程不安全的办法就是在创建静态对象参数的时候添加volatile ，并且在静态实例化方法上添加synchronized 来实现线程安全。（上面的代码中也已经标注出来了）

2、饿汉方式
在类初始化的时候就会先被实例化，但是如果一直不用就会占着一部分内存。
方法实现：

public class HungrySingleton {
    /**
     * 创建实体类
     */
    private static HungrySingleton instance = new HungrySingleton();

    /**
     * 私有化构造方法
     */
    private HungrySingleton(){}

    /**
     * 静态对外方法
     * @return
     */
    public static HungrySingleton getInstance(){
        return instance;
    }
}

测试类：

public class Test2 {
    public static void main(String[] args) throws Exception{
        //ptMethod();
        //fsMethod();
        threadDemo();
    }
    /**
     * 普通方法
     */
    public static void ptMethod(){
        System.out.println("普通方法！");
        HungrySingleton hs1 = HungrySingleton.getInstance();
        HungrySingleton hs2 = HungrySingleton.getInstance();
        System.out.println(hs1==hs2);
    }
    /**
     * 反射
     */
    public static void fsMethod() throws Exception{
        System.out.println("反射方法！");
        Class<HungrySingleton> cl = HungrySingleton.class;
        Constructor<HungrySingleton> cla = cl.getDeclaredConstructor();
        cla.setAccessible(true);
        HungrySingleton hs1 = HungrySingleton.getInstance();
        HungrySingleton hs2 = cla.newInstance();
        System.out.println(hs1== hs2);
    }

    /**
     * 多线程
     */
    private static  void threadDemo(){
        System.out.println("多线程");
        for (int i = 0; i < 5; i++) {
            new Thread(){
                @Override
                public void run() {
                    System.out.println(HungrySingleton.getInstance());
                }
            }.start();
        }
    }
}

执行结果：

普通方法：
在这里插入图片描述
反射方法：

线程方法：

总结：
饿汉方式普通调用是线程安全的，反射调用不安全，线程调用是安全的，并且不用加锁，执行效率高，但容易产生垃圾对象。
3、登记方式

/**
 * 登记方式
 */
public class RegisterSingleton {

    private static class RegisterSingletonHodel{
        private static RegisterSingleton instance = new RegisterSingleton();
    }

    private RegisterSingleton(){}

    public static RegisterSingleton getInstance(){
        return RegisterSingletonHodel.instance;
    }

}

测试类：


public class Test3 {
    public static void main(String[] args) throws Exception{
        ptMethod();
        //fsMethod();
        //threadDemo();
    }
    /**
     * 普通方法
     */
    public static void ptMethod(){
        System.out.println("普通方法！");
        RegisterSingleton rs1 = RegisterSingleton.getInstance();
        RegisterSingleton rs2 = RegisterSingleton.getInstance();
        System.out.println(rs1==rs2);
    }
    /**
     * 反射
     */
    public static void fsMethod() throws Exception{
        System.out.println("反射方法！");
        Class<RegisterSingleton> cl = RegisterSingleton.class;
        Constructor<RegisterSingleton> cla = cl.getDeclaredConstructor();
        cla.setAccessible(true);
        RegisterSingleton rs1 = RegisterSingleton.getInstance();
        RegisterSingleton rs2 = cla.newInstance();
        System.out.println(rs1== rs2);
    }

    /**
     * 多线程
     */
    private static  void threadDemo(){
        System.out.println("多线程");
        for (int i = 0; i < 5; i++) {
            new Thread(){
                @Override
                public void run() {
                    System.out.println(RegisterSingleton.getInstance());
                }
            }.start();
        }
    }
}

普通方法：
在这里插入图片描述

反射方法：
在这里插入图片描述

线程方法：
在这里插入图片描述
总结：登记方式和懒汉方式加双重锁效果一样，它可以延迟加载，而且不会浪费内存资源，线程也是安全的，反射不安全。
4、枚举方式

/**
 * 枚举方式
 */
public enum EnumSingleton {
    INSTANCE;
    public void whateverMethod(){
        System.out.println("枚举方式");
    }

}

测试类：


public class Test4 {
    public static void main(String[] args) throws Exception{
        // ptMethod();
         fsMethod();
    }
    /**
     * 普通方法
     */
    public static void ptMethod(){
        System.out.println("普通方法！");
        EnumSingleton es1 = EnumSingleton.INSTANCE;
        EnumSingleton es2 = EnumSingleton.INSTANCE;
        System.out.println(es1==es2);
    }
    /**
     * 反射
     */
    public static void fsMethod() throws Exception{
        System.out.println("反射方法！");
        Class<EnumSingleton> cl = EnumSingleton.class;
        Constructor<EnumSingleton> cla = cl.getDeclaredConstructor();
        cla.setAccessible(true);
        EnumSingleton rs1 = EnumSingleton.INSTANCE;
        EnumSingleton rs2 = cla.newInstance();
        System.out.println(rs1== rs2);
    }

}

普通方法：
在这里插入图片描述
反射方法：

总结：枚举方式不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化，并且不能通过反射来调用，唯一的缺点就是不能被继承。

三、最后总结
总的来说在一般情况下，不建议使用懒汉方式，如果有特殊的需求可以选择用加双重校验锁的方式来应用，推荐用还是饿汉方式，虽然初始化的时候回占用一定的内存，但是效率高，线程安全；如果涉及到延迟加载可以使用登记方式；如果涉及到反序列化创建对象时可尝试使用枚举方式。

一字码

关注

0
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
单例模式的实现

一、什么是单例模式单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。需要注意：1、单例类只能有一个实例。2、单例类必须自己创建自己的唯一实例。3、单例类必须给所有其他对象提供这一实例。实现说明：1、私有化该类的构造方法，构造方法私有化，其
复制链接

扫一扫