单例模式

1.什么是单例模式？

Singleton的英文意思是单独，也就是一个人，应用在面向对象语言上，通常翻译成「单例」，单一的实例「Instance」。Singleton模式可以保证一个类仅有一个实例，并提供一个访问这个实例的方法。

Java源码中就拥有许多的设计模式，其中Java.lang.Runtime类就实现了单例模式，每个Java程序运行时，都有唯一一个Runtime实例，透过静态方法getRuntime（），获得实例，例如：

Runtime runtime = Runtime.getRuntime();

Java.lang.Runtime类的部分源码：

2.单例模式解决什么需求？

当一个类被设计来管理共享资源的时候，我们仅需实例化一个对象，比方说：线程池、缓存、日志对象等等。如果new出多个实例，那么容易导致一些问题产生，如资源使用过量，程序异常，结果不一致等等。

举个栗子：当在一个Web应用中连接数据库的Connection对象，如果每次访问都new一个实例，那么当发生成千上万甚至更多的访问在短时间内并发，这将导致服务器资源的大量开销，因为对象不能被垃圾收集器及时的回收。但是，如果服务器对此仅实例化一次，每次Connection对象被使用后放回线程池，其他访问连接时继续使用它，便使得服务器性能大大的提升，这就是单例模式的实践。

3.单例模式的实现

VERSION 1:懒汉式之幼年期

public class Singleton {
    private static Singleton singleton = null;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
    return singleton;
    }
}

上面这段代码中，关于Singletom模式的几个特点：

1.私有（private）的构造函数，表明这个类是不可能从外部形成实例了。

2.即然这个类是不可能形成实例，那么，我们需要一个静态的方式让其形成实例：getInstance()。

3.在getInstance()中，先做判断是否已形成实例，如果已形成则直接返回实例，否则创建实例。

4.所形成的实例保存在自己类中的私有成员中。

5.我们取实例时，仅需要使用Singleton.getInstance()就行了。

上面这段代码是有缺陷的，仅适合单线程情况。在多线程情况下，所有的全局共享的东西都会变得非常的危险，上述代码也一样，在多线程情况下，如果多个线程同时调用getInstance()的话，那么，可能会有多个进程同时通过 (singleton== null)的条件检查，于是，多个实例就创建出来，并且很可能造成内存泄露问题。

VERSION 2:懒汉式之成长期

public class Singleton {
    private static Singleton singleton = null;
    
    private Singleton() {}

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

OK，既然可能产生多个线程通过 (singleton== null)的条件检查，那么我们将在VERSION 2中使用线程互斥或同步来避免产生多个实例，代码如上。

虽然使用synchronized方法会帮助我们同步所有线程，让并行的线程变成串行，一个一个地去new，但最终结果与VERSION 1无异，还是会出现很多实例。所以接下来需要将（singleton == null）条件也同步起来。

VERSION 3:懒汉式之成熟期

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

现在的代码已经不会出现多线程new出多个实例的情况了，可是稍有不足的是，所有调用getInstance()方法的线程都得同步。正常情况下，创建对象的动作仅有一次，后面的动作均是读取对象。如果每次读取对象需要经过线程同步，将会影响程序的性能，所以接下来更好方法是：在线程同步实例化对象之前，先进行（siglenton == null）的判断，如果不为空，则直接读取对象。

VERSION 4:懒汉式之完全体

public class Siglenton {
    private static Siglenton siglenton = null;
    
    private Siglenton() {}
    
    public static Siglenton getInstance() {
        if (siglenton == null) {
            synchronized (Siglenton.class) {
                if (siglenton == null) {
                    siglenton = new Siglenton();
                }
            }
        }
        return siglenton;
    }
}

好的，这个版本称为「双重检查Double-Check」。下面是说明：

1.第一个条件是说，如果实例创建了，那就不需要同步了，直接返回实例。

2.不然，我们就开始同步线程。

3.第二个条件是说，如果被同步的线程中，有一个线程创建了对象，那么别的线程无需再创建了。

这是稍微不错的单例模式，可是在一些极端的情况下还是会出问题，引用陈皓大叔说的：

无论你的代码写得有多好，其只能在特定的范围内工作，超出这个范围就要出Bug。

OK，那么最后，我们就不继续纠缠懒汉式的单例模式了。

关于单例模式的实现方式还有很多种，比如接下来展示的：饿汉式、静态内部类，枚举等等。

饿汉式：

public class Singleton {  
    private static Singleton singleton = new Singleton();  
    
    private Singleton() {}  
    
    public static Singleton getInstance() {  
        return instance;  
    }  
}

静态内部类：

public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton singleton = new Singleton();  
    }  
    
    private Singleton() {} 
     
    public static final Singleton getInstance() {  
        return SingletonHolder.sigleton;  
    }  
}

枚举：

public enum Singleton {  
    SINGLETON;  
    
    public void whateverMethod() {  
    }  
}

参考：

「1」:Double-checked locking: Clever, but broken

「2」:Difference between static class and singleton pattern?

「3」:深入浅出单实例Singleton设计模式

「4」:单例模式的七种写法

转载于:https://my.oschina.net/OrangeHatrb/blog/208731