设计模式之单例模式

前言

本篇文章主要介绍的是设计模式中的单例模式的实现方式。

什么是设计模式

设计模式其实就是前辈们长时间的试验和错误总结出来的，针对软件开发过程中面临的一般问题的解决方案。

设计模式分类

根据其目的（模式是用来做什么的）可分为创建型，结构型和行为型三种：
• 创建型模式主要用于创建对象。
• 结构型模式主要用于处理类或对象的组合。
• 行为型模式主要用于描述对类或对象怎样交互和怎样分配职责。

单例模式

单例模式属于创建型模式，它提供了一种创建对象的最佳方式。这种模式保证一个系统中的某个类只有一个能够被外界访问的实例。

单例模式的使用场景

在程序中比较常用的是数据库连接池、线程池、日志对象等等。

单例模式的实现

单例模式的实现有5种方式，分别是懒汉式、饿汉式、双重锁、静态内部类、枚举。

1.懒汉式

这种方式是最基本的实现方式，但是不支持多线程，线程不安全。

实现：定义一个私有的构造方法，定义一个该类静态私有的变量，然后定义一个公共的静态方法，在静态方法内对变量的值进行空判断，不为空直接返回，如果为空重新构建并赋值给改该变量。

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

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

测试：

public class SingletonTest {
    public static void main(String[] args) {
		System.out.println(Singleton.getInstance()==Singleton.getInstance());
    }
}

这里输出的是true，可以看到两次获取的实例其实是同一个。

采用多线程方式：

public class SingletonTest {
    public static void main(String[] args) {
        new Thread(new SingletonThread()).start();
        new Thread(new SingletonThread()).start();
    }
}
class SingletonThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Singleton.getInstance().hashCode());
    }
}

此时两次输出的哈希值时而相同时而不同，出现线程不安全问题。

这种方式可以在静态方法的方法声明上加synchronized关键字来确保线程安全，但是效率低下。

2.饿汉式

这种方式没有加锁，所以效率会提高。虽然没有加锁，但是也是线程安全的，这是因为它在类加载时就初始化了，而一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例。所以饿汉式天生就是线程安全的。但也正是因为它在类加载的时候就初始化了，会一直占用内存，导致内存浪费。

定义一个私有的构造方法，并将自身的实例对象设置为一个静态私有属性,然后通过公共的静态方法调用返回实例。

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

    public static Singleton getInstance() {
        return singleton;
    }
}

测试：和懒汉式的测试代码一样，普通方式获取的两个实例是同一个，输出true，多线程方式获取的哈希值是一样的。

3.双重锁

定义一个私有构造方法，通过volatile定义静态私有变量，保证了该变量的可见性，然后定义一个共有的静态方法，第一次对该对象实例化时与否判断，不为空直接返回，提升效率；然后使用synchronized 进行同步代码块，防止对象未初始化时，在多线程访问该对象在第一次创建后，再次重复的被创建；然后第二次对该对象实例化时与否判断，如果未初始化，则初始化，否则直接返回该实例。

第一次判空是为了提升效率，只有第一次实例化的时候需要加锁，而不是每次请求都加锁
第二次是为了进行同步，避免多线程问题。

public class Singleton {
    private volatile static Singleton singleton;
    private Singleton() {}

    public static Singleton getInstance() {
        if (singleton == null) { //#1
            synchronized (Singleton.class){ //#2
                if (singleton == null) { //#3
                    singleton = new Singleton(); //#4
                    System.out.println(Thread.currentThread().getName() + ": singleton is initalized...");//#5.1
                } else {
                    System.out.println(Thread.currentThread().getName() + ": singleton is not null now...");//#5.2
                }
            }
        }
        return singleton;
    }
}

双重锁这种方式实现单例的关键点在于两次判空、加锁、以及volatile关键字，这里解释一下volatile关键字在这种方式实现单例起到的作用。

volatile有两个特性
可见性：证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
有序性：禁止进行指令重排序。

假设不加volatile关键字，这段代码可能输出的是
thread1: uniqueInstance is initalized...
thread2: uniqueInstance is initalized...

过程分析：
1.thread1进入#1，获取到singleton为空，此时thread1让出CPU资源给thread2，thread1进入#1，却在#2外等待。
2.thread2进入#1，获取到singleton为空，此时thread2让出CPU资源给thread1，
thread2进入#1，却在#2外等待。
3.thread1会依次执行#2，#3，#4，#5.1，最终在thread2里面实例化了singleton。thread1执行完毕让出CPU资源给thread2。
4.thread2接着#1跑下去，跑到#3的时候，由于#1里面拿到的singleton还是空（并没有及时从thread1里面拿到最新的），所以thread2仍然会执行#4，#5.1
5.最后在thread1和thread2都实例化了singleton。

这样的话，singleton实例化了两次。而volatile关键字修饰变量的作用就是让第四步中thread2及时拿到thread1更新的的singleton,使它最后执行#5.2，这里利用的就是可见性。

volatile使singleton重排序被禁止，所有的写（write）操作都将发生在读（read）操作之前。也就确保了thread1的实例化是发生在thread2第二次判空之前的。

当然，这只是一种假设的情况，没有重现过，太难模拟了，但是确实存在。

4.静态内部类

这种方式也是利用了类加载机制，只不过它不像饿汉式一样，Singleton类被加载就实例化，这样就没有达到懒加载的效果。外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化instance，因此不占内存。而静态内部类实现单例保证线程安全，是由JVM决定的。

public class Singleton {
    private Singleton() {}

    private static class SingletonInner {
        private static Singleton singleton = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInner.singleton;
    }
}

5.枚举

枚举是JDK1.5之后的特性。无偿提供序列化机制，防止多次实例化。

public enum Singleton {  
    INSTANCE;  
}

测试：输出的哈希值都是一样的。

public class SingletonTest {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new SingletonThread()).start();
        }

    }
}

class SingletonThread implements Runnable {
    @Override
    public void run() {
        System.out.println(Singleton.INSTANCE.hashCode());
    }
}

PS：第2.3.4种测试代码和第一种是一样的。

总结：
一般情况下使用饿汉式；如果要求实现懒加载，则使用静态内部类；如果涉及到反序列化创建对象时，可以尝试使用枚举方式。

CSDN：https://blog.csdn.net/qq_27682773
简书：https://www.jianshu.com/u/e99381e6886e
博客园：https://www.cnblogs.com/lixianguo
个人博客：https://www.lxgblog.com