单例模式在多线程下的情况

2024-07-14 01:32| 来源: 网络整理| 查看: 265

单例模式在多线程下的情况介绍一下单例模式

概念：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。其实就是指保证一个类只能有一个实例，并且要提供一个访问它的全局访问点，它的主要目的就是为了防止一个全局使用的类被频繁的创建和销毁，这样也可以节省很多的系统资源。

特点：

单例类只能有一个实例单例类必须自己创建自己的唯一实例单例类必须给所有其他对象提供这一实例

优点：

在内存中只存在一个实例，这样减少了内存的开销，尤其是类被频繁的创建和销毁会导致缓存占用内存过多，影响效率。避免对资源的多重占用（比如写文件的操作）。

缺点：

没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

使用场景：

要求生产唯一序列号。WEB 中的计数器，不用每次刷新都在数据库里加一次，用单例先缓存起来创建的一个对象需要消耗的资源过多，比如 I/O 与数据库的连接等。单例模式的实现方式饿汉式：

实现代码：

package com.czu.single; /** * 饿汉式单例 * @author 87682 */ public class Hungry { /** * 可能会浪费空间 */ private byte[] data1 = new byte[1024*1024]; private byte[] data2 = new byte[1024*1024]; private byte[] data3 = new byte[1024*1024]; private byte[] data4 = new byte[1024*1024]; private Hungry(){ } private final static Hungry HUNGRY = new Hungry(); public static Hungry getInstance(){ return HUNGRY; } }

这种方法的弊端在注释里面也写了，就是会浪费很多内存空间，虽然也能实现线程安全，不必加锁，执行效率高，但是在类被加载的时候会不断的初始化，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

懒汉式：

实现代码：

package com.czu.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; /** * 懒汉式单例模式 * * @author 87682 */ public class LazyMan { private static boolean qinjiang = false; private LazyMan() { synchronized (LazyMan.class) { if (qinjiang == false) { qinjiang = true; } else { throw new RuntimeException("不要试图使用反射破坏异常"); } } } private volatile static LazyMan lazyMan; /** * 双重检测锁模式的懒汉式单例，简称为DCL懒汉式 * * @return */ public static LazyMan getInstance() { if (lazyMan == null) { synchronized (LazyMan.class) { if (lazyMan == null) { //不是一个原子性操作 lazyMan = new LazyMan(); /** * 1. 分配内存空间 * 2. 执行构造方法，初始化对象 * 3. 把这个对象指向这个空间 */ } } } return lazyMan; } // /** // * 多线程并发 // */ // public static void main(String[] args) { // for (int i = 0; i < 10; i++) { // new Thread(()->{ // LazyMan.getInstance(); // }).start(); // } // } /** * 反射 */ public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { //LazyMan instance = LazyMan.getInstance(); Constructor declaredConstructor = LazyMan.class.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); LazyMan instance = declaredConstructor.newInstance(); LazyMan instance2 = declaredConstructor.newInstance(); System.out.println(instance); System.out.println(instance2); } }

代码中也提到了，如果有人利用反射类加载的方式，或者说反编译的方式去恶意加载类，会导致很多不安全的问题，在普通的懒汉式单例模式中，线程是不安全的，所以我们需要使用双重检测锁模式的懒汉式单例来解决问题，由于实例不能保持原子性，所以会导致指令重排的现象，于是我们会添加volatile关键字来保证原子性，这样既保证原子性又不会造成线程不安全的现象。

静态内部类方式实现单例模式：

实现代码：

package com.czu.single; /** * 静态内部类 * @author 87682 */ public class Holder { private Holder(){ } public static Holder getInstance(){ return InnerClass.HOLDER; } public static class InnerClass{ private static final Holder HOLDER = new Holder(); } }

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程。它跟懒汉式不同的是：懒汉式只要单例类被装载了，那么 instance 就会被实例化（没有达到 lazy loading 效果），而这种方式是单例类类被装载了，instance 不一定被初始化。因为 Holder类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 Holder类，从而实例化 instance。想象一下，如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在单例类类加载时就实例化，因为不能确保单例类类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比懒汉式就显得很合理。

枚举式单例模式： package com.czu.single; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; /** * enum 是一个什么？本身也是一个Class类 * @author 87682 */ public enum EnumSingle { /** * */ INSTANCE; public EnumSingle getInstance(){ return INSTANCE; } } class Test{ public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { EnumSingle instance1 = EnumSingle.INSTANCE; Constructor declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); declaredConstructor.setAccessible(true); EnumSingle instance2 = declaredConstructor.newInstance(); //java.lang.NoSuchMethodException: com.czu.single.EnumSingle.() System.out.println(instance1); System.out.println(instance2); } }

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还自动支持序列化机制，防止反序列化重新创建新的对象，绝对防止多次实例化。不过，由于 JDK1.5 之后才加入 enum 特性，用这种方式写不免让人感觉生疏，在实际工作中，也很少用。不能通过 reflection attack 来调用私有构造方法（用来防止别人用反编译的方式恶意破坏），同时也能保证线程安全。

【本文地址】

单例模式在多线程下的情况

单例模式在多线程下的情况

今日新闻

推荐新闻