设计模式——单例模式

单例模式

单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

单例模式通用类图（饿汉式单例），可以看出：

• Singleton类称为单例类；
• 将构造函数变为private，确保在一个应用中只产生一个实例；
• 通过new，在类内自行实例化的；
• 通过get方法返回对象。

  

   

    

     

    
    

     

      public 
      class Singleton {
     
    
   

    

     

    
    

     
    
      //通过new，在类内自行实例化的
     
    
   

    

     

    
    

     
    
      private 
      static 
      final Singleton singleton = 
      new Singleton(); 
     
    
   

    

     

    
    

     
    
      //构造函数变为private，限制产生多个对象 
     
    
   

    

     

    
    

     
    
      private Singleton(){ 
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      //通过该方法获得实例对象 
     
    
   

    

     

    
    

     
    
      public static Singleton getSingleton(){ 
     
    
   

    

     

    
    

     
        
      return singleton; 
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      //类中其他方法，尽量是static 
     
    
   

    

     

    
    

     
    
      public static void doSomething(){} 
     
    
   

    

     

    
    

     

      }
     
    
  

单例模式的优点：

• 减少内存开支，特别是一个对象需要频繁地创建、销毁时。
• 减少系统的性能开销，当一个对象的产生需要比较多的资源（读取配置、产生其他依赖对象等）时，可以通过在应用启动时直接产生一个单例对象，然后用永久驻留内存的方式来解决（在Java EE中采用单例模式时需要注意JVM垃圾回收机制）。
• 避免对资源的多重占用，例如一个写文件动作，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。
• 可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

单例模式的缺点：

• 单例模式一般没有接口，扩展很困难。当然，在特殊情况下，单例模式可以实现接口、被继承等。
• 单例模式对测试是不利的。
• 单例模式与单一职责原则有冲突。一个类应该只实现一个逻辑，是不是要单例取决于环境。

单例模式的适用场景：

• 要求生成唯一序列号的环境；
• 在整个项目中需要一个共享访问点或共享数据，例如一个Web页面上的计数器，可以不用把每次刷新都记录到数据库中，使用单例模式保持计数器的值，并确保是线程安全的；
• 创建一个对象需要消耗的资源过多，如要访问IO和数据库等资源；
• 需要定义大量的静态常量和静态方法（如工具类）的环境，可以采用单例模式（也可以直接声明为static的方式）。

单例模式的另一种表现形式：

  

   

    

     

    
    

     

      public 
      class Singleton {
     
    
   

    

     

    
    

     
    
      private 
      static Singleton singleton = 
      null;
     
    
   

    

     

    
    

     
    
      private Singleton(){
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      public static Singleton getSingleton(){
     
    
   

    

     

    
    

     
        
      if(singleton == 
      null){
     
    
   

    

     

    
    

     

                  singleton = 
      new Singleton();
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     
        
      return singleton;
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  

该形式称为懒汉式单例，它是不安全的，当多个线程同时访问代码时，可能出现产生多个对象的情况。

我们可以通过在getSingleton方法前加synchronized关键字，或在getSingleton方法内增加synchronized来实现。当然，还是不建议用这种实现方式。

在Java中，对象默认是不可以被复制的，若实现了Cloneable接口，并实现了clone方法，则可以直接通过对象复制方式创建一个新对象，对象复制是不用调用类的构造函数，因此即使是私有的构造函数，对象仍然可以被复制。

单例模式的扩展

如果一个类可以产生多个对象，对象的数量不受限制，则是非常容易实现的，直接使用 new关键字就可以了，如果只需要一个对象，使用单例模式就可以了。那么，如果要求一个类只能产生两三个对象呢？

我们以同一时期存在两个皇帝为例（即父子等同朝为帝）：

  

   

    

     

    
    

     

      public 
      class Emperor {
     
    
   

    

     

    
    

     
    
      //定义最多能产生的实例数量
     
    
   

    

     

    
    

     
    
      private 
      static 
      int maxNumOfEmperor = 
      2;
     
    
   

    

     

    
    

     
    
      //每个皇帝都有名字，使用一个ArrayList来容纳，每个对象的私有属性
     
    
   

    

     

    
    

     
    
      private 
      static ArrayList<String> nameList=
      new ArrayList<String>();
     
    
   

    

     

    
    

     
    
      //定义一个列表，容纳所有的皇帝实例
     
    
   

    

     

    
    

     
    
      private 
      static ArrayList<Emperor> emperorList=
      new ArrayList<Emperor>();
     
    
   

    

     

    
    

     
    
      //当前皇帝序列号
     
    
   

    

     

    
    

     
    
      private 
      static 
      int countNumOfEmperor = 
      0;
     
    
   

    

     

    
    

     
    
      //产生所有的对象
     
    
   

    

     

    
    

     
    
      static{
     
    
   

    

     

    
    

     
        
      for(
      int i = 
      0;i < maxNumOfEmperor;i ++){
     
    
   

    

     

    
    

     

                  emperorList.add(
      new Emperor(
      "皇" + ( i + 
      1 ) + 
      "帝"));
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      private Emperor(){
     
    
   

    

     

    
    

     
    
      //世俗和道德约束你，目的就是不产生第二个皇帝
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      //传入皇帝名称，建立一个皇帝对象
     
    
   

    

     

    
    

     
    
      private Emperor(String name){
     
    
   

    

     

    
    

     

              nameList.add(name);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      //随机获得一个皇帝对象
     
    
   

    

     

    
    

     
    
      public static Emperor getInstance(){
     
    
   

    

     

    
    

     

              Random random = 
      new Random();
     
    
   

    

     

    
    

     
        
      //随机拉出一个皇帝，只要是个精神领袖就成
     
    
   

    

     

    
    

     

              countNumOfEmperor = random.nextInt(maxNumOfEmperor);
     
    
   

    

     

    
    

     
        
      return emperorList.get(countNumOfEmperor);
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     
    
      //皇帝发话了
     
    
   

    

     

    
    

     
    
      public static void say(){
     
    
   

    

     

    
    

     

              System.out.println(nameList.get(countNumOfEmperor));
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  

在Emperor中使用了两个ArrayList分别存储实例和实例变量。如果考虑到线程安全问题可以使用Vector来代替。

臣子参拜皇帝的过程：

  

   

    

     

    
    

     

      public 
      class Minister {
     
    
   

    

     

    
    

     
    
      public static void main(String[] args) {
     
    
   

    

     

    
    

     
        
      //定义5个大臣
     
    
   

    

     

    
    

     
        
      int ministerNum =
      5;
     
    
   

    

     

    
    

     
        
      for(
      int i=
      0;i<ministerNum;i++){
     
    
   

    

     

    
    

     

                  Emperor emperor = Emperor.getInstance();
     
    
   

    

     

    
    

     

                  System.out.print(
      "第"+(i+
      1)+
      "个大臣参拜的是：");
     
    
   

    

     

    
    

     

                  emperor.say();
     
    
   

    

     

    
    

     

              }
     
    
   

    

     

    
    

     

          }
     
    
   

    

     

    
    

     

      }
     
    
  

结果：

这种需要产生固定数量对象的模式就叫做有上限的多例模式，它是单例模式的一种扩展，它可以在设计时决定在内存中有多少个实例，方便系统进行扩展，修正单例可能存在的性能问题，提供系统的响应速度。

在Spring中，每个Bean默认就是单例的。