说起单例模式，大家都不陌生，它是简单而又经常用的设计模式之一。但是，你真的会用单例模式吗？
完美的单例模式
（1）单例（ps：废话，看名字就知道啦~）
（2）延迟加载
（3）线程安全
（4）没有性能问题
（5）防止反序列化产生新对象
单例模式的实现方式
通常它的实现方式有两种：
public class MyEngine{
public static MyEngine instance = new MyEngine();
private void MyEngine(){
}
public static MyEngine getInatance(){
return instance;
}
}public class MyEngine implement Serializable{
public static MyEngine instance = new MyEngine();
private void MyEngine(){
}
public static MyEngine getInatance(){
return instance;
}
/**
* 如果实现了Serializable, 必须重写这个方法：没有找到这个方法？
*/
private Object readResolve() throws ObjectStreamException {
return instance;
}
}public class MyEngine{
public static MyEngine instance;
private void MyEngine(){
}
public static MyEngine getInatance(){
if(instance==null){
instance = new MyEngine();
}
return instance;
}
}public class MyEngine{
public static MyEngine instance;
private void MyEngine(){
}
public static synchronized MyEngine getInatance(){
if(instance==null){
instance = new MyEngine();
}
return instance;
}
}public class MyEngine{
public static MyEngine instance;
private void MyEngine(){
}
public static MyEngine getInatance(){
if(instance==null){//第一次检查
synchronized(MyEngine.class){
if(instance==null){//第二次检查
instance = new MyEngine();
}
}
}
return instance;
}
}我们只需要将 instance 变量声明成 volatile 就可以了。
public class MyEngine{
public static volatile MyEngine instance;
private void MyEngine(){
}
public static MyEngine getInatance(){
if(instance==null){//第一次检查
synchronized(MyEngine.class){
if(instance==null){//第二次检查
instance = new MyEngine();
}
}
}
return instance;
}
}有些人认为使用 volatile 的原因是可见性，也就是可以保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但其实是不对的。使用 volatile 的主要原因是其另一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操作后面会有一个内存屏障（生成的汇编代码上），读操作不会被重排序到内存屏障之前。比如上面的例子，取操作必须在执行完 1-2-3 之后或者 1-3-2 之后，不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作（这里的“后面”是时间上的先后顺序）。
但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能完全避免重排序，主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，所以在这之后才可以放心使用 volatile。
相信你不会喜欢这种复杂又隐含问题的方式，当然我们有更好的实现线程安全的单例模式的办法。
其他线程安全方式
我们可以利用JVM加载类的机制去实现同步控制。
public class MyEngine{
//类加载时就初始化
public static final MyEngine INSTANCE = new MyEngine();
private void MyEngine(){
}
public static MyEngine getInatance(){
return INSTANCE;
}
}public class MyEngine{
/**
* 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，
* 而且只有被调用到才会装载，从而实现了延迟加载
*/
public static class MyEngineHolder {
private static final MyEngine INSTANCE = new MyEngine();
}
private void MyEngine(){
}
public static MyEngine getInatance(){
return MyEngineHolder.INSTANCE;
}
}public enum MyEngine{
INSTANCE;
}