一.需求

在遥远的山村，由于交通不便，物资匮泛，很多生活必需品都供应不足。家家户户都需要吃的食盐便是如此。村里有几家杂货店供应日常用品，油盐酱醋倒是都有供应，但是食盐却是常常供不应求，主要是因为食盐需要从很远的地方才可以进货，而由于交通不便每次又运不了太多。

时间长了，几家杂货店的老板看到了其中的商机。有的囤货不卖，等其他几家卖完后加价出售；有的以次充好，销售劣质食盐；有时，几家杂货店老版甚至集体涨价。种种伎俩，到头来吃亏的都是普通村民们。

村长也想过很多办法规范食盐销售，但是由于交通的根本问题一直得不到解决，每次严厉惩治后不久，杂货店就变相涨价，道高一尺，魔高一丈。看来，必须要想一个彻底解决问题的办法。

二.解决方案

经过村委会讨论，大家想出一个好办法：村委会出资采购食盐，平价销售。几个杂货店一看再也涨不了价了，食盐的进货又很麻烦，索性都不再销售食盐了。这样一来，村里只有一个食盐销售的渠道，那就是村委会，再也没有了过去的种种烦恼，村民们无比拥护。

对比一下前后两种食盐销售途径：

第一种：多家杂货店同时销售

这种方式的问题是：每家销售的食盐价格不统一，质量不统一。

第二种：村委会统一销售

这种方法的好处是：销售的食盐价格统一，质量稳定

两相对比，可以看出，针对食盐销售这个场景，统一销售要好于多家零散销售。

三.模式总结

我们上面采用的统一销售的方式其实已经使用了单例模式的思想：全局中只有一个实例，并提供一个全局的访问点。

类图

单例模式类图

使用场景

系统只需要一个实例对象，如系统需要生产唯一的序列号，则序列号生成器最好由唯一对象统一生成。

优点

（1）提供唯一可以访问的实例对象，从而可以更好的控制用户行为
（2）由于只有一个实例，可以减少系统开销

缺点

由于单例类是某个具体的类，而不是接口，因此扩展性不足

几种实现方式

方法一：静态初始化

public class Singleton {
    // 初始化阶段完成实例创建
    private static Singleton instance = new Singleton();
    
    // 将构造方法声明为私有，保证类外部无法调用
    private Singleton() {}
    
    public static Singleton getInstance() {
        return instance;
    }
}

方法二：延迟实例化

方法一中，实现过程简单，而且能保证线程安全，但是有一个缺点：不管instance最终有没有被用到，都已经被实例化，有可能造成资源浪费。另一类方法是延迟实例化：

// 线程不安全的单例模式
public class Singleton {
    private static Singleton instance;

    // 将构造方法声明为私有，保证类外部无法调用
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

上面代码是线程不安全的，在多线程环境下，有可能创建出多个Singleton实例。

如果考虑到线程安全，有几种办法：

// 线程安全的单例模式
public class Singleton {
    private static Singleton instance;

    // 将构造方法声明为私有，保证类外部无法调用
    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

注意到我们对getInstance方法进行了同步操作，保证同一时刻，只能有一个线程进入方法体。但是由于同步操作会降低性能，实时上，一旦完成初始化后，就不需要再进行同步了，实际上是另一种资源浪费。

双重检查加锁：

// 线程安全的单例模式
public class Singleton {
    private volatile static Singleton instance;

    // 将构造方法声明为私有，保证类外部无法调用
    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) { // 如果确实没有被实例化，才进行实例化
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

在这个实现中，一旦完成实例化，就不会再进入synchronized同步块，从而不会造成性能问题。

参考资料

• 《Head First设计模式》
• Graphic Design Patterns

本文已迁移至我的博客：http://ipenge.com/52281.html