设计模式之(四):单例设计模式

发表于   |   分类于 左手代码 java   |   阅读(120)   |   评论(91)

一.什么是单例模式

1.什么是单例模式

单例模式就是一个类对外只有一个实例

2.场景
  • 实例化类需要消耗很多的资源
  • 该类只能实例化一次，对外是唯一的对象
3.表现形式:
  • 构造方法是私有的，即外部是无法实例化该类的
  • 有一个保存当前实例的私有静态变量
  • 有一个对外开放的访问该类对象的方法
4.单例的线程安全性检测

通过多线程调用单例的获取实例的方法，检查每次的实例是否相同

二.单例模式的实现方式

1.饿汉式(线程安全)

(1)特点:

  • 在类加载的时候就实例化类(感觉很饿一样，饭一到就直接吃)

(2)实例：

  1. /**
  2. * 饿汉式单例模式
  3. */
  4. public class HungrySingleton {
  5.     /**
  6.      * 在类加载时就实例化
  7.      */
  8.     private static final HungrySingleton INSTANCE = new HungrySingleton();
  10.     /**
  11.      * 构造方法外对私有
  12.      */
  13.     private HungrySingleton() {
  15.     }
  17.     /**
  18.      * 对外开放的访问实例对象的方法
  19.      */
  20.     public static HungrySingleton getInstance() {
  21.         return INSTANCE;
  22.     }
  23. }

测试代码

  1. class HungrySingletonRunnable implements Runnable {
  3.     @Override
  4.     public void run() {
  5.         System.out.println( HungrySingleton.getInstance());
  6.     }
  7. }
  9. /**
  10.  * 饿汉式测试
  11.  * @author shixinke
  12.  */
  13. public class HungrySingletonTest {
  15.     public static void main(String[] args) {
  16.         new Thread(new HungrySingletonRunnable()).start();
  17.         new Thread(new HungrySingletonRunnable()).start();
  18.         new Thread(new HungrySingletonRunnable()).start();
  19.     }
  20. }

打印结果：

  1. com.shixinke.practise.design.pattern.creation.singleton.HungrySingleton@5eacd0a4
  2. com.shixinke.practise.design.pattern.creation.singleton.HungrySingleton@5eacd0a4
  3. com.shixinke.practise.design.pattern.creation.singleton.HungrySingleton@5eacd0a4

(3)优点

  • 是线程安全的

注：JVM保证一个类只会被加载一次，因为它在类加载时就被实例化，因此可以保证它只被实例化一次

(4)缺点

  • 加载类时就初始化，会立即占用内存空间，如果不使用它，会造成资源浪费，对整个程序加载速度有一定影响
2.懒汉式

(1)特点：

在使用时，才实例化，就延迟加载的感觉(感觉它比较懒，不用它，它就不干活)

(2)实例

  1. /**
  2.  * 懒汉式
  3.  * @author shixinke
  4.  */
  5. public class LazySingleton {
  6.     /**
  7.      * 先不初始化
  8.      */
  9.     private static LazySingleton INSTANCE;
  11.     private LazySingleton() {
  13.     }
  15.     /**
  16.      * 在使用时初始化
  17.      * @return
  18.      */
  19.     public static LazySingleton getInstance() {
  20.         /**
  21.          * 如果当前实例不存在，则new一个
  22.          */
  23.         if (INSTANCE == null) {
  24.             INSTANCE = new LazySingleton();
  25.         }
  26.         return INSTANCE;
  27.     }
  29. }

测试代码:

  1. class LazyRunnable implements Runnable {
  3.     @Override
  4.     public void run() {
  5.         System.out.println(LazySingleton.getInstance());
  6.     }
  7. }
  9. /**
  10.  * 懒汉式测试
  11.  * @author shixinke
  12.  */
  13. public class LazySingletonTest {
  15.     /**
  16.      * 单线程测试
  17.      */
  18.     public static void singleThread() {
  19.         LazySingleton ls1 = LazySingleton.getInstance();
  20.         LazySingleton ls2 = LazySingleton.getInstance();
  21.         System.out.println(ls1);
  22.         System.out.println(ls2);
  23.     }
  25.     public static void main(String[] args) {
  26.         //singleThread();
  27.         new Thread(new LazyRunnable()).start();
  28.         new Thread(new LazyRunnable()).start();
  29.         new Thread(new LazyRunnable()).start();
  30.     }
  31. }

测试结果：

  1. com.shixinke.practise.design.pattern.creation.singleton.LazySingleton@48df2951
  2. com.shixinke.practise.design.pattern.creation.singleton.LazySingleton@6fb104b6
  3. com.shixinke.practise.design.pattern.creation.singleton.LazySingleton@1467bfc6

(3)优点：

  • 懒加载：在类加载后，并不进行实例化，而是在使用时才实例化，在一定程度上能降低资源占用

(4)缺点：

  • 不是线程安全的，无法保证所有对外的方法生成的是同一个对象

补充：我们通过单步调试来分析这个结果：

多线程调试懒汉式单例模式

注：为什么它不是线程安全的呢？

  • 因为编译器为了进行程序优化，进行指令重排序，因此无法保证if判断在前，初始化在后
  • 因为CPU缓存问题，多线程对同一个共享变量的操作对于另外的线程有可见性问题，因此无法保证创建同一个对象
3.改进懒汉式

通过加锁的方式来保证线程安全

  1. /**
  2.  * 懒汉式(加锁)
  3.  * @author shixinke
  4.  */
  5. public class SynchronizedLazySingleton {
  7.     private static SynchronizedLazySingleton INSTANCE;
  9.     private SynchronizedLazySingleton() {
  11.     }
  13.     public static synchronized SynchronizedLazySingleton getInstance() {
  14.         if (INSTANCE == null) {
  15.             INSTANCE = new SynchronizedLazySingleton();
  16.         }
  17.         return INSTANCE;
  18.     }
  20. }

测试代码:

  1. class SynchronizedLazyRunnable implements Runnable {
  3.     public void run() {
  4.         System.out.println( SynchronizedLazySingleton.getInstance());
  5.     }
  6. }
  8. /**
  9.  * 懒汉式测试
  10.  * @author shixinke
  11.  */
  12. public class SynchronizedLazySingletonTest {
  15.     public static void singleThread() {
  16.         SynchronizedLazySingleton ls1 =  SynchronizedLazySingleton.getInstance();
  17.         SynchronizedLazySingleton ls2 =  SynchronizedLazySingleton.getInstance();
  18.         System.out.println(ls1);
  19.         System.out.println(ls2);
  20.     }
  22.     public static void main(String[] args) {
  23.         //singleThread();
  25.         new Thread(new SynchronizedLazyRunnable()).start();
  26.         new Thread(new SynchronizedLazyRunnable()).start();
  27.         new Thread(new SynchronizedLazyRunnable()).start();
  28.     }
  29. }

注：在getInstance前面添加synchronized关键词，表示添加一把内置锁

  • 优点：可保证线程安全，即多个线程也可以获取到同一对象
  • 缺点：因为加锁(synchronized是重量级锁)对性能有很大损耗，而且因为这里的锁是对整个类加锁，所以使用getInstance时，只能有一个线程访问资源
4.双重检测+懒汉式

目的：改进上面synchronized加锁的性能

  1. /**
  2.  * 懒汉式
  3.  * @author shixinke
  4.  */
  5. public class DoubleCheckLazySingleton {
  7.     private volatile static DoubleCheckLazySingleton INSTANCE;
  9.     private DoubleCheckLazySingleton() {
  11.     }
  13.     public static DoubleCheckLazySingleton getInstance() {
  14.         if (INSTANCE == null) {
  15.             synchronized(DoubleCheckLazySingleton.class) {
  16.                 if (INSTANCE == null) {
  17.                     INSTANCE = new DoubleCheckLazySingleton();
  18.                 }
  19.                 return INSTANCE;
  20.             }
  21.         }
  22.         return INSTANCE;
  23.     }
  24. }

测试代码:

  2. class DoubleCheckLazyRunnable implements Runnable {
  4.     public void run() {
  5.         System.out.println( DoubleCheckLazySingleton.getInstance());
  6.     }
  7. }
  9. /**
  10.  * 双重检测测试
  11.  * @author
  12.  */
  13. public class DoubleCheckSingletonTest {
  15.     public static void main(String[] args) {
  16.         new Thread(new DoubleCheckLazyRunnable()).start();
  17.         new Thread(new DoubleCheckLazyRunnable()).start();
  18.         new Thread(new DoubleCheckLazyRunnable()).start();
  19.     }
  20. }

分析：

  • 只有当INSTANCE为null时，才加锁进入下一步操作
  • 在锁内再次进行判断，是检测在加锁进入后这一对象是否被其他线程初始化
  • 使用volatile关键词，可以保证多线程之间的有序性和可见性，即对if判断和后面的初始化禁用重排序，另外，其他线程对INSTANCE的操作，对当前线程也是可见的
5.静态内部类

通过在静态内部类中初始化当前类的实例，也是通过JVM来保证该类只会被实例化一次

  1. /**
  2.  * 内部类的方式
  3.  * @author shixinke
  4.  */
  5. public class InnerClassSingleton {
  7.     private InnerClassSingleton() {
  9.     }
  11.     public static InnerClassSingleton getInstance() {
  12.         return Inner.INSTANCE;
  13.     }
  15.     private static class Inner {
  16.         private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();
  17.     }
  19. }

测试代码:

  1. class InnerClassRunnable implements Runnable {
  3.     public void run() {
  4.         System.out.println(InnerClassSingleton.getInstance());
  5.     }
  6. }
  8. /**
  9.  * 内部类测试
  10.  * @author shixinke
  11.  */
  12. public class InnerClassSingletonTest {
  15.     public static void singleThread() {
  16.         InnerClassSingleton ls1 = InnerClassSingleton.getInstance();
  17.         InnerClassSingleton ls2 = InnerClassSingleton.getInstance();
  18.         System.out.println(ls1);
  19.         System.out.println(ls2);
  20.     }
  22.     public static void main(String[] args) {
  23.         //singleThread();
  25.         new Thread(new InnerClassRunnable()).start();
  26.         new Thread(new InnerClassRunnable()).start();
  27.         new Thread(new InnerClassRunnable()).start();
  28.     }
  29. }
6.枚举类

这是最推荐使用的单例设计模式实现方式

  1. public enum EnumInstance {
  2.     INSTANCE;
  3.     EnumInstance() {
  5.     }
  7.     public static EnumInstance getInstance() {
  8.         return INSTANCE;
  9.     }
  10. }

测试代码:

  1. class EnumSingletonRunnable implements Runnable {
  3.     public void run() {
  4.         System.out.println( EnumInstance.getInstance());
  5.     }
  6. }
  7. /**
  8.  * 枚举测试
  9.  * @author
  10.  */
  11. public class EnumInstanceTest {
  12.     public static void main(String[] args) {
  13.         new Thread(new EnumSingletonRunnable()).start();
  14.         new Thread(new EnumSingletonRunnable()).start();
  15.         new Thread(new EnumSingletonRunnable()).start();
  16.     }
  17. }

补充:
Q:为什么枚举类单例是线程安全的?

A:这里借助反编译工具jad来查看反编译编译后的enum源码

  • jad官方网站: https://varaneckas.com/jad/
  • 下载安装: 直接下载解压即可(根据自己的操作系统选择对应的版本)，把jad所在目录放入到环境变量PATH中
  • 反编译.class文件
  1. cd /data/program/github/degisn-pattern-practise/target/classes/com/shixinke/practise/design/pattern/content/creation/singleton
  2. jad EnumInstance.class
  • 查看生成的反编译后的文件(与类名同名的文件，并以.jad为后缀)
  1. // Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
  2. // Jad home page: http://www.geocities.com/kpdus/jad.html
  3. // Decompiler options: packimports(3)
  4. // Source File Name:   EnumInstance.java
  6. package com.shixinke.practise.design.pattern.content.creation.singleton;
  8. //它是一个final的class，因此它不能被继承
  9. public final class EnumInstance extends Enum
  10. {
  12.     public static EnumInstance[] values()
  13.     {
  14.         return (EnumInstance[])$VALUES.clone();
  15.     }
  17.     public static EnumInstance valueOf(String name)
  18.     {
  19.         return (EnumInstance)Enum.valueOf(com/shixinke/practise/design/pattern/content/creation/singleton/EnumInstance, name);
  20.     }
  22.     private EnumInstance(String s, int i)
  23.     {
  24.         super(s, i);
  25.     }
  27.     public static EnumInstance getInstance()
  28.     {
  29.         return INSTANCE;
  30.     }
  32.     //INSTANCE是final的，因此也无法改变它
  33.     public static final EnumInstance INSTANCE;
  34.     private static final EnumInstance $VALUES[];
  36.     //在static中实例化(JVM保证了它只会被实例化一次)
  37.     static
  38.     {
  39.         INSTANCE = new EnumInstance("INSTANCE", 0);
  40.         $VALUES = (new EnumInstance[] {
  41.             INSTANCE
  42.         });
  43.     }
  44. }
7.容器类
  • 一个容器，来保存所有的实例
  • 容器对外有两个方法:
    • 注册方法：将实例对象注册到容器中(一般在初始化时注册)
    • 获取实例方法：从容器中取出实例
  1. /**
  2.  * 容器类型的单例
  3.  * @author shixinke
  4.  */
  5. public class ContainerSingleton {
  6.     /**
  7.      * 保存实例的容器
  8.      */
  9.     private static Map<String, Object> INSTANCE_MAP = new ConcurrentHashMap<String, Object>(10);
  12.     private ContainerSingleton() {
  14.     }
  17.     /**
  18.      * 添加instance到容器
  19.      * @param key
  20.      * @param instance
  21.      */
  22.     public static void register(String key, Object instance) {
  23.         if (key != null && instance != null) {
  24.             if (!INSTANCE_MAP.containsKey(key)) {
  25.                 INSTANCE_MAP.put(key, instance);
  26.             }
  27.         }
  28.     }
  30.     /**
  31.      * 取instance
  32.      * @param key
  33.      * @return
  34.      */
  35.     public static Object getInstance(String key) {
  36.         return INSTANCE_MAP.get(key);
  37.     }
  38. }

测试代码:

  1. package com.shixinke.practise.design.pattern.content.creation.singleton;
  3. class RegisterSingletonRunnable implements Runnable {
  5.     private String key;
  6.     private Object value;
  8.     public RegisterSingletonRunnable(String key, Object value) {
  9.         this.key = key;
  10.         this.value = value;
  11.     }
  13.     public void run() {
  14.         ContainerSingleton.register(this.key, this.value);
  15.     }
  16. }
  18. class GetSingletonRunnable implements Runnable {
  20.     public void run() {
  21.         System.out.println( ContainerSingleton.getInstance("object"));
  22.     }
  23. }
  24. /**
  25.  * 容器单例测试类
  26.  * @author shixinke
  27.  */
  28. public class ContainerSingletonTest {
  30.     public static void main(String[] args) {
  31.         new Thread(new RegisterSingletonRunnable("object", new Object())).start();
  32.         new Thread(new RegisterSingletonRunnable("object", new Object())).start();
  33.         new Thread(new RegisterSingletonRunnable("object2", new Object())).start();
  34.         new Thread(new GetSingletonRunnable()).start();
  35.         new Thread(new GetSingletonRunnable()).start();
  36.         new Thread(new GetSingletonRunnable()).start();
  37.     }
  38. }
8总结

单例模式实现方式有多种，推荐顺序如下:

枚举类单例模式 > 静态内部类单例模式 > 饿汉式单例模式

  • 枚举类单例模式不用考虑序列化和反射来破坏单例模式的情况
  • 其他实现方式需要考虑序列化和反射破坏单例模式的情况

三.源码中单例模式的使用

1.JDK中单例模式的使用
(1)Runtime类
  1. public class Runtime {
  2.     private static Runtime currentRuntime = new Runtime();
  4.     public static Runtime getRuntime() {
  5.         return currentRuntime;
  6.     }
  8.     private Runtime() {}
  9. }
  • Runtime类使用的是懒汉式的单例模式
2.Mybatis中单例模式的使用

注:ErrorContext 只保证在线程内部，实例对象是唯一的(因为使用了ThreadLocal，这个是每个线程都有一个)

  1. public class ErrorContext {
  3.     private static final ThreadLocal<ErrorContext> LOCAL = new ThreadLocal();
  5.     private ErrorContext() {
  6.     }
  8.     //对外提供的获取实例的方法
  9.     public static ErrorContext instance() {
  10.         ErrorContext context = (ErrorContext)LOCAL.get();
  11.         if (context == null) {
  12.             context = new ErrorContext();
  13.             LOCAL.set(context);
  14.         }
  16.         return context;
  17.     }
  18. }

专题 更多...

分类 更多...

展开

标签 更多...

归档 更多...

展开