设计模式之 - 单例模式

“ 设计模式详解。”

《Design Patterns: Elements of Reusable Object-Oriented Software》（即《设计模式》一书），由 Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides 合著（Addison-Wesley，1995）。这几位作者常被称为"四人组（Gang of Four）"。

设计模式不是一种规定，也不需要为了设计模式而设计，错误的应用设计模式反而会让代码变得复杂，难以维护。相反，正确的应用设计模式，可以让我们的代码更加健壮，扩展性更好，逻辑也更加清晰。

设计模式一书针对不同的应用场景，列出了各自的最佳实践。随着技术的不断发展，可能一些范例已经不再适用，但是这本书带给我们思想上的指引，意义是非常重大的。设计模式一书，根据应用场景，大致分为建造型、结构型、行为型，总共 23 种，并提出了 6 大原则。

本文开始，试着详细介绍每种设计模式，有解释不到位，理解存在偏差的地方，请提出宝贵意见。

建造型-单例模式

单例模式 Singleton，即一个实例，类本身提供获取全局唯一的实例的方式，其它人使用的时候不需要重新创建对象，只需要通过类获取实例即可。

应用场景：配置类、工厂类等

关键点：

1、将实例变成成员变量。

2、将默认构造方法改为private。

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。

2、避免对资源的多重占用（比如写文件操作）。

实现方式：分为懒汉式 Lazy ，饿汉式，下面依次介绍

01

—

饿汉式

**
**

所谓饿汉式，即程序从硬盘加载到内存中，即实现初始化，由 JVM 实现，线程安全。

**
**

方式 1

public class Singleton01 {    private static final Singleton01 INSTANCE=new Singleton01();    private Singleton01(){}    public void m(){        System.out.println("hello singleton1");    }    public static Singleton01 getInstance(){        return INSTANCE;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton01.INSTANCE.hashCode())).start();        }    }}

输出：

105995111910599511191059951119105995111910599511191059951119105995111910599511191059951119

可以看到打印的是同一个对象。

方式 2 将实例过程放到静态代码块中

public class Singleton02 {    private static final Singleton02 INSTANCE;    static {        INSTANCE = new Singleton02();    }    private Singleton02() {    }    public void m() {        System.out.println("hello singleton2");    }    public static Singleton02 getInstance() {        return INSTANCE;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton02.INSTANCE.hashCode())).start();        }    }}

输出：

2062686098206268609820626860982062686098206268609820626860982062686098206268609820626860982062686098

方式 3 使用枚举的方式

public enum Singleton08 {    INSTANCE    ;    public void m(){        System.out.println("hello singleton8");    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton08.INSTANCE.hashCode())).start();        }    }}

输出：

2062686098206268609820626860982062686098206268609820626860982062686098206268609820626860982062686098

方式 1 和 2，除了创建实例的过程，其余均相同，理论上没有区别，比较简单，应用也最多。方式 3 使用枚举实现，这种方式是非常安全的，不能通过反射创建实例。整体来看，饿汉式这种方式，也存在一些问题，即我们没有使用这个对象，但是已经实例化了，能不能在我使用的时候才进行实例化呢，那就是懒汉式，即懒加载。下面演示一下懒汉式实现方法。

02

—

懒汉式

**
**

懒汉式，即在第一次调用的时候才真正的实例化，在加载的时候不进行实例化。

方式 4

public class Singleton03 {    private static Singleton03 instance;    private Singleton03() {    }    public void m() {        System.out.println("hello singleton3");    }    public static Singleton03 getInstance() {        if (null == instance) {            instance = new Singleton03();        }        return instance;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton03.getInstance().hashCode())).start();        }    }}

输出：

2062686098105995111910599511191059951119105995111910599511191059951119105995111910599511191059951119

可以看到，多线程的情况下，会概率出现创建多个对象的情况，那是因为，当一个线程发现当前实例为 null，需要创建一个对象，在这个过程中另一个线程也发现实例为 null，也去创建实例，导致出现多个实例，因此我们使用方式 4 来解决。

方式 5

public class Singleton04 {    private static Singleton04 instance;    private Singleton04() {    }    public void m() {        System.out.println("hello singleton4");    }    public static synchronized Singleton04 getInstance() {        if (null == instance) {            try {                instance = new Singleton04();                Thread.sleep(100);            } catch (InterruptedException e) {                e.printStackTrace();            }        }        return instance;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton04.getInstance().hashCode())).start();        }    }}

输出：

1585461681158546168115854616811585461681158546168115854616811585461681158546168115854616811585461681

此方式在方法上面增加 synchronized 关键字，将方法变成同步方法，因为 synchronized 关键字使用的重量级锁，上下文切换影响效率，为了减少锁的范围，可能会想到下面的方式优化代码。

方式 6

public class Singleton05 {    private static Singleton05 instance;    private Singleton05() {    }    public static Singleton05 getInstance() {        if (null == instance) {            synchronized (Singleton05.class) {                try {                    Thread.sleep(1);                } catch (InterruptedException e) {                    e.printStackTrace();                }                instance = new Singleton05();            }        }        return instance;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(() -> System.out.println(Singleton05.getInstance().hashCode())).start();        }    }}

输出：

29574062727790602098586510057349981047393000410312950991585461681206268609815881478521059951119

运行发现，这样是无法实现，因为多线程运行时，速度非常快，导致多个线程同时阻塞住，而获取到锁的时候就会去创建实例，因此会产生多个实例，因此需要使用下面的方式。

方式 7：DCL 方式（Double Check Locking）

public class Singleton06 {    private static volatile Singleton06 instance;    private Singleton06() {    }    public static Singleton06 getInstance() {        if (null == instance) {            synchronized (Singleton06.class) {                if (null == instance) {                    try {                        Thread.sleep(1);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    instance = new Singleton06();                }            }        }        return instance;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(() -> System.out.println(Singleton06.getInstance().hashCode())).start();        }    }}

输出：

2062686098206268609820626860982062686098206268609820626860982062686098206268609820626860982062686098

此种方式是比较完美的解决方式。

双重检查的意义：线程由于无法获取锁，处于阻塞状态，当线程获取锁时，第二次检查一下是否对象创建完成，如果已创建完成，直接返回此对象即可。

DCL 加 volatile 的意义：保证线程可见，防止指令重排序

方式 8：内部类的方式

public class Singleton07 {    private Singleton07() {    }    private static class  SingletonHold{        private final static Singleton07 INSTANCE=new Singleton07();    }    public static Singleton07 getInstance() {        return SingletonHold.INSTANCE;    }    public static void main(String[] args) {        for (int i = 0; i < 10; i++) {            new Thread(()-> System.out.println(Singleton07.getInstance().hashCode())).start();        }    }}

输出：

868202916868202916868202916868202916868202916868202916868202916868202916868202916868202916

使用内部类，可以将在类加载的时候不会实例化，但是调用的时候会进行实例化，比较好的方式，也是线程安全的。

总结：

单例模式是非常常用的设计模式，看似简单，其实这里面还是有许多值得研究学习。

设计模式不是为了生搬硬套，应该根据实际情况，灵活的运用，后面会介绍更多的设计模式和设计原则，欢迎大家一起讨论学习。

欢迎关注我们