设计模式记录1之“单件模式”

上次面试遇到这个问题，没回答到重点，看了些资料，现在记录下来。

 特点： 1 绕过常规的构造器，确保一个类只有一个实例，并提供一个全局访问点；

          2 必须在自己的类中实例化，自己负责保存唯一实例，并且保证不会产生第二个实例；

          3  类的构造函数改为private 或者protect；

          3 安全的单件模式：双重检查锁定机制；

 场景描述：一个网站进行人数统计，通常会保存到内存，文件或者数据库中，每次用户登录，都new一个实例进行加一，然后保存起来。但是这样的话，有多个用户就会new多个对象，这样数据就不准确了，此时用"单件模式"可以解决。把计数器作为一个全局的对象，向所有人提供这一份数据，所有的用户登录都是操作这一个对象，这样便避免了人数统计的不准确性。

实现方法1，简单的单件模式：

View Code

 1    public   class  singleClass
 2   { 
 3            private   static  singleClass single = null ;
 4            private  singleClass (){}      // 把原本默认的公开构造函数设为private私有的
 5           
 6            public  singleClass  GetInstance()
 7           {
 8              Get
 9            {
10                  if (single == null )
11                 {
12                    single = new  singleClass ()
13                }
14                return  single;
15           } 
16          }
17   }

 这个是在单线程中的单件模式，但如果在多线程中，一个实例来不及构建，另一个线程也接着new 一个。因而可能会导致多个对象实例。

实现方法2，叫做Double-Check Locking(双重锁定)：

View Code

 1  public   singClass
 2  {
 3  private  singClass(){}
 4        private   static  singClass single = null ;
 5        static   readonly   object  padlock  =   new   object ();
 6        
 7        public   static  singClass GetInstance
 8       {
 9          get
10          {
11            if (single == null )
12           {
13               lock (padlock)
14              {
15                  if (single == null )
16                 { 
17                  single = new   singClass ();  
18                  }
19               }
20             }
21            return  single;
22         }
23       }
24  }

方法3,静态实现：

View Code

 1  public  singleClass
 2  {
 3       public   static   readonly  singleClass single = new   singleClass ();
 4       private   static  singleClass (){}
 5  }
 6 
 7  // 以上代码展开等同
 8  public  singleClass
 9  {
10      public   static   readonly  singleClass  single;
11      static  singleClass ()    // 静态构造器
12     {
13       single = new  singleClass  ();
14     }
15       private  singleClass  (){}
16  }

原理：使用了静态构造器，在第一次引用类的任何成员时创建实例，公共语言运行库负责处理变量初始化。

缺点：不能传入参数。

单件模式核心：如何控制用户使用new对一个类的实例构造器的任意调用。

 

-------

题外话：锁(lock)的使用。锁主要就是为了保证数据同步与安全。

情景：比如我修改数据库的数据，当我修改到一半的时候，别人又来修改这个数据，然后可能会有更多的人一起来修改，这样的话数据是不正确的。所以就需要使用到锁。当我正在对某些数据进行修改的时候，把它锁起来，别人不能进行操作，必须等我操作完了别人才能执行操作。

 首先定义一个辅助的对象，就像我之前写的单件模式的方法二中写的，

readonly object padlock=new object();

......

然后使用锁

lock(padlock){/*被锁住的代码或对象*/   }