方法的提炼和重要，同样的代码加入出现了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();
///

?

解析：在外层已经判断了singleton == null，为什么在lock（）后面还需要判断一次singleton == null呢？

? ? 因为，加入有两个线程同时调用了getInstance()方法，它们将都可以通过第一重singleton == null的判断，然后由于lock机智，这两个线程则一个进入，另一个在排队等待，必须要其中的一个进入并出来后，另外一个才能进入，因此如果没有了第二重instance是否为空的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这就没有达到单例的目的了。