线程安全 单例模式

线程安全-单例模式

线程安全性的定义：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。 
　　或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。

线程安全问题都是由全局变量及静态变量引起的。若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则就可能影响线程安全。

多线程环境下写代码的时候要注意这个问题，说白了它是一个并发的问题。asp.net程序也要注意这个问题，许多用户同时访问，进行同一个操作的时候，如果不注意这个问题，将会导致数据库数据出错。一些关键性的地方要用事务来处理数据库的更改操作。前面老是看到这个名词，一直懒的看看它到底是怎么回事，原来就是并发操作的问题。

单例（Singleton）模式下最关心的就是这个线程安全的问题了，介绍一个单例模式：
单实例设可能是使用最广泛的设计模式。其思想意图是保证一个类只有一个实例，并且提供类对象的全程访问。单实例对象应用的范围很广：如GUI应用必须是单鼠标，MODEM的联接需要一条且只需要一条电话线，操作系统只能有一个窗口管理器，一台PC连一个键盘。使用全程对象能够保证方便地访问实例，但是不能保证只声明一个对象-也就是说除了一个全程实例外，仍然能创建相同类的本地实例。单实例模式通过类本身来管理其唯一实例，这种特性提供了问题的解决办法。唯一的实例是类的一个普通对象，但设计这个类时，让它只能创建一个实例并提供对此实例的全程访问。唯一实例类Singleton在静态成员函数中隐藏创建实例的操作。

单例模式在java和C#里有两个实现方式：1、懒汉模式（lazy initialization）；2、饿汉模式
以下是C#伪代码（摘自网络）
1、懒汉模式
using System; 
namespace csPattern.Singleton 
{ 
public class Singleton 
{ 
static Singleton uniSingleton; 
private Singleton() {} 
static public Singleton instance() 
{ 
if (null == uniSingleton) 
{ 
uniSingleton = new Singleton _lazy(); 
} 
return uniSingleton; 
} 
} 
}

2、饿汉模式
using System; 
namespace csPattern.Singleton 
{ 
public class Singleton 
{ 
static Singleton uniSingleton = new Singleton(); 
private Singleton() {} 
static public Singleton instance() 
{ 
return uniSingleton; 
} 
} 
}

两种实现模式的比较：
1、相同点：两种方式的构造函数都是私有的，对外的接口都是工厂方法
2、不同点：饿汉式是在类装载的时候直接得到该类的实例，可以说是前期绑定的；懒汉式是后期绑定的，类加载的时候uniSingleton是空的，在需要的时候才被创建且仅创建一次。饿汉式的速度快，效率高，但是耗费系统资源；懒汉式则相反。懒汉式还存在一个问题，就是后期绑定不能确保对象只能被实例化一次，这需要对指示类是否实例化的标志设置1个互斥锁，仅允许1个线程访问。这样就可以确保对象只被实例化一次。

懒汉模式的具体实现C#代码
using System; 
using System.Threading; 
using System.Runtime.CompilerServices; 
namespace csPattern.Singleton 
{ 
public class Counter_lazy 
{ 
static Counter_lazy uniCounter; 
private int totNum = 0; 
private Counter_lazy() 
{ 
Thread.Sleep(100); //假设多线程的时候因某种原因阻塞100毫秒 
} 
[MethodImpl(MethodImplOptions.Synchronized)] //方法的同步属性 
static public Counter_lazy instance() 
{ 
if (null == uniCounter) 
{ 
uniCounter = new Counter_lazy(); 
} 
return uniCounter; 
} 
public void Inc() { totNum ++;} 
public int GetCounter() { return totNum;} 
} 
}

　　 不知道大家有没有注意到instance()方法上方的[MethodImpl(MethodImplOptions.Synchronized)] 语句，他就是同步的要点，他指定了instance()方法同时只能被一个线程使用，这样就避免了线程0调用instance()创建完成实例前线程1就来调用instance()试图获得该实例。

　　 根据MSDN的提示，也可以使用lock关键字进行线程的加锁，代码如下：

using System; 
using System.Threading; 
namespace csPattern.Singleton 
{ 
public class Counter_lazy 
{ 
static Counter_lazy uniCounter; 
static object myObject = new object(); 
private int totNum = 0; 
private Counter_lazy() 
{ 
Thread.Sleep(100); //假设多线程的时候因某种原因阻塞100毫秒 
} 
static public Counter_lazy instance() 
{ 
lock(myObject) 
{ 
if (null == uniCounter) 
{ 
uniCounter = new Counter_lazy(); 
} 
return uniCounter; 
} 
} 
public void Inc() { totNum ++;} 
public int GetCounter() { return totNum;} 
} 
}

　　 lock()是对一个对象加互斥锁，只允许一个线程访问其后大括号中语句块，直到该语句块的代码执行完才解锁，解锁后才允许其他的线程执行其语句块。

　　 还可以使用Mutex类进行同步，定义private static Mutex mut = new Mutex();后，修改instance()如下，同样可以得到正确的结果：

static public Counter_lazy instance() 
{ 
mut.WaitOne(); 
if (null == uniCounter) 
{ 
uniCounter = new Counter_lazy(); 
} 
mut.ReleaseMutex(); 
return uniCounter; 
}

http://hi.baidu.com/daijun2007/blog/item/5d102f093c1319c83bc76300.html