linux动态库单例模式,设计模式之单例模式
方法的提炼和重要，同样的代码加入出现了5遍，只要我们稍微一修改，我们要修改的就是5个地方，可能我们有时候改了几个地方，有1、2个地方漏改了，方法的提炼有助于开发的维护和扩展。好吧，扯远了，回到我们的正题，单例模式。
一、定义：
单例模式(Singleton),保证一个类仅有一个实例，并提供一个访问它的全局访问点。
通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你的实例化多个对象，一个最好的方法就是，让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。 通俗的说就是， 将构造函数声明为private，防止外部类的实例化，提供一个public的方法用于生成对象。
二、UML图
名词解释：
lazy Loading：延迟加载，即在需要的时候载加载类，而不是一开始就加载。
三、常用方法形式
方式1、将构造函数声明为private，提供一个公共的外界调用该对象的方式(lazy Loading，线程不安全)
public class Singleton{
private static Singletoninstance=null;
private Singleton(){ //构造方法是private，堵死了外界用new实例化
//dosomething
}
//获取本类实例的唯一全局访问点
public static Singleton getInstance(){
if(instance==null){ //若实例不存在，创建一个返回，否则返回已有实例
instance=new Singleton();
}
return instance;
}
}
主要缺点：在线程下工作容易出问题，生成多个对象。
方式2、(lazy Loading，线程不安全)
public class Singleton{
private static Singletoninstance=null;
private Singleton(){ //构造方法是private，堵死了外界用new实例化
//dosomething
}
//获取本类实例的唯一全局访问点
public static synchronized Singleton getInstance(){
if(instance==null){ //若实例不存在，创建一个返回，否则返回已有实例
instance=new Singleton();
}
return instance;
}
}
能很好的解决上面说的多线程问题，但是使多线程的变成了单线程的效率，效率很差。一般不适用。
方式3、在类里面生成唯一的对象，每次生成该对象都是返回那唯一的对象。(非Lazy Loading)
public class Singleton{
//在自己内部定义自己的一个实例，只供内部调用
private static Singleton instance=new Singleton();
private Singleton(){
//dosomething
}
//这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance(){
return instance;
}
}
不是延迟加载类型，类在类加载的时候就进行了初始化，这样子会浪费一定的知源，违背了延迟加载的性质。
方式4
public class Singleton{
private static Singletoninstance=null;
private Singleton(){
//dosomething
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(null==instance){
instance=new Singleton();
}
}
}
return instance;
}
}
//这个模式将同步内容下方到if内部，提高了执行的效率，不必每次
获取对象时都进行同步，只有第一次才同步，创建了以后就没必要了。
通过静态代码块(static)的方式，将对象生成延迟了类初始化的时候。
方式5、双重锁机制
public class Singleton
{
//定义一个私有的静态全局变量来保存该类的唯一实例
private static Singleton singleton;
//定义一个只读静态对象
//且这个对象是在程序运行时创建的
private static readonly object syncObject = new object();
///
/// 构造函数必须是私有的
/// 这样在外部便无法使用 new 来创建该类的实例
///
private Singleton()
{}
///
/// 定义一个全局访问点
/// 设置为静态方法
/// 则在类的外部便无需实例化就可以调用该方法
///
///
public static Singleton GetInstance()
{
//这里可以保证只实例化一次
//即在第一次调用时实例化
//以后调用便不会再实例化
//第一重 singleton == null
if (singleton == null)
{
lock (syncObject)
{
//第二重 singleton == null
if (singleton == null)
{
singleton = new Singleton();
}
}
}
return singleton;
}
}
解析：在外层已经判断了singleton == null，为什么在lock()后面还需要判断一次singleton == null呢？
因为，加入有两个线程同时调用了getInstance()方法，它们将都可以通过第一重singleton == null的判断，然后由于lock机智，这两个线程则一个进入，另一个在排队等待，必须要其中的一个进入并出来后，另外一个才能进入，因此如果没有了第二重instance是否为空的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的了。
