单例设计模式Java实现的八种写法以及反序列化、反射的破坏与防御

最新推荐文章于 2024-01-16 12:42:57 发布
最新推荐文章于 2024-01-16 12:42:57 发布
阅读量167 收藏 1
点赞数
分类专栏： Java设计模式 文章标签： 设计模式 java 多线程 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sun10367/article/details/108931481
版权

目录

单例设计模式概述

单例设计模式：保证一个类仅有一个实例，并且提供一个全局访问点。

所谓类的单例设计模式，就是采取一定的措施保证在整个的软件系统中，使某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造器的访问权限设置为 private ，这样，就不能用 new 操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。在类的外部一开始还无法获得类的对象，只能调用该类的某个静态方法以返回类内部创建的对象。静态方法只能访问类中的静态成员变量，所以，指向类内部创建的该类对象的变量也必须声明成静态的。

主要步骤

1）构造器私有化（防止在类的外部通过new创建该类对象)
2）在类的内部创建一个对象实例
3）对外提供一个公共的静态方法 getInstance()，返回实例对象

单例模式实现方案

1. 饿汉式（静态常量，线程安全）

饿汉式：类初始化时就创建类的对象完成实例化。

JVM在类初始化阶段（即在Class被加载后，且线程使用之前），会执行类的初始化。在执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。

class Singleton {
    //类的内部创建对象
    private final static Singleton INSTANCE = new Singleton();

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public class SingletonTest1 {
    public static void main(String[] args) {
        Singleton instance1 = Singleton.getInstance();
        Singleton instance2 = Singleton.getInstance();
        System.out.println(instance1 == instance2);
    }
}

运行结果：

true

优缺点说明

1）优点：写法简单，在类初始化时就完成实例化，避免了线程同步问题，JVM保证线程安全
2）缺点：在类初始化时就完成实例化，没有达到延迟加载的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费
3）这种方式基于类的初始化机制，避免了多线程的同步问题，不过，instance 在类初始化时就完成实例化，在单例模式中大多数都是调用getInstance()方法，但是导致类初始化的原因有很多种，因此不能确定有其他的方式（或者调用类的其他静态方法）导致类初始化，这时实例化 instance 就没有达到延迟加载的效果
4）结论：可用，但可能造成内存浪费

2. 饿汉式（静态代码块，线程安全）

将上面创建对象的步骤放入静态代码块中

class Singleton {
    private final static Singleton INSTANCE;

    //在静态代码块中创建对象
    static {
        INSTANCE = new Singleton();
    }

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

优缺点说明

1）这种方式和上面的方式类似，只不过将类实例化的过程放在了静态代码块中，也是在类初始化的时候，就执行静态代码块中的代码，初始化类的实例。优缺点和上面方式是一样的。
2）结论：可用，但可能造成内存浪费

3. 懒汉式（线程不安全）

懒汉式：延迟加载，真正使用到对象时（调用 getInstance() 方法）才去创建。在Java程序中，有时候可能需要推迟一些高开销对象的实例化操作，并且只有在使用这些对象的时候才实例化，此时，程序员可能会采用延迟实例化。

class Singleton {
    private static Singleton instance;

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，当需要使用到该类的对象时才去创建
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明

1）起到了延迟加载的效果，但是只能在单线程下使用。
2）如果在多线程下，一个线程进入了 if (singleton == null) 判断语句块，还未来得及往下执行，如果另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。
3）结论：不要使用

4. 懒汉式（同步方法，线程安全，但性能差）

在 getInstance() 方法声明加上 synchronized 关键字，保证线程安全。同一时刻只能有一个线程进入同步方法执行。

class Singleton {
    private static Singleton instance;

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，当需要使用到该类的对象时才去创建
    //使用synchronized关键字修饰getInstance()方法保证线程安全
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优缺点说明

1）保证了线程安全
2）效率太低了，每个线程在想获得类的实例时，执行getInstance()方法都要进行同步操作，频繁的加锁、释放锁需要消耗资源，使用synchronized关键字是一种重量级的同步机制，开销庞大、效率低。而其实这个方法只执行一次实例化代码就够了，如果对象已经创建，直接返回已创建的对象就行了，无需执行同步操作
3）结论：在实际开发中，不推荐使用这种方式

5. 懒汉式（同步代码块，但并不能保证线程安全）

同一时刻只能有一个线程进入同步代码块执行

class Singleton {
    private static Singleton instance;

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，当需要使用到该类的对象时才去创建
    public static Singleton getInstance() {
        if (instance == null) {
            //可能有多个线程通过if判断
            synchronized(Singleton.class) {
                instance = new Singleton();
            }
        }
        return instance;
    }
}

优缺点说明

1）这种方式，本意是想对第四种实现方式改进，因为同步方法效率太低， 改为同步产生实例化的代码块
2）但是这种同步并不能保证线程安全，跟第3种实现方式遇到的情形一 致，假如一个线程进入了 if (singleton == null) 判断语句块， 还未来得及往下执行，另一个线程也通过了这条判断语句，同步代码块就会被多次执行，这时便会产生多实例
3）结论：不能使用

6. 懒汉式（双重检查加锁，线程安全）

getInstance()方法进行两次if (singleton == null)判断，同一时刻只能有一个线程进入同步代码块执行，在同步代码块中再加一层if (singleton == null)判断

class Singleton {
    private static volatile Singleton instance;

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，当需要使用到该类的对象时才去创建
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

单例的引用需要用volatile关键字修饰，volatile关键字的作用：

禁止指令重排序

实际上创建对象要经过如下3个步骤：

1）分配对象所需的内存空间
2）初始化对象
3）设置 instance 变量指向刚分配的内存地址
在这里插入图片描述
2）和 3）的顺序可能会被重排序，在单线程下，访问对象是不受影响的；但在多线程下，可能会发生问题，访问一个没有初始化完成的对象操作其内部数据时，可能会抛出空指针异常。使用volatile关键字修饰可以禁止重排序，防止第3步先于第2步执行。
在这里插入图片描述
保证内存可见性

由于可见性问题，线程0创建了实例，且变量instance还未同步到主存中；此时线程1从主存中拿到的instance变量还是null
如果加上了volatile修饰instance之后，保证了内存可见性，一旦线程0返回了实例，线程1可以立即发现instance不为null（主要用在第一层if判断，同步代码块在第二层if判断就可以保证内存可见性）。

优缺点说明

1）进行了两次if (singleton == null)检查，可以保证线程安全
2）实例化代码只执行一次，后面再次访问时，判断if (singleton == null)，直接返回已实例化对象，也避免反复进行方法同步
3）线程安全，延迟加载，效率较高
4）结论：推荐使用

7. 静态内部类（线程安全）

class Singleton {
    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //静态内部类定义静态属性，调用构造器，基于类初始化
    private static class SingletonInnerClass {
        private final static Singleton INSTANCE = new Singleton();
    }

    //对外提供一个公共的静态方法 getInstance()，返回静态内部类中创建的单例对象
    public static Singleton getInstance() {
        return SingletonInnerClass.INSTANCE;
    }
}

优缺点说明

1）一个类只会被类加载器加载一次，JVM保证线程安全

2）装载外部类Singleton并不会导致内部类SingletonInnerClass的装载，调用getInstance方法访问静态属性时会装载内部类，从而完成Singleton的实例化
3）优点：避免了线程不安全，利用静态内部类特点实现延迟加载，效率高
4）结论：推荐使用

8. 枚举（线程安全）

利用枚举的实例是有限个数的特性实现单例模式，如果我们只定义一个实例就相当于是单例了。

enum  Singleton {
    //单例对象
    INSTANCE;

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }
	//其他方法
    public void method() {
        System.out.println("方法执行了...");
    }
}

优缺点说明

1）借助JDK1.5 中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止通过反射、反序列化重新创建新的对象。
2）结论：推荐使用

反序列化破坏单例模式及解决方案

反序列化破坏饿汉式单例，让单例类实现Serializable接口：

package demo1;

import java.io.*;

class Singleton implements Serializable {
    //类的内部创建对象
    private final static Singleton INSTANCE = new Singleton();

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public class SingletonTest1 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //获取单例对象
        Singleton instance = Singleton.getInstance();
        //创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        //将单例对象写入文件中
        oos.writeObject(instance);
        //创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton_file"));
        //从文件中读取对象
        Singleton newInstance = (Singleton) ois.readObject();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }
}

运行结果：

demo1.Singleton@14ae5a5
demo1.Singleton@6d03e736
false

解决方案：

在单例类Singleton中添加一个readResolve()方法：

private Object readResolve() {
    return INSTANCE;
}

调用readObject()方法会查找单例类一个方法名为 readResolve 的方法，若存在方法名为 readResolve 的方法，则执行该方法，在该方法中返回单例类中创建的单例对象，从而保证从单例类中获取的对象和通过反序列化获取的是同一个对象。

通过测试发现前7种方案均不能防反序列化重新创建新的对象。

反序列化破坏枚举单例：

package demo8;

import java.io.*;

enum  Singleton {
    INSTANCE;

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }

    public void method() {
        System.out.println("方法执行了...");
    }
}

public class SingletonTest8 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //获取单例对象
        Singleton instance = Singleton.getInstance();
        //创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file"));
        //将单例对象写入文件中
        oos.writeObject(instance);
        //创建反序列化流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton_file"));
        //从文件中读取对象
        Singleton newInstance = (Singleton) ois.readObject();
        
        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }
}

运行结果：

INSTANCE
INSTANCE
true

调用readObject()方法若发现单例类型是枚举，则返回枚举中已存在的枚举对象，因此枚举单例能够防反序列化重新创建新的对象。

反射破坏单例模式及解决方案

前7种方案均不能防反射重新创建新的对象

在类加载初始化时就已创建好单例对象的单例模式：

以饿汉式单例为例：

package demo1;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class Singleton {
    //类的内部创建对象
    private final static Singleton INSTANCE = new Singleton();

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {}

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

public class SingletonTest1 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //正常获取单例对象
        Singleton instance = Singleton.getInstance();
        
        //获取单例类的Class对象
        Class<Singleton> clazz = Singleton.class;
        //获取单例类的私有无参构造器
        Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
        //放开构造器对象的访问权限
        constructor.setAccessible(true);
        //反射创建单例实例
        Singleton newInstance = constructor.newInstance();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }
}

运行结果：

demo7.Singleton@1b6d3586
demo7.Singleton@4554617c
false

解决方案：

在构造器中加上处理逻辑，只针对在类加载初始化时就已经创建好单例对象的单例模式有效，即饿汉式和基于静态内部类实现的懒加载单例模式有效，对其他懒加载实现方式无效

例如：若已存在单例对象，则直接抛出异常：

private Singleton() {
    if (INSTANCE != null) {
        throw new RuntimeException("单例构造器禁止反射调用");
    }
}

将main方法首行获取单例对象的代码放在反射创建单例对象代码的后面，上面的解决方案仍然生效，程序抛出异常。

对于不是在类加载初始化时就已创建好单例对象的单例模式是无法避免的：

以双重检查加锁单例模式为例：

package demo6;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class Singleton {

    private static volatile Singleton instance;

    //构造器私有化（防止外部通过new创建对象)
    private Singleton() {
        if (instance != null) {
            throw new RuntimeException("单例构造器禁止反射调用");
        }
    }

    //对外提供一个公共的静态方法 getInstance()，当需要使用到该类的对象时才去创建
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class SingletonTest6 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {

        //获取单例类的Class对象
        Class<Singleton> clazz = Singleton.class;
        //获取单例类的私有无参构造器
        Constructor<Singleton> constructor = clazz.getDeclaredConstructor();
        //放开构造器对象的访问权限
        constructor.setAccessible(true);
        //反射创建单例实例
        Singleton newInstance = constructor.newInstance();
        Singleton newInstance2 = constructor.newInstance();

        //正常获取单例对象
        Singleton instance = Singleton.getInstance();
        System.out.println(instance);

        System.out.println(newInstance);
        System.out.println(newInstance2);
        System.out.println(instance == newInstance);
        System.out.println(newInstance2 == newInstance);
    }
}

运行结果：

demo6.Singleton@1b6d3586
demo6.Singleton@4554617c
demo6.Singleton@74a14482
false
false

反射破坏枚举单例：

package demo8;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

enum  Singleton {
    INSTANCE;

    //对外提供一个公共的静态方法 getInstance()，返回实例对象
    public static Singleton getInstance() {
        return INSTANCE;
    }

    public void method() {
        System.out.println("方法执行了...");
    }
}

public class SingletonTest8 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class<Singleton> clazz = Singleton.class;
        /*Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : declaredConstructors) {
            System.out.println("构造方法：" + constructor); //构造方法：private demo8.Singleton(java.lang.String,int)
        }*/
        Constructor<Singleton> declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);
        declaredConstructor.setAccessible(true);
        Singleton instance = declaredConstructor.newInstance("instance", 0);
        System.out.println(instance);
    }
}

反射创建单例对象失败，程序抛出异常：

Exception in thread “main” java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at demo8.SingletonTest8.main(SingletonTest8.java:53)

Constructor类的newInstance方法中有这样一段代码：

if ((clazz.getModifiers() & Modifier.ENUM) != 0)
    throw new IllegalArgumentException("Cannot reflectively create enum objects");

当单例类型是枚举时，直接抛出 IllegalArgumentException，因此枚举单例能够防反射重新创建新的对象

单例模式在JDK中的应用

例如：JDK 中，java.lang.Runtime类 就是经典的单例模式（饿汉式）

public class Runtime {
    private static Runtime currentRuntime = new Runtime();

    public static Runtime getRuntime() {
        return currentRuntime;
    }

    private Runtime() {}
    
    //其他方法
    ...
}
ixcoret
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java设计模式之单例模式的七种写法
07-13
Java设计模式之单例模式的七种写法 单例模式是一种常见的设计模式，它确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机的驱动程序对象常...
Java：单例模式的七种写法
12-22
免线程同步问题，而且还能防止反序列化重新创建新的对象，绝对的线程安全，同时也能保证单例的唯一性。枚举在Java中是一个特殊的语法结构，它天然支持单例模式，INSTANCE是Singleton枚举类型下的一个元素，相当于...
单例模式及其序列化/反序列化
xuerhu85的博客
02-26 207
为了使一个单例类变成可串行化的，仅仅在声明中添加“implements Serializable”是不够的。因为一个串行化的对象在每次返串行化的时候，都会创建一个新的对象，而不仅仅是一个对原有对象的引用。为了防止这种情况，可以在单例类中加入readResolve 方法。 下面我们先简要地回顾下对象的序列化. 一般来说, 一个类实现了 Serializable接口,...
设计模式：一文搞定单例模式（防止反射、反序列化、clone破坏单例）Singleton Pattern-Java版
m0_50654102的博客
08-09 245
一、定义 单例模式，顾名思义，就是一个类从始至终只产生一个对象。现实生活中的例子有很多，比如在太阳系考虑问题，那么太阳和地球都可称为单例，再比如工具类，有时候没有把所有方法用static修饰（这不是个好办法），就应该把它做成单例，因为它没有不变的状态。 二、五种单例模式：饿汉式、懒汉式、双重检查锁、静态内部类、枚举 (一) 饿汉式，加载类时马上创建对象 /** * 饿汉式 * 优点：线程安全、效率高 * 缺点：不能做到“即用即创建”,有可能浪费内存资源 */ public class Singlet
单例模式的反序列化总结
weixin_34255793的博客
07-01 137
2019独角兽企业重金招聘Python工程师标准>>> ...
Java多线程 单例模式防止被反序列化破坏的处理方式
qq_20156289的博客
08-24 1004
Java单例模式（解决反射攻击，反序列化攻击）
weixin_45679480的博客
11-27 615
单例模式 什么是单例模式 单例模式就是确保类的实例对象只能有一个，类本身要实例化好这个对象提供给其他所有的类访问。单例模式就是为了避免状态不一致。 单例模式特定 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 单例模式四大原则 1、构造私有 2、以静态方法或者枚举返回实例 3、确保实例只有一个，尤其是多线程环境 4、确保反序列换时不会重新构建对象 实现单例模式的方式 饿汉式（立即加载） 就是在类加载是就创建一个静态对象私有的对象实例，来提供给外部使用，除非
java-单例模式几种写法
11-29
单例模式是软件设计模式中的一种，用于控制类的实例化过程，确保一个类只有一个实例，并提供全局访问点。在Java中，实现单例模式有多种方法，每种方法都有其特点和适用场景。以下是对这六种常见单例模式实现方式的...
Java版的7种单例模式写法示例
08-25
单例模式是软件设计模式中的一种，它的核心思想是确保一个类只有一个实例，并提供一个全局访问点。在Java中，由于语言特性，实现单例模式有多种方式，每种方式都有其优缺点。以下是Java中7种常见的单例模式实现方式...
Java设计模式单例模式(Singleton)用法解析
08-25
java设计模式单例模式（Singleton）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局反访问点。单例模式是创建型模式。单例模式在生活中应用也很广泛，比如公司CEO只有一个，部门经理只有一个等。...
9.Java设计模式-创建型模式-单例模式-反序列化对单例的破坏
最新发布
Runnin_Athena的博客
01-16 1037
Java设计模式-创建型模式-单例模式-反序列化对单例的破坏
单例模式(防止反序列化破解单例模式)
qq_35289343的博客
11-15 491
public class Client2 {     public static void main(String[] args) throws Exception {         //通过反序列化的方式构造多个对象         LazySingletonVSSyn ls1 = LazySingletonVSSyn.getInstance();         LazySingletonV...
设计模式|单例模式（2） 单例模式下反序列化和反射带来的安全问题
dsdj
10-28 205
接上篇 单例模式（1） 序列化破坏单例模式 饿汉式的单例类 public class HungarySingleton { private final static HungarySingleton hungarySingleton = new HungarySingleton(); private HungarySingleton(){ } ...
单例模式，防止反射和反序列化漏洞
ＺＥＥＧＡＴＥＳ的博客
07-30 961
一、懒汉式单例模式，解决反射和反序列化漏洞   package com.iter.devbox.singleton;   import java.io.ObjectStreamException; import java.io.Serializable;   /** * 懒汉式（如何防止反射和反序列化漏洞） * @author Sh...
别写错了，你知道如何防止 反射 和 序列化 破坏单例模式吗？
Java笔记虾
04-04 202
点击关注公众号，利用碎片时间学习反射破坏单例单例模式一般构造方法都是private，目的就是为了防止外界调用私有构造器创建多个实例，通过一个public的共有方法作为外界获取实例的唯一入口，从而实现单例。但是反射能够访问私有的构造方法，只要反射获取的构造器调用setAccessible(true)方法即可。这样调用一次就会产生一个实例，调用多次就时多个实例，从而破坏单例。...
单例模式（防止反序列化恢复对象）
flyingnet的博客
12-09 194
/** * 单例模式之防止利用反序列化恢复java对象 **/ public class Singleton implements Serializable{ private static Singleton instance; private String name; private Singleton(String name){ System.out.println("调用有参数的构造器"); this.name = name; }.
设计模式-单例模式(包括反射和序列化的影响和解决方法)
Jwasx的博客
01-22 607
文章目录前言1. 单例模式的介绍 前言 在之前写过一篇java单例模式的文章，只是简单介绍两种懒汉式和饿汉式的单例，因此在这里重新写一次单例模式，本篇文章基于菜鸟教程的单例模式，会介绍其中的6中单例模式，并且会涉及到多线程情况下的并发问题 1. 单例模式的介绍 ...
单例模式实现及防止反射与序列化
Better_YZQ的博客
07-19 798
单例模式 模式动机 对于系统中的某些类来说，只有一个实例很重要，如一个系统中只有一个计时工具和 ID（序号）生成器。 单例模式适用情况包括：系统只需要一个实例对象；客户调用类的单个实例只允许使用一个公共访问点。 定义 顾名思义，用来保证一个对象只能创建一个实例，除此之外，它还提供了对实例的全局访问方法。 单例模式的要点有三个：一是类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。 实现 为了确保单例实例的唯一性，所有的 单例构造器都要被声明为私有 的，再通过声明 静态方法实
单例的获取and序列化和反序列化破坏单例的原因及解决方法
chy6575的博客
04-05 2370
单例模式就是在整个全局中（无论是单线程还是多线程），该对象只存在一个实例，而且只应该存在一个实例，没有副本（副本的制作需要花时间和空间资源）。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，同时该对象需要协调系统整体的行为，单例模式是最好的解决方案。单
Java语言程序设计：ch05 泛型、枚举与for语句的简化写法.ppt
06-17
Java语言程序设计：泛型、枚举与for语句的简化写法 本节课程主要介绍Java语言程序设计中的泛型、枚举与for语句的简化写法。泛型是Java语言程序设计中的一种机制，可以提高程序代码的复用性，减少数据的类型转换，以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值