单例模式

Wed, 01 Jul 2020 17:58:01 +0800

🥇单例模式(Singleton)

问题产生

很多时候，我们在系统中使用的对象有且仅仅需要一个，如果大量的实例化反而会产生性能问题或其他的不必要的麻烦。在我们的日常使用中有很多单例情况，比如说 windows 操作系统的资源管理器，有且只有一个资源管理器可以被使用。

如何设计该类，使其只能产生一个实例？我们必须保证这个类不能有多余的实例。

我们都知道在进行类的实例的时候，必须使用类构造器来进行，如果我们将类构造器设置为私有（private），禁止外部进行实例化时，便可以很方便的解决该问题。

懒汉模式

我们将构造器私有化，在类的内部进行实例，并且进行返回。这样便形成了我们的单例，确保了类中间只有一个实例。

class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
        fun getInstance(): Singleton {
            if (instance == null) {
                instance = Singleton()
            }
            return instance!!
        }
    }
}

这样我们的类就形成了一个单例。

如上的写法是单例模式中的懒汉模式，为什么叫懒汉模式，因为该对象在使用的时候才会初始化。

线程安全的懒汉模式

但是上述的写法存在一定的问题。当线程 A 访问该方法时，代码执行到 getInstance 还没有进行判断或者实例化的时候，线程 B 也开始进行访问该方法。那么此时线程A就会进行一次实例化，线程 B 也会进行一次实例化。此刻就会出现问题，单例不再单例，两个线程创建的实例并不是同一个实例。

为了解决上述问题，我们可以对 getInstance() 进行加锁。确保同一时刻只能由一个线程访问getInstance 方法。这样便解决了线程同步问题。

class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null
        @Synchronized
        fun getInstance(): Singleton {
            if (instance == null) {
                instance = Singleton()
            }
            return instance!!
        }
    }
}

通过 @Synchronized 标记该方法为一个同步方法。

双检查锁

通过 @Synchronized 注解解决了多线程访问问题，但是随之而来的又出现了性能问题。如果线程 A 在执行 getInstance 方法的时候，线程 B 就必须等待。反之亦然。如果是一个高并发系统，那么就会带来巨大的性能损耗，总是有一堆线程在等待中。

面对上述的问题，那么就应该做出新的改变。公共写是危险操作，而公共读确实安全的。所以我们在进行创建的时候加锁，而不是在整个方法上。

class Singleton private constructor() {
    companion object {
        private var instance: Singleton? = null

        fun getInstance(): Singleton {
            if (instance == null) {
                synchronized(Singleton::class.java) {
                    if (instance == null) {
                        instance = Singleton()
                    }
                }
            }
            return instance!!
        }
    }
}

这里在加锁前和加锁后都进行了判断，通过这样的双检测来解决了功能上单例问题和性能上问题。

如果加锁后不检查会发生什么？

如果加锁后不检查，那么假设两个线程 A、B 同时进入了 getInstance 并且都执行到加锁前，如果不进行判断，那么只要其中一个线程申请了加锁，那么另外一个就要等待，当前一个释放锁后，后面的就会加锁继续实例化。此时又会产生两个不同的实例。而加锁后判断就避免了这样问题。

然而在 kotlin 中提供了更简单实现方式，通过 by lazy 来实现双检查锁。

class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) { Singleton() }
    }
}

饿汉模式

对于单例的另一个模式那就是饿汉模式。而饿汉模式的名字由来是因为饿了就需要吃，所以提前就都准备好(初始化)。因为已经提前都初始化好了，所以也不存在上述的线程安全问题。

object Singleton

总结

单例模式和其他创建型模式不同，单例更重要的是解决多次创建带来的性能上的问题。

单例模式 - 标签 - ISLAND