Singleton（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也将被实例化一次. 这时会出现问题，单例不再是单例，两个线程创建的实例不是同一实例.

为了解决上述问题单例模式 singleton，我们可以锁定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将方法标记为同步方法.

很多时候，我们在系统中使用的对象只有一个，并且只需要一个. 如果大量的实例化将导致性能问题或其他不必要的麻烦. 在我们的日常使用中，有很多情况，例如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将方法标记为同步方法.

很多时候，我们在系统中使用的对象只有一个，并且只需要一个. 如果大量的实例化将导致性能问题或其他不必要的麻烦. 在我们的日常使用中，有很多情况，例如Windows操作系统的资源管理器，只能使用一个资源管理器.

如何设计此类，使其只能产生一个实例？我们必须确保没有此类的额外实例.

我们都知道执行类实例时必须使用类构造函数. 如果将类构造函数设置为private并禁止外部实例化，则可以轻松解决问题.

我们私有化构造函数，在类中创建一个实例，然后将其返回. 这形成了我们的单例，确保在类中间只有一个实例.

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

这样单例模式 singleton，我们的班级就形成了一个单例.

上面的措辞是单例模式下的惰性模式. 为什么将其称为延迟模式，因为该对象仅在使用时才会初始化.

但是以上编写存在一些问题. 当线程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将方法标记为同步方法.

本文来自电脑杂谈，转载请注明本文网址：
https://www.pc-fly.com/a/jisuanjixue/article-242675-1.html