大话设计模式之单例模式

单例模式：保证一个类只有一个实例，并提供一个访问它的全局访问点，

class Singleton {
  private static Singleton instance;
  private Singleton() {

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

static void Main(string[] args) {
  Singleton s1 = Singleton.GetInstance();
  Singleton s2 = Singleton.GetInstance();
  if(s1 == s2) {
    Console.WriteLine("两个对象是相同的实例");
  }
}

单例模式除了可以保证唯一的实例外，还有可以严格控制客户怎样访问它以及何时访问它，就是对唯一实例的受控访问。

多线程时的单例，多线程同时访问Singleton类，调用GetInstance()方法，有可能造成创建多个实例。

解决方法可以给进程加锁，lock确保当一个线程位于代码的临界区时，另一个线程不进入临界区。

class Singleton {
  private static Singleton instance;
  private static readonly object syncRoot = new object();
  private Singleton() {

  }
  public static Singleton getInstance() {
    lock(syncRoot) {

    if(instance == null) {
      instance = new Singleton(); 
    } 
    }
    return instance;
  }
}

static void Main(string[] args) {

  Singleton s1 = Singleton.GetInstance();
  Singleton s2 = Singleton.GetInstance();
  if(s1 == s2) {
    Console.WriteLine("两个对象是相同的实例");
  }
}

这段代码使得对象实例由最先进入的那个线程创建，以后的线程在进入时不会创建对象实例。由于有了lock，就保证了多线程环境下的同时访问也不会造成多个实例的生成。

为什么不直接lock instance，而是再创建一个syncRoot来lock呢

因为instance实例有没有被创建还不清楚，所以不能对它加锁，

缺点 影响性能。

双重锁定

class Singleton {
  private static Singleton instance;
  private static readonly object syncRoot = new object();
  private Singleton() {

  }
  public static Singleton getInstance() {
    if(instance == null){
    lock(syncRoot) {
    if(instance == null) {
      instance = new Singleton(); 
    } 
    }
    }
    return instance;
  }
}

先判断实例是否存在，不存在再加锁

分析

1.都进入了instance为空判断的方法体内，还未进入加锁环节，此时一旦先进入加锁的线程获得创建实例的机会，后进入的则不能创建，

2.已有线程创建了实例，那么后面进入的线程，则不能进入第一个为空判断内，而是直接获取实例，这样就不用加锁了，避免性能的浪费。