Singleton（二）

最新推荐文章于 2024-02-18 09:58:39 发布
最新推荐文章于 2024-02-18 09:58:39 发布
阅读量508 收藏
点赞数

0)Eager initialization

如果程序一开始就需要某个单例，并且创建这个单例并不那么费时，我们可以考虑用这种方式：

1
2
3
4
5
6
7
8
9

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

这种实现方式有几个特点：

  • 实例一开始就被创建(Eager initialization)。
  • getInstance()方法不需要加synchronize来解决多线程同步的问题。
  • final关键字确保了实例不可变，并且只会存在一个。

1)Lazy initialization

懒加载的方式使得单例会在第一次使用到时才会被创建.先看一种有隐患的写法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public final class LazySingleton {
  private static volatile LazySingleton instance = null;

  // private constructor
  private LazySingleton() {
  }

  public static LazySingleton getInstance() {
      if (instance == null) {
          synchronized (LazySingleton.class) {
              instance = new LazySingleton();
          }
      }
      return instance;
  }
}

请注意：上面的写法其实非线程安全的，假设两个Thread同时进入了getInstance方法，都判断到instance==null，然后会因为synchronized的原因，逐个执行，这样就得到了2个实例。解决这个问题，需要用到典型的double-check方式，如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class LazySingleton {
    private static volatile LazySingleton instance = null;

    private LazySingleton() {       
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton .class) {
                if (instance == null) {
                        instance = new LazySingleton ();
                }
            }
        }
        return instance;
    }
}

另外一个更简略直观的替代写法是：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class LazySingleton {
    private static volatile LazySingleton instance = null;

    private LazySingleton() {       
    }

    public static synchronized LazySingleton getInstance() {
            if (instance == null) {
                instance = new LazySingleton ();
            }
        return instance;
    }
}

2)Static block initialization

如果我们对程序的加载顺序有点了解的话，会知道Static block的初始化是执行在加载类之后，Constructor被执行之前。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class StaticBlockSingleton {
  private static final StaticBlockSingleton INSTANCE;

  static {
      try {
          INSTANCE = new StaticBlockSingleton();
      } catch (Exception e) {
          throw new RuntimeException("Error, You Know This, Haha!", e);
      }
  }

  public static StaticBlockSingleton getInstance() {
      return INSTANCE;
  }

  private StaticBlockSingleton() {
      // ...
  }
}

上面的写法有一个弊端，如果我们类有若干个static的变量，程序的初始化却只需要其中的1，2个的话，我们会做多余的static initialization。

3)Bill Pugh solution

University of Maryland Computer Science researcher Bill Pugh有写过一篇文章initialization on demand holder idiom。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class Singleton {
    // Private constructor prevents instantiation from other classes
    private Singleton() { }

    /**
    * SingletonHolder is loaded on the first execution of Singleton.getInstance() 
    * or the first access to SingletonHolder.INSTANCE, not before.
    */
    private static class SingletonHolder {
        public static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

SingletonHolder类会在你需要的时候才会被初始化，而且它不影响Singleton类的其他static成员变量的使用。这个方法是线程安全的并且避免了使用volatile与synchronized。

4)Using Enum

这是最简便安全的方法。没有明显的缺点，并且避免了下面要讲到的序列化的隐患。

1
2
3
4
5
6

public enum Singleton {
    INSTANCE;
    public void execute (String arg) {
        // perform operation here 
    }
}

Serialize and de-serialize

在某些情况下，需要实现序列化的时候，普通的单例模式需要添加readResolve的方法，不然会出现异常。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class DemoSingleton implements Serializable {
  private volatile static DemoSingleton instance = null;

  public static DemoSingleton getInstance() {
      if (instance == null) {
          instance = new DemoSingleton();
      }
      return instance;
  }

  protected Object readResolve() {
      return instance;
  }

  private int i = 10;

  public int getI() {
      return i;
  }

  public void setI(int i) {
      this.i = i;
  }
}

仅仅有上面的还不够，我们需要添加serialVersionUID，例子详见下面的总结。

Conclusion

实现一个功能完善，性能更佳，不存在序列化等问题的单例，建议使用下面两个方式之一:

Bill Pugh(Inner Holder)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class DemoSingleton implements Serializable {
  private static final long serialVersionUID = 1L;

  private DemoSingleton() {
      // private constructor
  }

  private static class DemoSingletonHolder {
      public static final DemoSingleton INSTANCE = new DemoSingleton();
  }

  public static DemoSingleton getInstance() {
      return DemoSingletonHolder.INSTANCE;
  }

  protected Object readResolve() {
      return getInstance();
  }
}

Enum

1
2
3
4
5
6

public enum Singleton {
    INSTANCE;
    public void execute (String arg) {
        // perform operation here 
    }
}

参考资料

谁与少牧
关注
Loki库中SingletonHolder的多线程改进
03-09
Loki是套非常实用的模板库，这不用多说了吧。 其中的SingletonHolder非常方便创建我们自己的 Singleton类。但是在多线程这块，它只保证了 多线程情况下对该singleton对象创建操作的串行化，没有对singleton对象访问的操作进行串行化。 这个包就是修正这个问题的。只不过访问方式要从 CMyclass::instance().DoSomething() 改成 CMyclass::instance()->DoSomething().
Singleton 单例模式
03-16
if (instance == null) { // 第二次检查，避免同步的线程安全问题 instance = new Singleton(); } } } return instance; } } ``` 4. 静态内部类： 利用Java类加载机制保证线程安全，同时延迟初始化。 ```...
设计模式之单例模式的四种实现
飞鸿踏雪泥的博客
07-07 1078
设计模式之单例模式 **单例模式（Singleton）**保证一个类仅有一个实例，并提供一个访问它的全局访问点。 结构图 常见应用： 日志，驱动，缓存和线程池等。 实现方法： Eager initialization（饿汉式初始化） Static block initialization（静态块初始化） Lazy initialization（懒汉式初始化） Bill Pugh Singleto...
Java单例模式
sanmansan的博客
05-31 87
Java单例模式
单例模式的5种实现方式，最后一种最推荐
QiuMing
02-18 2938
单例模式有多种实现方式，选择哪种方式取决于你的具体需求。如果你希望在程序启动时就创建实例，可以选择饿汉式；如果你希望在需要时才创建实例，可以选择懒汉式、静态内部类或枚举。在多线程环境下，需要注意线程安全问题。希望本文能帮助你更好地理解和使用单例模式。
Java的安全初始化
ba12346的专栏
02-28 1296
不安全的发布 错误的延迟初始化将导致不正确的发布，如下面的程序所示。初看起来，在程序中存在的问题只有竞态条件问题。在某些特定条件下，例如当Resource的所有实例都相同时，你或许会忽略这些问题（以及在多次创建Resource实例时存在的低效率问题）。然而，即使不考虑这些问题，UnsafeLazyInitialization仍然是不安全的，因为另一个线程可能看到对部分构造的Resource实例的
Python使用metaclass实现Singleton模式的方法
09-22
第二次调用`Cache()`时，`Singleton call`被触发，直接返回了已存在的实例，而不是创建新的实例，这就实现了Singleton模式。 总结一下，Python通过元类实现Singleton模式的核心在于利用元类的`__call__`方法控制类...
C++完美实现Singleton模式
08-01
#### 二、标准实现方式 在C++中，最简单也是最常见的Singleton模式实现方式如下所示： ```cpp class Singleton { public: static Singleton* Instance() { if (_instance == nullptr) { _instance = new ...
Spring中的singleton和prototype的实现
08-18
Spring中的singleton和prototype的实现 Spring框架中，bean的作用域是指在容器中bean的实例化和生命周期管理。其中，singleton和prototype是两个最基本的bean作用域。本文将详细介绍Spring中的singleton和...
SingleTon的模板（template）化应用
03-24
二是提供一个全局访问点，使得任何地方都可以获取到这个唯一的实例。传统的C++单例实现可能使用静态成员变量和私有构造函数来达到这一目的： ```cpp class Singleton { private: Singleton() {} // 私有构造函数 ...
Job的初始化—EagerTaskInitializationListener
xhh198781的专栏
03-13 1510
客户端用户在向JobTracker节点成功地提交了一个Job之后，JobTracker节点并不会马上对这个作业进行调度，因为任何作业在被任务调度器TaskSchedule调度之前，都必须先被初始化，这一点笔者曾经在讲解Hadoop的默认调度器——JobQueueTaskSchedule时已经详细地谈到过了。而本文将要集中讨论的是Job是如何被初始化的，同时，Job的初始化又干了哪些事情。
并发编程(1)-单例模式和volatile
All is well ^_^
01-13 312
个人博客: https://zongwenlong.github.io/ 欢迎访问 ^_^  之前在找实习的时候，被N次问过，你用过什么设计模式么，或者你知道有什么设计模式么？每次我都只会羞愧的说，单例模式，面试官就会说，那就写一下吧。然后我就把直接背诵过得模板的写了出来。当时羞愧的原因是我只会一种设计模——单例模式。关于设计模式这个坑会在之后进行填补，现在的我才意识到还有个地方更应该感到羞愧——唯
单例模式Singleton
酱紫的博客
09-26 256
定义：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。 使用场景：确保某一个类有且只有一个对象的场景，避免产生多个对象消耗过多的资源，或则某种类型的对象应该有且只有一个。 实现单利模式： 1、构造函数不对外开放，一般为Private 2、通过一个静态方法或则枚举返回单利类对象 3、确保单利类的对象有且只有一个，尤其是多线程的环
面试题02-玩转单例模式
zzf1233的博客
03-25 160
单例模式 1、什么叫单例模式 这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。 注意点： 单例类只能有一个实例。 单例类必须自己创建自己的唯一实例。 单例类必须给所有其他对象提供这一实例。 不需要实例化该类对象就可以访问。 2、单例实现介绍 **实现意图：**保证一个类仅有一个实例，并提供一个访问它的全局访问点。 **主要解决：**一个全局使用的类频繁地创建与销毁。 **何时使用：**当您想控制
Java设计模式—Singleton
weixin_30894389的博客
11-22 71
单例模式的特点： 　　1、单例模式只能有一个实例 　　2、单利类必须自己创建自己的唯一实例 　　3、单例类必须给所有的其他对象提供这一实例 　　概述：保证一个类，只有一个实例存在，同时提供对该实例加以访问的全局访问方法。 单例模式的运用：线程池，缓存，日志对象，对话框，打印机，显卡驱动常常被设计为单例模式。主要就是避免不一致状态。 单例模式的实现方式： 　　懒汉式 　　...
单例模式双检验锁中的volatile理解
payne608的博客
03-23 148
public class Singleton { private volatile static Singleton uniqueInstance; private Singleton() { } public static Singleton getUniqueInstance() { if (uniqueInstance == null) { synchronized (Singleton.class) {
绿色柔性导电水凝胶的构建及其在运动健康监测中的应用
最新发布
11-11
绿色柔性导电水凝胶的构建及其在运动健康监测中的应用
com.harmonyos4.exception.GpsUnavailableException解决方案(亲测可用).md
11-11
鸿蒙开发中碰到的报错，问题已解决，写个文档记录一下这个问题及解决方案
Java Singleton模式详解与面试题
第二种形式，称为懒汉式Singleton，延迟初始化，只有在首次调用`getInstance()`时才创建实例，提高了效率。代码如下： ```java public class Singleton { private static Singleton instance = null; public ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值