欢迎访问悦橙教程（wld5.com），关注java教程。悦橙教程  java问答|  每日更新
页面导航 : > > 文章正文

Java23种设计模式中的单例模式你了解吗，

来源： javaer 分享于  点击 49943 次 点评：258

Java23种设计模式中的单例模式你了解吗，


目录
  • 1、定义
  • 2、适用场景
  • 3、常见写法
  • 4、如何防止单例被破坏
    • 1.多线程破坏单例以及解决方法
    • 2.反射破坏单例以及解决方法
    • 3.序列化破坏单例以及解决方法
  • 5、优缺点
    • 6、总结

      1、定义

      单例模式(Singleton Pattern)是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。
      隐藏其所有的构造方法。
      属于创建型模式。

      2、适用场景

      确保任何情况下都绝对只有一个实例。

      3、常见写法

      第一种：饿汉式单例：在单例类首次加载时就创建实例

      /**
 * @Package: com.hzg.study.design.pattern.singleton.hungry
 * @Description: 饿汉式单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:15
 */
public class HungrySingleton {
    private static final HungrySingleton INSTANCE = new HungrySingleton();
    /**
     * 私有化构造器
     */
    private HungrySingleton() {
    }
    /**
     * 全局访问点
     */
    public static HungrySingleton getInstance() {
        return INSTANCE;
    }
}

      饿汉式单例静态代码块写法：

      /**
 * @Package: com.hzg.study.design.pattern.singleton.hungry
 * @Description: 饿汉式单例(静态代码块初始化)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:15
 */
public class HungryStaticSingleton {
    private static final HungryStaticSingleton INSTANCE;
    /**
     * 静态代码块
     */
    static {
        INSTANCE = new HungryStaticSingleton();
    }
    /**
     * 私有化构造器
     */
    private HungryStaticSingleton() {
    }
    /**
     * 全局访问点
     */
    public static HungryStaticSingleton getInstance() {
        return INSTANCE;
    }
}

      第二种：懒汉式单例：被外部类调用时才创建实例

      /**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:24
 */
public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazySingleton() {
    }
    /**
     * 全局访问点
     */
    public static LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

      懒汉式单例静态匿名内部类写法(性能最优)：

      /**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例(匿名静态内部类)(性能最优)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 18:00
 */
public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

      第三种：注册式单例：将每一个实例都缓存到统一的容器中，使用唯一标识获取实例

      注册式单例枚举写法：

      /**
 * @Package: com.hzg.study.design.pattern.singleton.registry
 * @Description: 注册式单例-枚举单例
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 10:24
 */
public enum EnumSingleton {
    INSTANCE;
    /**
     * 如果需要让其他对象成为单例，只需要将data改为目标类对象即可
     * <p/>
     * 通过getter和setter操作
     */
    private Object data;
    public Object getData() {
        return data;
    }
    public void setData(Object data) {
        this.data = data;
    }
    public static EnumSingleton getInstance() {
        return INSTANCE;
    }
}

      Spring中常见的注册式单例写法：

      /**
 * @Package: com.hzg.study.design.pattern.singleton.registry
 * @Description: Spring中常见的注册式单例写法
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 10:54
 */
public class ContainerSingleton {
    /**
     * spring ioc
     */
    private static Map<String, Object> container = new ConcurrentHashMap<>();
    private ContainerSingleton() {
    }
    public static Object getBean(String clazzName) {
        // 加synchronized代码块保证线程安全
        synchronized (container) {
            if (!container.containsKey(clazzName)) {
                Object object = null;
                try {
                    object = Class.forName(clazzName).newInstance();
                    container.put(clazzName, object);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return object;
            }
            return container.get(clazzName);
        }
    }
}

      第四种：ThreadLocal线程单例：保证线程内部的全局唯一，且天生线程安全

      /**
 * @Package: com.hzg.study.design.pattern.singleton.threadlocal
 * @Description: ThreadLocal线程单例(伪安全)
 * @Description: 可以使用ThreadLocal动态切换数据源
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-21 11:10
 */
public class ThreadLocalSingleton {
    public static final ThreadLocal<ThreadLocalSingleton> THREAD_LOCAL = new ThreadLocal<ThreadLocalSingleton>() {
        @Override
        protected ThreadLocalSingleton initialValue() {
            return new ThreadLocalSingleton();
        }
    };
    private ThreadLocalSingleton() {
    }
    public static ThreadLocalSingleton getInstance() {
        return THREAD_LOCAL.get();
    }
}

      4、如何防止单例被破坏

      1.多线程破坏单例以及解决方法

      以懒汉式单例LazySingleton为例：

      首先写一个线程实现类，如下：

      import com.hzg.study.design.pattern.singleton.lazy.LazySingleton;
/**
 * @Package: com.hzg.study.design.pattern.singleton.lazy.test
 * @Description:
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 16:32
 */
public class ExecutorThread implements Runnable {
    @Override
    public void run() {
        LazySingleton instance = LazySingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + instance);
    }
}

      main方法测试：

      public class LazySingletonTest {
    public static void main(String[] args) {
        Thread thread1 = new Thread(new ExecutorThread());
        thread1.start();
        Thread thread2 = new Thread(new ExecutorThread());
        thread2.start();
        System.out.println("----------------------------------------");
    }
}

      测试结果：显然出现了两个不同的实例

      解决方法1：加synchronized关键字修饰getInstance方法

      public class LazySingleton {
    private static LazySingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazySingleton() {
    }
    /**
     * 全局访问点
     * <p/>
     * synchronized关键字修饰方法
     */
    public static synchronized LazySingleton getInstance() {
        if (INSTANCE == null) {
            INSTANCE = new LazySingleton();
        }
        return INSTANCE;
    }
}

      解决方法2：双重检查锁DoubleCheck

      /**
 * @Package: com.hzg.study.design.pattern.singleton.lazy
 * @Description: 懒汉式单例(双重检查锁)
 * @Author: HuangZhiGao
 * @CreateDate: 2022-02-18 17:08
 */
public class LazyDoubleCheckSingleton {
    /**
     * volatile关键字修饰，避免指令重排序引发问题
     */
    private volatile static LazyDoubleCheckSingleton INSTANCE = null;
    /**
     * 私有化构造器
     */
    private LazyDoubleCheckSingleton() {
    }
    /**
     * 全局访问点
     * <p/>
     * 双重检查锁
     */
    public static LazyDoubleCheckSingleton getInstance() {
        if (INSTANCE == null) {
            synchronized (LazyDoubleCheckSingleton.class) {
                if (INSTANCE == null) {
                    INSTANCE = new LazyDoubleCheckSingleton();
                }
            }
        }
        return INSTANCE;
    }
}

      2.反射破坏单例以及解决方法

      以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：

      main方法测试：

      public class LazyInnerClazzSingletonTest {
    public static void main(String[] args) {
        try {
            Class<LazyInnerClazzSingleton> aClazz = LazyInnerClazzSingleton.class;
            Constructor<LazyInnerClazzSingleton> declaredConstructor = aClazz.getDeclaredConstructor(null);
            declaredConstructor.setAccessible(true);
            LazyInnerClazzSingleton instance1 = declaredConstructor.newInstance();
            LazyInnerClazzSingleton instance2 = LazyInnerClazzSingleton.getInstance();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

      测试结果：构建了两个不同的实例

      解决方法：在构造器中增加如下if判断

      public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
}

      再次测试：

      3.序列化破坏单例以及解决方法

      以懒汉式单例静态匿名内部类写法LazyInnerClazzSingleton为例：注意必须先实现序列化接口Serializable

      main方法测试：

          public static void main(String[] args) {
        LazyInnerClazzSingleton instance1 = LazyInnerClazzSingleton.getInstance();
        LazyInnerClazzSingleton instance2 = null;
        try (
                FileOutputStream fileOutputStream = new FileOutputStream("LazyInnerClazzSingleton.obj");
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
                FileInputStream fileInputStream = new FileInputStream("LazyInnerClazzSingleton.obj");
                ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
        ) {
            // 序列化
            objectOutputStream.writeObject(instance1);
            objectOutputStream.flush();
            // 反序列化
            instance2 = (LazyInnerClazzSingleton) objectInputStream.readObject();
            System.out.println(instance1);
            System.out.println(instance2);
            System.out.println(instance1 == instance2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

      测试结果：构建了两个不同的实例

      解决方法：新增readResolve方法

      public class LazyInnerClazzSingleton implements Serializable {
    /**
     * 私有化构造器
     */
    private LazyInnerClazzSingleton() {
        if (null != LazyHolder.INSTANCE) {
            throw new RuntimeException("不允许构建多个实例");
        }
    }
    /**
     * 全局访问点
     */
    public static final LazyInnerClazzSingleton getInstance() {
        return LazyHolder.INSTANCE;
    }
    private static class LazyHolder {
        private static final LazyInnerClazzSingleton INSTANCE = new LazyInnerClazzSingleton();
    }
    /**
     * 重写readResolve方法，实际还是创建了两次，只不过是覆盖了反序列化出来的对象，之前反序列化出来的对象会被GC回收
     * 发生在JVM层面，相对来说比较安全
     */
    private Object readResolve() {
        return LazyHolder.INSTANCE;
    }
}

      5、优缺点

      优点：

      在内存中只有一个实例，减少了内存开销。
      可以避免对资源的多重占用。
      设置全局访问点，严格控制访问。

      缺点：

      没有接口，扩展困难。
      如果要扩展单例对象，只有修改代码，没有其他途径。
      不符合开闭原则

      6、总结

      1、私有化构造器

      2、保证线程安全

      3、延迟加载

      4、防止序列化和反序列化破坏单例

      5、防御反射攻击单例

      本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注3672js教程的更多内容!  

      您可能感兴趣的文章:
      • java编程创建型设计模式单例模式的七种示例
      • JAVA设计模式之单例模式详解
      • Java设计模式之单例模式示例详解
      • 深入理解Java设计模式之单例模式
      • JAVA设计模式零基础解析之单例模式的八种方式
      • Java设计模式之单例模式

      相关文章

      相关栏目：

      相关文章

      用户点评