Singleton

定义 : 

Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。

运用：

1）系统资源，如文件路径，数据库链接，系统常量等

2）全局状态化类，类似AutomicInteger的使用

优缺点：

1）节省内存有利于垃圾回收

2）只能使用在特定的环境下,受限制于JVM和容器
      单例作用范围的前提是在一个ClassLoad下。所以像分布式应用EJB就要用其它的方式来解决单例问题。

如何使用?

第一种形式：

public class Singleton {
	// Early initialization.定义的时候就初始化(不推荐)。
	private static Singleton s = new Singleton();
	private Singleton() {
	}
	public static Singleton getInstance() {
		return s;
	}
}

第二种形式:

public class Singleton {
	private static Singleton s;
	private Singleton() {
	}
	// Lazy initialization. 延迟初始化，使用的时候再初始化，效率较高(推荐)。
	public static Singleton getInstance() {
		if (s == null) {
			s = new Singleton();
		}
		return s;
	}
}

实现的关键：

1. 将所有的构造函数都设为private ，而且必须显示的指定构造函数（不能设置为默认的，因为默认构造函数是package访问权限）。

2. 注意clone()方法。

     例如， 如果基类实现了cloneable接口的话，子类就应该重写该方法。当然，在应用中应该灵活运用各种方法来防止clone()的各种情况。

@Override
protected Object clone() throws CloneNotSupportedException {
	hrow new CloneNotSupportedException();
}

多线程调用singleton方法：

如果在网络编程中，要注意多线程访问singleton引发的一系列问题：

public class Singleton {
	private static Singleton s;
	private Singleton() {
	}
	// 如果多个线程同时访问, 有可能会出现多个实例。
	public static Singleton getInstance() {
		// 第一次初始化时，多个线程同时执行"if (s == null)",判断结果都为真，所以都会执行下面的操作:"s = new Singleton()"，由此引发多个实例的出现。
		if (s == null) {
			s = new Singleton();
		}
		return s;
	}
}

解决方法1（不推荐）：

public class Singleton {
	private static Singleton s;
	private Singleton() {
	}
	// 将该方法加上synchronized关键字。这种方法确实能解决问题，但效率不是很高。因为每次调用该方法的时候，都需要阻塞该方法，但事实上只有第一次初始化的时候才会出现这种情况，所以......
	public static synchronized Singleton getInstance() {
		if (s == null) {
			s = new Singleton();
		}
		return s;
	}
}

上面方法的改进版：

解决方法2（推荐 ）：

public class Singleton {
	private static Singleton singleton;
	private Singleton() {
	}
	public static Singleton getInstance() {
		if (singleton == null) {//1
			synchronized (Singleton.class) {//2
			     singleton = new Singleton();//3
			}
		}
		return singleton;
	}
}

这种写法减少了锁开销，但是在如下情况，却创建了2个对象：
a:线程1执行到1挂起，线程1认为singleton为null
b:线程2执行到1挂起，线程2认为singleton为null
c:线程1被唤醒执行synchronized块代码，走完创建了一个对象
d:线程2被唤醒执行synchronized块代码，走完创建了另一个对象
所以看出这种写法，并不完美。

解决方法3,引入双重检查锁定（推荐 ）：

public class Singleton {
	private static Singleton singleton;
	private Singleton() {
	}
	public static Singleton getInstance() {
		if (singleton == null) {//1
			synchronized (Singleton.class) {//2
				if (singleton == null) {//3
					singleton = new Singleton();//4
				}
			}
		}
		return singleton;
	}
}

 在同步锁代码块内部，再判断一次对象是否为null，为null才创建对象。这种写法已经接近完美：
a:线程1执行到1，已经进入synchronized的时候，线程挂起，线程1占有Singleton.class资源锁；
b:线程2执行到1，当它准备synchronized块时，因为Singleton.class被占用，线程2阻塞；
c:线程1被唤醒，判断出对象为null，执行完创建一个对象
d:线程2被唤醒，判断出对象不为null，不执行创建语句
      如此分析，发现似乎没问题。
      但是实际上并不能保证它在单处理器或多处理器上正确运行；
      问题就出现在singleton = new Singleton()这一行代码。它可以简单的分成如下三个步骤：
              mem= singleton();//1
             instance = mem;//2
             ctorSingleton(instance);//3
       这行代码先在内存开辟空间，赋给singleton的引用，然后执行new 初始化数据，但是注意初始化是要消耗时间。如果此时线程3在执行步骤1的时候，发现singleton 为非null，就直接返回，那么线程3返回的其实是一个没构造完成的对象。
      我们期望1,2,3 按照反序执行，但是实际jvm内存模型，并没有明确的有序指定。

      这归咎于java的平台的内存模型允许“无序写入”。

解决方法3,引入双重检查锁定（不是十分的理解 ）：

public class Singleton {
	private static Singleton singleton;
	private Singleton() {
	}
	public static volatile Singleton getInstance() {
		if (singleton == null) {//1
			synchronized (Singleton.class) {//2
				if (singleton == null) {//3
					singleton = new Singleton();//4
				}
			}
		}
		return singleton;
	}
}

Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。

而volatile使用时有明确的规定：

      对变量的写操作不依赖于当前值；

该变量没有包含在具有其他变量的不变式中；

—— 只有在状态真正独立于程序内其他内容时才能使用 volatile。

但是5的写法，虽然理论上似乎可以解决无序写入问题。实际上并非如此。

（我个人觉得这里对volatile语法说的不够详细，想知道详细的可以看这篇转帖Java 理论与实践: 正确使用 Volatile 变量, http://nkliuliu.iteye.com/blog/980854）

小结：

1）使用同步锁方法，内部锁存在不安全。

2）静态成员直接初始化。