浅析设计模式(六)——单例模式

单例模式（Singleton，创建型模式）

本文的结构：

• 一、单例模式的定义
• 二、单例模式的示例
• 三、参考

一、单例模式的定义

　　定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

       单例，顾名思义，就是只有一个实例，因此需要将构造函数私有化，使其不能随意实例化。

　　好处：减少对象的创建和销毁，提高性能；资源共享；

二、单例模式的示例

1、经典的单例模式：非线程安全的写法。

public class ClassicSingleton {
    private static ClassicSingleton uniqueInstance;
     
    private ClassicSingleton() {}
 
    //not thread safe
    public static ClassicSingleton getInstance() {
        if (null == uniqueInstance) {
            uniqueInstance = new ClassicSingleton();
        }
        return uniqueInstance;
    }
 
    // other useful methods here
    public String getDescription() {
        return "I'm a classic ClassicSingleton!";
    }
}

2、线程安全的做法

　　对上面的经典形式进行同步，使其在多线程环境下变得安全：

public class ThreadSafeSingleton {
    private static ThreadSafeSingleton uniqueInstance;
     
    // other useful instance variables here
 
    private ThreadSafeSingleton() {}
 
    public static synchronized ThreadSafeSingleton getInstance() {
        if (null == uniqueInstance) {
            uniqueInstance = new ThreadSafeSingleton();
        }
        return uniqueInstance;
    }
 
    // other useful methods here
    public String getDescription() {
        return "I'm a thread safe ThreadSafeSingleton!";
    }
}

3、双重检查加锁

　　注意到这里内部实例加了volatile修饰，保证线程的可见性。

public class DoubleCheckLockingSingleton {
    private volatile static DoubleCheckLockingSingleton uniqueInstance;
     
    private DoubleCheckLockingSingleton() {}
 
    public static DoubleCheckLockingSingleton getInstance() {
        if (null == uniqueInstance) {
            synchronized (DoubleCheckLockingSingleton.class) {
                if (null == uniqueInstance) {
                    uniqueInstance = new DoubleCheckLockingSingleton();
                }
            }
        }
        return uniqueInstance;
    }
}

4、内部类实现单例

public class InnerClassSingleton {
    private InnerClassSingleton() {}

    public static InnerClassSingleton getInstance() {
        return Nested.instance;
    }

    private static class Nested {
        public static InnerClassSingleton instance = new InnerClassSingleton();
    }
}

5、恶汉模式单例：借助类的惟一一次初始化进行加载

public class HungrySingleton {
    
    private static HungrySingleton uniqueInstance = new HungrySingleton();
     
    private HungrySingleton() {}
 
    public static HungrySingleton getInstance() {
        return uniqueInstance;
    }
    
    // other useful methods here
    public String getDescription() {
        return "I'm a statically initialized Singleton!";
    }
}

三、参考

1、参考《Head First设计模式》和GoF《设计模式：可复用面向对象软件的基础》

2、代码可参考【github传送门】。

待办：单例如何回收、内部安全问题等。