/// <summary>      /// 创建一个 Singleton 类（饿汉式）      /// 这种方式比较常用，但容易产生垃圾对象。      ///优点：没有加锁，执行效率会提高。      ///缺点：类加载时就初始化，浪费内存。      ///它基于 classloder 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，      ///虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法，      ///但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。      /// </summary>      public class SingleObject      {          //创建 SingleObject 的一个对象          private static SingleObject instance = new SingleObject();            //让构造函数为 private，这样该类就不会被实例化          private SingleObject() {              Console.WriteLine("我被创建了.饿汉式");          }            //获取唯一可用的对象          public static SingleObject GetInstance()          {              return instance;          }            public void ShowMessage()          {              Console.WriteLine("Hello World.饿汉式");          }      }

  /// <summary>      /// 创建一个 Singleton 类（懒汉式）      /// 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。      /// 优点：第一次调用才初始化，避免内存浪费。      /// 缺点：懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象。      /// </summary>      public class SingleObject1      {          //创建 SingleObject 的一个对象          private static SingleObject1 instance;            //让构造函数为 private，这样该类就不会被实例化          private SingleObject1() { }            //获取唯一可用的对象          public static SingleObject1 GetInstance()          {              if (instance == null)              {                  instance = new SingleObject1();                  Console.WriteLine("我被创建了.懒汉式");              }              return instance;          }            public void ShowMessage()          {              Console.WriteLine("Hello World.懒汉式");          }      }

    /// <summary>      /// 创建一个 Singleton 类（双重验证）      /// 这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。      /// 优点：第一次调用才初始化，避免内存浪费，线程安全。      /// 缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。      /// </summary>      public class SingleObject2      {          //创建 SingleObject 的一个对象          private static SingleObject2 instance;            // 定义一个标识确保线程同步          private static readonly object locker = new object();              //让构造函数为 private，这样该类就不会被实例化          private SingleObject2() { }            //获取唯一可用的对象          public static SingleObject2 GetInstance()          {              //// 如果为空，那么就加锁，创建实例              if (instance == null)              {                  lock (locker)                  {                      //// 枷锁成功后，在做一次非空判断，避免在加锁期间以创建了实例而导致重复创建                      if (instance == null)                      {                          instance = new SingleObject2();                          Console.WriteLine("我被创建了.双重验证");                      }                  }              }              return instance;          }            public void ShowMessage()          {              Console.WriteLine("Hello World.双重验证");          }      }

  /// <summary>      /// 创建一个 Singleton 类(静态内部类)      /// 这种方式不用加锁，在效率上和内存使用上都比较优秀      /// 克服了饿汉模式的不足饿汉模式执行效率高，由于在类加载的时候初始化导致内存浪费      /// </summary>      public class SingletonStatic      {          /// <summary>          /// 内部类          /// </summary>          public class SingletonStaticInner          {              /// <summary>              /// 当一个类有静态构造函数时，它的静态成员变量不会被beforefieldinit修饰              /// 就会确保在被引用的时候才会实例化，而不是程序启动的时候实例化              /// </summary>              static SingletonStaticInner() { }                /// <summary>              /// 实例化              /// </summary>              internal static SingletonStatic singletonStatic = new SingletonStatic();          }            /// <summary>          /// 私有构造函数          /// </summary>          private SingletonStatic() {              Console.WriteLine("我被创建了.静态内部类");          }            /// <summary>          /// 获取实例          /// </summary>          /// <returns></returns>          public static SingletonStatic GetInstance()          {              return SingletonStaticInner.singletonStatic;          }            public void ShowMessage()          {              Console.WriteLine("Hello World.静态内部类");          }      }

/*
介绍
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
主要解决：一个全局使用的类频繁地创建与销毁。
何时使用：当您想控制实例数目，节省系统资源的时候。
如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。
关键代码：构造函数是私有的。
应用实例：
典型的已有应用：
1、windows的任务管理器等
2、IIS的HttpApplication，所有的HttpModule都共享一个HttpApplication实例
在项目中的实际使用场景：
1、日志组件
2、多线程线程池管理
3、网站计数器
4、配置文件管理
*/

  
class Program      {          static void Main(string[] args)          {              TaskFactory taskFactory = new TaskFactory();              List<Task> taskList = new List<Task>();                //// 测试--饿汉式               for (int i = 0; i < 5; i++)              {                  taskList.Add(taskFactory.StartNew(() =>                  {                      SingleObject.GetInstance();                  }));              }                //// 测试--懒汉式               for (int i = 0; i < 5; i++)              {                  taskList.Add(taskFactory.StartNew(() =>                  {                      SingleObject1.GetInstance();                  }));              }                //// 测试--双重验证               for (int i = 0; i < 5; i++)              {                  taskList.Add(taskFactory.StartNew(() =>                  {                      SingleObject2.GetInstance();                  }));              }                //// 测试--静态内部类               for (int i = 0; i < 5; i++)              {                  taskList.Add(taskFactory.StartNew(() =>                  {                      SingletonStatic.GetInstance();                  }));              }                Console.ReadLine();          }      }