网站建设襄阳,门户网站模板 图片,南宁百度推广代理商,网站建设服务公司有哪些单例模式保证一个类仅有一个实例#xff0c;并提供一个全局访问点来访问它#xff0c;这个类称为单例类。可见#xff0c;在实现单例模式时#xff0c;除了保证一个类只能创建一个实例外#xff0c;还需提供一个全局访问点。
Singleton is a creational design pattern t…单例模式保证一个类仅有一个实例并提供一个全局访问点来访问它这个类称为单例类。可见在实现单例模式时除了保证一个类只能创建一个实例外还需提供一个全局访问点。
Singleton is a creational design pattern that lets you ensure that a class has only one instance,
while providing a global access point to this instance. 为提供一个全局访问点可以使用全局变量但全局变量无法禁止用户实例化多个对象。为此可以让类自身负责保存它的唯一实例。这个类可以保证没有其他实例可以被创建并且它可以提供一个访问实例的方法。 综上单例模式的要点有三个一是某个类只能有一个实例二是这个类必须自行创建这个实例三是这个类必须自行向整个系统提供这个实例。
结构设计
单例模式只有一个角色 Singleton单例类用来保证实例唯一并提供一个全局访问点。为实现访问点全局唯一可以定义一个静态字段同时为了封装对该静态字段的访问可以定义一个静态方法。为了保证实例唯一这个类还需要在内部保证实例的唯一。基于以上思考单例模式的类图表示如下
伪代码实现
接下来将使用代码介绍下单例模式的实现。单例模式的实现方式有很多种主要的实现方式有以下五种饿汉方式、懒汉方式、线程安全实现方式、双重校验方式、惰性加载方式。
(1) 饿汉方式
饿汉方式就是在类加载的时候就创建实例因为是在类加载的时候创建实例所以实例必唯一。由于在类加载的时候创建实例如果实例较复杂会延长类加载的时间。
// 1. 定义单例类提供全局唯一访问点保证实例唯一
public class HungrySingleton {// (1) 声明并实例化静态私有成员变量(在类加载的时候创建静态实例)private static final HungrySingleton instance new HungrySingleton();// (2) 私有构造方法private HungrySingleton() {}// (3) 定义静态方法提供全局唯一访问点public static HungrySingleton getInstance() {return instance;}public void foo() {System.out.println(---------do some thing in a HungrySingleton instance---------);}
}
// 2. 客户端调用
public class HungrySingletonClient {public void test() {// (1) 获取实例HungrySingleton singleton HungrySingleton.getInstance();// (2) 调用实例方法singleton.foo();}
}(2) 懒汉方式
懒汉方式就是在调用实例获取(如getInstance())接口时再创建实例这种方式可避免在加载类的时候就初始化实例。
// 1. 定义单例类提供全局唯一访问点保证实例唯一
public class LazySingleton {// (1) 声明静态私有成员变量private static LazySingleton instance;// (2) 私有构造方法private LazySingleton() {}// (3) 定义静态方法提供全局唯一访问点public static LazySingleton getInstance() {// 将实例的创建延迟到第一次获取实例if(instance null) {instance new LazySingleton();}return instance;}public void foo() {System.out.println(---------do some thing in a LazySingleton instance---------);}
}
// 2. 客户端调用
public class LazySingletonClient {public void test() {// (1) 获取实例LazySingleton instance LazySingleton.getInstance();// (2) 调用实例方法instance.foo();}
}需要说明的是对多线程语言来说(如java语言)懒汉方式会带来线程不安全问题。如果在实例前执行判空处理时至少两个线程同时进入这行代码则会创建多个实例。 所以对于多线程语言来说为了保证代码的正确性还需在实例化的时候保证线程安全。
(3) 线程安全实现方式
为保证线程安全可以在实例判空前进行线程同步处理如添加互斥锁。
// 1. 定义单例类提供全局唯一访问点保证实例唯一
public class ThreadSafeSingleton {// (1) 声明静态私有成员变量private static ThreadSafeSingleton instance;// (2) 私有构造方法private ThreadSafeSingleton() {}// (3) 定义静态方法提供全局唯一访问点public static ThreadSafeSingleton getInstance() {// 使用synchronized方法保证线程安全synchronized (ThreadSafeSingleton.class) {if (Objects.isNull(instance)) {instance new ThreadSafeSingleton();}return instance;}}public void foo() {System.out.println(---------do some thing in a ThreadSafeSingleton instance---------);}
}
// 2. 客户端调用
public class ThreadSafeSingletonClient {public void test() {// (1) 获取实例ThreadSafeSingleton instance ThreadSafeSingleton.getInstance();// (2) 调用实例方法instance.foo();}
}但是这种方式会因线程同步而带来性能问题。因为大多数场景下是不存在并发访问。
(4) 双重校验方式
为避免每次创建实例时加锁带来的性能问题引入双重校验方式即在加锁前额外进行实例判空校验这样就可保证非并发场景下仅在第一次实例化时去加锁并创建实例。
// 1. 定义单例类提供全局唯一访问点保证实例唯一
public class DoubleCheckSingleton {// (1) 声明静态私有成员变量private static volatile DoubleCheckSingleton instance;// (2) 私有构造方法private DoubleCheckSingleton() {}// (3) 定义静态方法提供全局唯一访问点public static DoubleCheckSingleton getInstance() {// 在加锁之前先执行判空检验提高性能if (Objects.isNull(instance)) {// 使用synchronized方法保证线程安全synchronized (DoubleCheckSingleton.class) {if (Objects.isNull(instance)) {instance new DoubleCheckSingleton();}}}return instance;}public void foo() {System.out.println(---------do some thing in a DoubleCheckSingleton instance---------);}
}
// 2. 客户端调用
public class DoubleCheckSingletonClient {public void test() {// (1) 获取实例DoubleCheckSingleton instance DoubleCheckSingleton.getInstance();// (2) 调用实例方法instance.foo();}
}注意使用双重校验方式时需明确语言是否支持指令重排序。以Java语言为例实例化一个对象的过程是非原子的。具体来说可以分为以下三步(1) 分配对象内存空间;(2)将对象信息写入上述内存空间;(3) 创建对上述内存空间的引用。其中(2)和(3)的顺序不要求固定(无先后顺序)所以存在实例以分配内存空间但还未初始化的情况。如果此时存在并发线程使用了该未初始化的对象则会导致代码异常。为避免指令重排序Java语言中可以使用 volatile 禁用指令重排序。更多细节可以参考java单例模式一文。
(5) 惰性加载方式
由于加锁会带来性能损耗最好的办法还是期望实现一种无锁的设计且又能实现延迟加载。对Java语言来说静态内部类会延迟加载(对C#语言来说内部类会延迟加载)。可以利用这一特性实现单例。
// 1. 定义单例类提供全局唯一访问点保证实例唯一
public class LazyLoadingSingleton {// (2) 私有构造方法private LazyLoadingSingleton() {}// (3) 定义静态方法提供全局唯一访问点public static LazyLoadingSingleton getInstance() {// 第一调用静态类成员或方法时才加载静态内部类实现了延迟加载return Holder.instance;}public void foo() {System.out.println(---------do some thing in a LazyLoadingSingleton instance---------);}// (1) 声明私有静态内部类并提供私有成员变量private static class Holder {private static LazyLoadingSingleton instance new LazyLoadingSingleton();}
}
// 2. 客户端调用
public class LazyLoadingSingletonClient {public void test() {// (1) 获取实例LazyLoadingSingleton instance LazyLoadingSingleton.getInstance();// (2) 调用实例方法instance.foo();}
}很多框架代码都会引入静态内部类实现延迟加载。更多静态内部类的使用细节可以参考笔者之前的文章。
适用场景
在以下情况下可以使用单例模式 (1) 如果系统只需要一个实例对象则可以考虑使用单例模式。 如提供一个唯一的序列号生成器或者需要考虑资源消耗太大而只允许创建一个对象。 (2) 如果需要调用的实例只允许使用一个公共访问点则可以考虑使用单例模式。 (3) 如果一个系统只需要指定数量的实例对象则可以考虑扩展单例模式。 可以在单例模式中通过限制实例数量实现多例模式。
优缺点
单例模式模式有以下优点 (1) 提供了对唯一实例的受控访问。 因为单例类封装了它的唯一实例所以它可以严格控制客户怎样以及何时访问它。 (2) 节约系统资源。由于在系统内存中只存在一个对象因此可以节约系统资源对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。 (3) 允许可变数目的实例。可以基于单例模式进行扩展使用与单例控制相似的方法来获得指定个数的对象实例。 但是单例模式模式也存在以下缺点 (1) 违反了单一职责原则。单例类的职责过重既充当工厂角色提供了工厂方法同时又充当产品角色包含一些业务方法将产品的创建和产品本身的功能融合到一起在一定程度上违背了单一职责原则。 (2) 单例类扩展困难。由于单例模式中没有抽象层且继承困难所以单例类的扩展有很大的困难。 (3) 滥用单例模式带来一些负面问题如过多的创建单例会导致这些单例类一直无法释放且占用内存空间另外对于一些不频繁使用的但占用内存空间较大的对象也不宜将其创建为单例。而且现在很多面向对象语言(如Java、C#)都提供了自动垃圾回收的技术。
参考
《设计模式可复用面向对象软件的基础》 Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides 著 李英军, 马晓星 等译 https://design-patterns.readthedocs.io/zh_CN/latest/creational_patterns/singleton.html 单例模式 https://refactoringguru.cn/design-patterns/singleton 单例模式 https://www.runoob.com/design-pattern/singleton-pattern.html 单例模式 https://www.cnblogs.com/adamjwh/p/9033554.html 单例模式 https://blog.csdn.net/czqqqqq/article/details/80451880 单例模式
