设计模式(1) 单例模式

单例模式

Singleton

应用场景：只需要一个实例
(饿汉式=提前加载 懒汉式=按需加载)

写法1 饿(early)汉式 多线程安全 常用

public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();

    private Mgr01() {}

    public static Mgr01 getInstance() {
        return INSTANCE;
    }
}

static: 在类被load时只初始化一次

final: 防止示例被修改

private 构造函数: 禁止被外部访问

缺点

不管是否用到，都被实例化

写法2 懒汉式(LazyLoading)

public class Mgr03 {
    private static Mgr03 instance;

    private Mgr03() {
        try {
            Thread.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

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

INSTANCE不能设置为final，因为有final修饰时必须要赋值。

在构造函数中增加了一些负载，便于测试时发现问题。

缺点

引发线程安全问题。多线程访问时可能会多次构造。

for (int i = 0; i < 100; i++) {
    new Thread(() -> {
        System.out.println(Mgr03.getInstance().hashCode());
    }).start();
}

测试之后发现有很多Hash Code不一样。

写法3 懒汉式加锁 多线程安全 低效

public class Mgr04 {
    public static Mgr04 instance;

    private Mgr04() {}

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

synchronized锁定是class对象。

缺点

每次获取实例都要加锁，效率降低。

写法4 减少同步代码块

public class Mgr05 {
    private static Mgr05 instance;

    private Mgr05() {}

    public static Mgr05 getInstance() {
        if (instance == null) {
            synchronized (Mgr05.class) {	// A
                instance = new Mgr05();
            }
        }
        return instance;
    }
}

缺点

有线程安全问题，不能保证单例模式。因为可能有多个线程同时到达第A行。

写法5 双重保证 多线程安全 懒汉式

public class Mgr06 {
    private static volatile Mgr06 instance;	// D

    private Mgr06() {}

    private Mgr06 getInstance() {
        if (instance == null) {				// C
            synchronized (Mgr06.class) {	// A
                if (instance == null) {		// B
                    instance = new Mgr06();
                }
            }
        }
        return instance;
    }
}

即时有多个线程同时进入第A行，加锁区域也是按顺序执行的，那么第2个进入第B行的人一定不会再创建新实例。

第C行是有必要的，可以加速。因为大部分线程执行完第C行之后不会跳转到第A行。

第D行加volatile的原因是

volatile让变量每次在使用的时候，都从主存中取。而不是从各个线程的“工作内存”。

volatile具有synchronized关键字的“可见性”，但是没有synchronized关键字的“并发正确性”，也就是说不保证线程执行的有序性。

也就是说，volatile变量对于每次使用，线程都能得到当前volatile变量的最新值。但是volatile变量并不保证并发的正确性。

缺点

相对于第一种写法速度慢，因为要加锁。

写法6 内部类 多线程安全 懒汉式 不需要加锁

public class Mgr07 {
    private Mgr07() {}
    
    public static Mgr07 getInstance() {
        return Mgr07Holder.instance;						// A
    }
    
    private static class Mgr07Holder {
        private final static Mgr07 instance = new Mgr07();
    }
}

在Mgr07类被加载时，instance并不会实例化。

只有在执行到第A行的时候，才会加载Mgr07Holder类。

在加载Mgr07Holder类的过程中，会实例化instance。

（由JVM保证Mgr07Holder类只会加载一次）

既能保证多线程安全，又能保证在需要时才会实例化。

写法7 枚举 多线程安全 懒汉式 不需要加锁 防止反射

public enum Mgr08 {
    instance;

    private void business() {	// 即使不写static也是静态的
        // do something
    }
}

枚举类是一种特殊的类，它和普通的类一样，有自己的成员变量、成员方法、构造器 (只能使用 private 访问修饰符，所以无法从外部调用构造器，构造器只在构造枚举值时被调用)；

所有的枚举值都是 public static final 的，且非抽象的枚举类不能再派生子类；

枚举类的所有实例(枚举值)必须在枚举类的第一行显式地列出，否则这个枚举类将永远不能产生实例。

因为构造器只能在枚举值时被调用，没有别的途径了，所以能防止反射。

枚举的构造方法是构造类的。

缺点

使用枚举而不使用类让代码可读性变差。