说起单例模式，大家都不陌生，它是简单而又经常用的设计模式之一。但是，你真的会用单例模式吗？
完美的单例模式
（1）单例（ps：废话，看名字就知道啦~）
（2）延迟加载
（3）线程安全
（4）没有性能问题
（5）防止反序列化产生新对象
单例模式的实现方式
通常它的实现方式有两种：
public class MyEngine{
public static MyEngine instance = new MyEngine();
private void MyEngine(){
}
public static MyEngine getInatance(){
return instance;
}
}这种方法写法最简单，缺点是一旦类被加载就会去初始化单例，没有实现延迟加载。而且当实现了Serializable接口后，反序列化时单例会被破坏。 实现Serializable接口需要重写readResolve，才能保证其反序列化依旧是单例：
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;
}
}2、懒汉式：按需加载
（1）最简单的懒汉式单例
public class MyEngine{
public static MyEngine instance;
private void MyEngine(){
}
public static MyEngine getInatance(){
if(instance==null){
instance = new MyEngine();
}
return instance;
}
}这样只有调用getInstance才会初始化单例，实现了延迟加载。但是，如果多个线程同时调用getInstance时，可能会创建出多个instance对象，因此需要进行同步。同步的话，加个synchronized关键字即可。
（2）线程安全的懒汉式单例
public class MyEngine{
public static MyEngine instance;
private void MyEngine(){
}
public static synchronized MyEngine getInatance(){
if(instance==null){
instance = new MyEngine();
}
return instance;
}
}上面的做法确实保证了线程的安全，但是会引起性能问题，因为在同一时间只能有一个线程能去调用getInstance。所以有必要对其优化下。
（3）线程安全的懒汉式单例：双重检验锁
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 = new MyEngine()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。
给 instance 分配内存
调用 MyEngine 的构造函数来初始化成员变量
将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）
但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 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;
}
}这种做法可惜不是懒汉式，而且对于需要传递参数构造单例的话，就无法使用了。
2、静态内部类
public class MyEngine{
/**
* 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，
* 而且只有被调用到才会装载，从而实现了延迟加载
*/
public static class MyEngineHolder {
private static final MyEngine INSTANCE = new MyEngine();
}
private void MyEngine(){
}
public static MyEngine getInatance(){
return MyEngineHolder.INSTANCE;
}
}这种写法仍然使用JVM本身机制保证了线程安全问题；由于 MyEngineHolder 是私有的，除了 getInstance() 之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
3、枚举enum
public enum MyEngine{
INSTANCE;
}我们通过MyEngine.INSTANCE来访问实例，且创建枚举默认是线程安全的，还能防止反序列化导致重新创建新的对象。但是一般很少看见这样写的，可能是大家不熟悉这样的写法吧。
471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
