JAVA单例模式代码实现

最新推荐文章于 2024-07-24 15:19:30 发布
最新推荐文章于 2024-07-24 15:19:30 发布
阅读量1.3k 收藏 4
点赞数 3
分类专栏： 设计模式 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36556137/article/details/108230650
版权
本文探讨JAVA中的单例模式，包括懒汉模式、静态内部类单例、饿汉模式和枚举单例，详细解析了各模式的优缺点及多线程安全性。并深入分析了单例模式可能遇到的反射攻击和序列化问题，提出了解决方案。
摘要由CSDN通过智能技术生成

JAVA常见的设计模式之单例模式

  • 懒汉模式

             懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间(搬运工)。

标准的懒汉模式

class LazySingleton {
    // 私有成员属性
    private LazySingleton lazySingleton;
    
    // 私有构造方法
    private LazySingleton() {
    }
    
    // 公共的获取实例方法
    public LazySingleton getLazySingleton() {
        // 如果成员属性为空，则创建实例
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

单线程环境下，该单例模式只会有一个实例

public class TestDemo
{
    public static void main(String[] args) {
        LazySingleton lazySingleton = LazySingleton.getLazySingleton();
        LazySingleton lazySingleton2 = LazySingleton.getLazySingleton();
        System.out.println(lazySingleton == lazySingleton2);
    }
}

运行结果：

多线程模式下，可能会产生多个实例

public class TestDemo
{
    public static void main(String[] args) {
        new Thread(() -> {
            LazySingleton lazySingleton = LazySingleton.getLazySingleton();
            System.out.println(lazySingleton);
        }).start();
        new Thread(() -> {
            LazySingleton lazySingleton = LazySingleton.getLazySingleton();
            System.out.println(lazySingleton);
        }).start();
    }
}

运行结果：

初步改进

class LazySingleton {
    // 私有成员属性
    private static LazySingleton lazySingleton;

    // 私有构造方法
    private LazySingleton() {
    }

    // 公共的获取实例方法
    public synchronized static LazySingleton getLazySingleton() {
        // 如果成员属性为空，则创建实例
        if (lazySingleton == null) {
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

缺点，每次调用方法都会加锁，效率低

再次改进

class LazySingleton {
    // 私有成员属性,使用volatile可以保证代码的有序性,防止指令重排
    private volatile static LazySingleton lazySingleton;

    // 私有构造方法
    private LazySingleton() {
    }

    // 公共的获取实例方法
    // 使用synchronized + 双重确认机制可以保证线程安全，但有可能存在指令重排，会导致创建多个实例
    public static LazySingleton getLazySingleton() {
        if (lazySingleton == null) {
            synchronized (LazySingleton.class) {
                if (lazySingleton == null) {
                    lazySingleton = new LazySingleton();
                }
            }
        }
        return lazySingleton;
    }
}

静态类部类单例

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }

}

 静态类不类单例不会有线程安全问题，线程安全由类加载机制担保

恶汉模式

             饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间(搬运工)。 

// 利用类加载机制保证线程安全
class HungrySingleton {
    private static HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getHungrySingleton() {
        return hungrySingleton;
    }
}

 枚举单例模式

package com.hy.test.singletonDemo;

public enum EnumSingletonDemo {
    INSTANCE;

}

class EnumTest {
    public static void main(String[] args) {
        EnumSingletonDemo instance = EnumSingletonDemo.INSTANCE;
        EnumSingletonDemo instance2 = EnumSingletonDemo.INSTANCE;
        System.out.println(instance == instance2);
    }
}

运行结果：

单例模式可能出现的问题(都会用静态类不类单例举例)

反射攻击

/**
 * 测试demo
 *
 * @auther Hy
 * @date 2020/8/25
 */
public class TestDemo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
        Class clazz = InnerSingleton.class;
        Constructor<InnerSingleton> declaredConstructor = clazz.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerSingleton innerSingleton1 = (InnerSingleton) declaredConstructor.newInstance();
        System.out.println(innerSingleton == innerSingleton1);
    }
}

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }

}

运行结果：

由此可见，反射生成了一个新的对象，不符合单例模式的定义

解决方法：在私有构造器中添加判断，如果已存在实例对象，抛出异常(也可进行其他操作，根据需求决定)

优化后的代码如下

/**
 * 测试demo
 *
 * @auther Hy
 * @date 2020/8/25
 */
public class TestDemo {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
        Class clazz = InnerSingleton.class;
        Constructor<InnerSingleton> declaredConstructor = clazz.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        InnerSingleton innerSingleton1 = (InnerSingleton) declaredConstructor.newInstance();
        System.out.println(innerSingleton == innerSingleton1);
    }
}

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
        // 防止反射攻击，只有恶汉与静态类部类能防止反射攻击
        if (InnerSingletonHolder.innerSingleton != null) {
            throw new RuntimeException("单例模式已存在一个实例");
        }
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }

}

 运行结果：

注意：只有恶汉模式与静态类部类能防止反射攻击

序列化相关问题

 首先，我们对创建的实例进行序列化，代码如下：

/**
 * 测试demo
 *
 * @auther Hy
 * @date 2020/8/25
 */
public class TestDemo {
    public static void main(String[] args) throws IOException {
        InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
        // 序列化测试
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
        oos.writeObject(innerSingleton);
        oos.close();
        // 反序列化
/*        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
        InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
        System.out.println(innerSingleton == innerSingleton1);*/
    }
}

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    // 需要固定序列化版本号id，如果不固定,JVM会根据字段、方法等生成一个序列化ID，并存入对应的序列化文件，反序列化时,
    // 会按照相同规则生成一个序列化版本号进行对比，如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
    private static final long serialVersionUID = 7822769557659839582L;

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
        // 防止反射攻击，只有恶汉与静态类不类能防止反射攻击
        if (InnerSingletonHolder.innerSingleton != null) {
            throw new RuntimeException("单例已存在一个实例");
        }
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }
    
}

然后，我们进行反序列化，查看反序列化生成的实例跟单例的实例是否是同一个

/**
 * 测试demo
 *
 * @auther Hy
 * @date 2020/8/25
 */
public class TestDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
        // 序列化测试
/*        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
        oos.writeObject(innerSingleton);
        oos.close();*/
        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
        InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
        System.out.println(innerSingleton == innerSingleton1);
    }
}

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    // 需要固定序列化版本号id，如果不固定,JVM会根据字段、方法等生成一个序列化ID，并存入对应的序列化文件，反序列化时,
    // 会按照相同规则生成一个序列化版本号进行对比，如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
    private static final long serialVersionUID = 7822769557659839582L;

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
        // 防止反射攻击，只有恶汉与静态类不类能防止反射攻击
        if (InnerSingletonHolder.innerSingleton != null) {
            throw new RuntimeException("单例已存在一个实例");
        }
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }

}

运行结果：

由此可见，反序列化创建了一个新的实例

解决方法：Serializable的源码中给出了提示

/**
 * 测试demo
 *
 * @auther Hy
 * @date 2020/8/25
 */
public class TestDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        InnerSingleton innerSingleton = InnerSingleton.getInnerSingleton();
        // 序列化测试
/*        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("innerTest"));
        oos.writeObject(innerSingleton);
        oos.close();*/
        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("innerTest"));
        InnerSingleton innerSingleton1 = (InnerSingleton) ois.readObject();
        System.out.println(innerSingleton == innerSingleton1);
    }
}

/**
 * 由静态内部类持有单例对象，并调用外部类的私有构造器初始化，由外部类调用静态内部类的属性
 * 本质是一个懒汉模式，在类加载时才会初始化对象
 */
class InnerSingleton implements Serializable {

    // 需要固定序列化版本号id，如果不固定,JVM会根据字段、方法等生成一个序列化ID，并存入对应的序列化文件，反序列化时,
    // 会按照相同规则生成一个序列化版本号进行对比，如果类已经发生了改变,反序列化的版本号会对应不上,反序列化会失败
    private static final long serialVersionUID = 7822769557659839582L;

    private static class InnerSingletonHolder {
        private static InnerSingleton innerSingleton = new InnerSingleton();
    }

    private InnerSingleton() {
        // 防止反射攻击，只有恶汉与静态类不类能防止反射攻击
        if (InnerSingletonHolder.innerSingleton != null) {
            throw new RuntimeException("单例已存在一个实例");
        }
    }

    public static InnerSingleton getInnerSingleton() {
        return InnerSingletonHolder.innerSingleton;
    }

    // 反序列化时,如果是单例模式,需要重写该方法,返回单例的实例，否则会获取到不同的对象
    Object readResolve() throws ObjectStreamException {
        return InnerSingletonHolder.innerSingleton;
    }
}

运行结果：

因此，在工作中推荐大家使用静态类部类单例模式，可以有效的防止反射攻击与序列化带来的相关问题

预见-遇见
关注
专栏目录
单例模式的Java如何去实现？
m0_73603837的博客
09-14 393
本文分析了单例模式在 Java 里的不同实现方式，通过对比优劣最后提出结论。
Java单例模式实现的几种方式
09-01
Java单例模式是一种设计模式，它保证一个类只有一个实例，并提供一个全局访问点。这种模式在需要频繁创建和销毁对象的场景中非常有用，比如配置类、缓存管理或者数据库连接池等。以下是对Java中实现单例模式的几种...
单例模式java代码
12-04
编写一个类LimitInstanceClass，该类最多可以实例化指定个数实例。实例的个数用配置文件InstanceLimit.cfg指定。例如，如果InstanceLimit.cfg的内容为2，则LimitInstanceClass最多可以同时存在2个对象。LimitInstanceClass的对象有一个整型成员变量id，保存对象的编号；有一个boolean型变量isBusy，如果该变量的值为true，表示该对象正在被使用，否则该对象空闲。getInstance()方法判断是否存在空闲的对象，存在将该空闲对象的isBusy置为true，并返回该对象；如果不存在空闲对象则返回null。LimitInstanceClass有一个release()方法，该方法将对象的isBusy置为false。LimitInstanceClass还有一个String类型的成员变量accessMessage，以及一个成员方法writeAccessMessage(String message)，该方法将参数message追加到accessMessage。LimitInstanceClass的printAccessMessage()方法输出accessMessage的内容。 编写一个线程类AccessLimitInstanceClassThread，在其run()方法中获取一个LimitInstanceClass对象，调用获得的对象的writeAccessMessage(String message)将自己的线程名写入accessMessage，随机休眠0-5秒，再调用printAccessMessage()，最后调用release（）方法。 编写一个UseLimitInstanceClass类，在其main方法中实例化10个AccessLimitInstanceClassThread线程对象，并启动各个线程。 设置InstanceLimit.cfg的内容为3，写出你的程序的运行结果。
java单例模式代码
Mr_sheik的专栏
10-08 9141
单例模式，在程序运行期间只有一个实例存在。 简单单例模式
Java设计模式—单例模式（Singleton Pattern）
最新发布
白白白鲤鱼的博客
07-24 2012
Java设计模式—单例模式（Singleton Pattern）
java单例模式代码_java单例模式
weixin_34391934的博客
02-20 226
判断是否存在/*** 懒汉式*/public class LazySingleInstance {// 私有构造方法private LazySingleInstance(){};// 私有的类对象private static LazySingleInstance instance = null;// 缺点：// 1 每次都需要去判断instance 是否为空// 2 调用时才去new对象，响应比较...
java单例_java中的单例模式的代码怎么写
weixin_42356803的博客
02-12 220
展开全部我从我的博客里把我的文章粘贴过来吧，62616964757a686964616fe4b893e5b19e31333332633034对于单例模式模式应该有比较清楚的解释：单例模式在我们日常的项目中十分常见，当我们在项目中需要一个这样的一个对象，这个对象在内存中只能有一个实例，这时我们就需要用到单例。一般说来，单例模式通常有以下几种：1.饥汉式单例public class Singleton...
java单例模式代码实例
12-14
下面我们将深入探讨Java单例模式的实现方式、优缺点以及注意事项。 一、单例模式的实现方式 1. 饿汉式（静态常量） 这是最简单的单例实现，通过静态常量在类加载时就初始化单例，保证了线程安全，但同时也意味着...
java单例模式及实现
09-22
Java单例模式及实现 Java单例模式是一种常见的设计模式，确保某一个类只有一个实例，而且向这个系统提供这个实例。单例模式可以分为三种：懒汉式单例、饿汉式单例、登记式单例。 单例模式的要点 1. 某个类只能有...
Java单例模式实现静态内部类方法示例
08-29
"Java单例模式实现静态内部类方法示例" Java单例模式是软件设计模式中最基本和最常见的一种设计模式，也是最容易理解的一种设计模式。它的主要思想是确保某个类只有一个实例，并且提供一个全局访问点来访问该实例。...
单例模式Java实现
07-15
单例模式是最简单的一种设计模式，确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例， 本资源提供了用java语言实现简单的单例模式，供初学者参考
设计模式(一)—单例模式(附Java代码)
Xiong-er 的博客
01-24 2877
SessionFactory就够，这时就会使用到单例模式。
Java单例模式几种代码详解
weixin_65837469的博客
08-02 1253
在软件开发中，单例模式是一种常见的设计模式，它的目的是确保一个类在任何情况下都只有一个实例，同时提供一个全局访问点。在Java中，有几种常见的实现单例模式的方式，下面将逐一进行详细解释。以上是几种常见的实现单例模式的方式，每种方式都有各自的适用场景和优缺点。该方式通过加锁保证线程安全，但每次调用getInstance()方法时都会对方法加锁，可能会影响性能。该方式的优点是实现简单，但在多线程环境下可能会导致创建多个实例，因此不适用于多线程环境。该方式的优点是线程安全，但在单线程环境下可能会导致资源浪费。
Java 各种单例模式实现代码
weixin_40169609的博客
05-06 683
1.饿汉式 //线程安全 饿汉式 浪费空间 class HungryMan{ private HungryMan(){ System.out.println(Thread.currentThread().getName()); }; private final static HungryMan hungryMan=new HungryMan(); public static HungryMan getInstance(){ return hungryMan; } } 2.懒汉式
Java单例模式简单代码
Liam Liu的博客
05-04 1319
题目：请设计 AppConfig 类，并在 AppConfig 类中用 main 函数测试判断是否只有一个实例对 象。（提示：基于 static、private、构造函数使用单例模式） 代码： public class AppConfig { private int a; //检验是否为同一实例 private static AppConfig app=new AppConfig();//设置私有静态的初始化对象,使得通过getApp生成的对象是同
Java设计模式--单例模式（代码详解懒汉、饿汉模式）
rain67的博客
04-15 4387
文章目录设计模式-单例模式懒汉模式怎么解决线程安全问题？1.使用双重校验锁2.volatile 修饰实例对象，禁止指令重排序线程安全的懒汉模式饿汉模式 设计模式-单例模式 啥是单例模式？ 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 1.在类中就创建实例，只创建一个实例 2.类外如果想要调用这个对象必须调用getInstance方法获取实例，好处是减少了创建对象、销毁对象的开销 3.获取实例只能
单例模式代码实现
Len
09-25 3419
双检查锁机制（Double Check Locking）实现 public class Singleton { //使用 volatile 关键字保变量可见性 private volatile static Singleton instance = null; private Singleton(){} //私有化构造方法 public static Single...
java实现单例模式源代码_单例模式（java代码实现）
weixin_30595763的博客
02-25 180
应用单例模式时，类只能有一个对象实例，这么做的目的是避免不一致状态。饿汉式单例：(立即加载)// 饿汉式单例public class Singleton1 {// 指向自己实例的私有静态引用，主动创建private static Singleton1 singleton1 = new Singleton1();// 私有的构造方法private Singleton1(){}// 以自己实例为返回值...
给我一个java单例模式代码实现
04-01
以下是一个简单的Java单例模式代码实现： ``` public class MySingleton { private static MySingleton instance; private MySingleton() {} public static MySingleton getInstance() { if (instance == ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值