单件模式--软件设计模式

如果给对象开一个全局变量，那么必须在一开始就创建好对像，而这样会造成资源浪费，而单件模式则是在需要时才创建对象。

单件模式的定义：确保一个类只有一个实例，并提供一个全局访问点。建造全局访问点暂知此两种方式：单件模式和声明全局变量

下面是经典单件模式代码，没有考虑全局变量。

      public class Singleton{
      private static Singleton uniqueInstance;//用一个静态变量记录Singleton类的唯一实例
      
      private Singleton(){}//构造器声明为私有的，只有Singleton类内才能调用//注意：构造函数是私有的
      
      public static Singleton getInstance(){//若我们不需要这个实例，它就永远不会产生。这就是“延迟实例化”（lazy instantiaze）
          if(uniqueInstance == null){
              uniqueInstance = new Singleton();
          }
         return uniqueInstance;
     }
   }

上述代码if语句为“延迟实例化”，即实例是在调用该方法的时候创建的或以前很早就创建出来了。它的类图也相当简单，只有三点：静态成员，私有构造方法，以及获得实例的静态方法。

但是这种方式对线程来说是不安全的，如果两个现成同时进入到if的处理代码中，就会造成创建了两个Singleton实例。

下面是处理多线程问题：

方法1:只把get instance( )变成同步（关键词：synchronized)方法。

     //每个线程在进入这个方法之前，要先等候别的线程离开该方法。
     public static synchronized Singleton getInstance(){
         if(uniqueInstance == null){
             uniqueInstance = new Singleton();
         }
         return uniqueInstance;
     }

synchronized关键字迫使每个线程进入这个方法之前，要先等候别的线程离开该方法。也就是说，不会有两个线程同时进入这个方法。但是这多线程就变成了串行，失效了。

方法2:使用“急切”创造实例，而不用“延迟实例化”。

 public class Singleton{
      //在静态初始化器（static initializer）中创建单件。保证了线程安全（thread safe）。
      private static Singleton uniqueInstance = new Singleton();
      
     private Singleton(){}
      
      public static Singleton getInstance(){
          return uniqueInstance;
      }
 }//JVM保证在任何线程访问uniqueInstance静态变量之前，一定先创建此实例。

这种方法虽然保证了线程的安全，但是造成了资源的浪费。

方法3:“双重检查加锁”，在getInstance( )中减少使用同步

/**
 * 双重检查加锁单件模式实现
 */
 public class Singleton {
    private volatile static Singleton uniqueInstace;
    //私有构造器，使单件类只能通过getInstance()获取
    private Singleton() {

    }
    //保证singleton的唯一实例
    public static synchronized Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class) {
                if(uniqueInstace == null)
                    singleton = new Singleton();
            }
        }
        return singleton;
    }
}

volatile关键字确保：当uniqueInstace变量被初始化成Singleton实例时，多个线程正确地处理uniqueInstace变量。

总结；

1.单件模式：确保一个类只有一个实例，并提供一个全局访问点

2.我们正在把某个类设计成自己管理的一个单独实例，同时也避免其他类再自行产生实例。要想取得单件实例，通过单件类是唯一的途径。

3.我们也提供这个实例的全局访问点：当你需要实例时，向类查询，它会返回单个实例。前面的例子利用延迟实例化的方式创建单件，这种做法对资源敏感的对象特别重要。

注意：不在单件模式中使用继承！

附：相关问答（Head First 设计模式P185）

1.单件模式只有一个类，应该是很简单的模式，但是问题似乎不少

答：固然正确地实现单件模式需要一点技巧，但是阅读完这篇文章之后，你已经具备了用正确的方式实现单件模式的能力。当你需要控制实例个数时，还是应当使用单件模式。

2.难道我不能创建一个类，把所有的方法和变量都定义为静态的，把类直接当作一个单件？

　　答：如果你的类自给自足，而且不依赖于复杂的初始化，那么你可以这么做。但是，因为静态初始化的控制是在CLR受伤，这么做有可能导致混乱，特别是当有许多类牵涉其中的时候。这么做常常会造成一些微妙的，不容易发现的和初始uade次序有关的bug。除非你有绝对的必要使用类的单件，否则还是建议使用对象的单件

3.类应该做一件事，而且只做一件事。类如果能做两件事，就会被认为是不好的OO设计，单件有没有违反这样的观念？

　　答：你说的是“一个类，一个责任”原则。没错，你似的对的，但见类不只负责管理自己的实例，并提供全局访问，还在应用程序中担当角色，所以也可以被视为是两个责任。尽管如此，由类管理自己的实例的做法并不少见。这可以让整体设计更简单。更何况，许多开发人员都已经熟悉了单件模式的这种做法。

4.我想把单件类当成超类，设计出子类，但是我遇到了问题，究竟可以不可以继承单件类？

　　答：继承单件类会遇到一个问题，就是构造器是私有的。你不能用私有构造器来扩展类。所以你必须把单件的构造器改成公共的或受保护的。但是这么一来就不算真正的单件了，因为别的类也可以实例化他。

如果你果真把构造器的访问权限改了，还有另一个问题出现，单件的实现是利用静态变量，直接继承会导致所有的派生类共享同一个实例变量，这可能不是你想要的。

5.我还是不了解为何全局变量比单件模式差。

　　答：在.net中，全局变量基本上就是对对象的静态引用。在这样的情况下使用全局变量会有一些缺点，我们已经提到了其中的一个：急切实例化VS延迟实例化。但是我们要记住这个模式的目的：确保类只有一个实例并提供全局访问，但是不能确保只有一个实例。全局变量也会变相鼓励开发人员，用许多全局变量指向许多小对象来造成这样的现象，但单件仍然可能被滥用。