一个jvm中,只能有一个实例,保证对象唯一
应用场景:
windows的任务管理器就是呀,小伙伴们不信可以点击下试试,看看能创建几次
servlet 连接池 线程池 spring(默认单例)枚举 常量
为啥设置单例? 优点? 保证对象的唯一性 节约内存 方便管理 重复利用
缺点? 线程安全问题
单例模式
什么是单例
保证一个类只有一个实例,并且提供一个访问该全局访问点
单例应用场景
1. Windows的Task Manager(任务管理器)就是很典型的单例模式(这个很熟悉吧),想想看,是不是呢,你能打开两个windows task manager吗? 不信你自己试试看哦~
2. windows的Recycle Bin(回收站)也是典型的单例应用。在整个系统运行过程中,回收站一直维护着仅有的一个实例。
3. 网站的计数器,一般也是采用单例模式实现,否则难以同步。
4. 应用程序的日志应用,一般都何用单例模式实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加。
5. Web应用的配置对象的读取,一般也应用单例模式,这个是由于配置文件是共享的资源。
6. 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池,主要是节省打开或者关闭数据库连接所引起的效率损耗,这种效率上的损耗还是非常昂贵的,因为何用单例模式来维护,就可以大大降低这种损耗。
7. 多线程的线程池的设计一般也是采用单例模式,这是由于线程池要方便对池中的线程进行控制。
8. 操作系统的文件系统,也是大的单例模式实现的具体例子,一个操作系统只能有一个文件系统。
9. HttpApplication 也是单位例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式,所有的HttpModule都共享一个HttpApplication实例.
单例优缺点
优点:
1.在单例模式中,活动的单例只有一个实例,对单例类的所有实例化得到的都是相同的一个实例。这样就 防止其它对象对自己的实例化,确保所有的对象都访问一个实例
2.单例模式具有一定的伸缩性,类自己来控制实例化进程,类就在改变实例化进程上有相应的伸缩性。
3.提供了对唯一实例的受控访问。
4.由于在系统内存中只存在一个对象,因此可以 节约系统资源,当 需要频繁创建和销毁的对象时单例模式无疑可以提高系统的性能。
5.允许可变数目的实例。
6.避免对共享资源的多重占用。
缺点:
1.不适用于变化的对象,如果同一类型的对象总是要在不同的用例场景发生变化,单例就会引起数据的错误,不能保存彼此的状态。
2.由于单利模式中没有抽象层,因此单例类的扩展有很大的困难。
3.单例类的职责过重,在一定程度上违背了“单一职责原则”。
4.滥用单例将带来一些负面问题,如为了节省资源将数据库连接池对象设计为的单例类,可能会导致共享连接池对象的程序过多而出现连接池溢出;如果实例化的对象长时间不被利用,系统会认为是垃圾而被回收,这将导致对象状态的丢失。
单例创建方式
- 饿汉式:类初始化时,会立即加载该对象,线程天生安全,调用效率高。
- 懒汉式: 类初始化时,不会初始化该对象,真正需要使用的时候才会创建该对象,具备懒加载功能。
- 静态内部方式:结合了懒汉式和饿汉式各自的优点,真正需要对象的时候才会加载,加载类是线程安全的。
- 枚举单例: 使用枚举实现单例模式 优点:实现简单、调用效率高,枚举本身就是单例,由jvm从根本上提供保障!避免通过反射和反序列化的漏洞, 缺点没有延迟加载。
- 双重检测锁方式 (因为JVM本质重排序的原因,可能会初始化多次,不推荐使用)
1、首先饿汉式: 类初始化时候就创建 对象。线程安全,调用效率比较高。不使用对象时候,浪费内存。
类初始化时,会立即加载该对象,线程天生安全,调用效率高
package com.toov5.desionModel; public class Hungry { //静态变量 private static final Hungry instance = new Hungry(); //垃圾回收机制 不会回收 存放永久区 //构造函数私有 在别的类里面 就不能new了(反射可以) private Hungry() { } //线程安全问题: //构造函数私有化之后 不能创建对象了 所以自己提供方法 public static Hungry getInstance(){ return instance; } public static void main(String[] args) { Hungry hungry1 = Hungry.getInstance(); Hungry hungry2 = Hungry.getInstance(); System.out.println(hungry1==hungry2); } }
运行结果:
2、懒汉式
package com.toov5.desionModel; //类初始化时候不会创建,需要时加载。天生不安全,需要解决线程安全问题,所以效率低。 public class Lazy { private static Lazy lazy; //私有掉 private Lazy(){ } //效率低 一个线程使用 public static synchronized Lazy getInstance(){ //synchronize 保证只有一个线程去创建了 if (lazy==null) { //如果没有被创建 lazy=new Lazy(); } return lazy; //如果创建过了 } public static void main(String[] args) { Lazy lazy1 = lazy.getInstance(); Lazy lazy2 = lazy.getInstance(); System.out.println(lazy1==lazy2); } }
运行结果:
3、枚举
首先枚举,在开发中 定义常量会用到。JVM天然保障枚举是单例 ,防止反射攻击。枚举有七种创建方式,大家可以自己去看下相关的文档。有时间,我也整理一篇枚举的博文。
枚举本身是单例的,一般用于项目中定义常量。
package com.toov5.fanshe; enum HttpEnum { HTTP_200(200,"successful"), HTTP_500(500,"faliure"); HttpEnum(Integer httpCode, String httpMsg){ System.out.println("我是初始化哈哈哈"); this.httpCode=httpCode; this.httpMsg=httpMsg; } private Integer httpCode; public Integer getHttpCode() { return httpCode; } public void setHttpCode(Integer httpCode) { this.httpCode = httpCode; } public String getHttpMsg() { return httpMsg; } public void setHttpMsg(String httpMsg) { this.httpMsg = httpMsg; } private String httpMsg; public static void main(String[] args) { System.out.println(HttpEnum.HTTP_200.httpCode); System.out.println(HttpEnum.HTTP_200.httpCode); System.out.println(HttpEnum.HTTP_500.httpCode); System.out.println(HttpEnum.HTTP_500.httpCode); } }
运行结果:
可以看出初始化一次啊
然后利用这个特性创建单例模式:
使用枚举实现单例模式 优点:实现简单、枚举本身就是单例,由jvm从根本上提供保障!避免通过反射和反序列化的漏洞 缺点没有延迟加载
package com.toov5.desionModel; public class EnumSingle { private EnumSingle(){ } //封装方法 public static EnumSingle getInstance(){ return Singleton.INSTSNCE.getInstance(); //这样只会创建一次 } //下面的枚举本身就是单例的 static enum Singleton{ //枚举类 INSTSNCE; private EnumSingle enumSingle; private Singleton(){ enumSingle=new EnumSingle(); } public EnumSingle getInstance(){ return this.enumSingle; } } public static void main(String[] args) { EnumSingle enumSingle1 = EnumSingle.getInstance(); EnumSingle enumSingle2 = EnumSingle.getInstance(); System.out.println(enumSingle1==enumSingle2); } }
运行结果:
4、双重检验锁
package com.toov5.desionModel; public class DoubleLock { private static volatile DoubleLock doubleLock; //防止重排序 private DoubleLock(){ } public static DoubleLock getInstance(){ //比较饿汉模式而言的,如果在这一行加锁,效率势必会比较低 利用同步代码块 if (doubleLock == null){ //判断一下 如果为null时候 这种情况下才会去创建对象 synchronized (DoubleLock.class){ //静态的用 字节码文件 if (doubleLock==null) { //上锁完了之后 可能没有创建完毕 所以要判断一下 但是 重排序时候 可能会导致 对象可能创建多次 //所以加volitile关键字 (单线程是不会产生重排序问题) doubleLock=new DoubleLock(); } } } return doubleLock; //不为空的话 会直接返回呀 多个线程去创建时候 才有有安全塞问题 } public static void main(String[] args) { DoubleLock doubleLock1 = DoubleLock.getInstance(); DoubleLock doubleLock2 = DoubleLock.getInstance(); System.out.println(doubleLock1==doubleLock2); } }
运行结果:
比较:
这里synchronize就保证了可见性了 没有必要再加 volitile关键字了 单线程里面是不会产生重排序问题 因为 只有一个线程进入执行了
5、静态内部类
饿汉式和懒汉式的各自优缺点:
饿汉式:天生线程安全,执行效率高,缺点占内存 如果不适用该对象也会创建 没有延迟加载的功能(懒加载)
懒汉式: 节省内存,延迟加载的功能。线程不安全,需要加锁,那么就会导致执行效率变低。产生阻塞和等待
静态的内部类方式结合懒汉式和饿汉式的优点: 具备 延迟加载 天生线程安全 真正需要时候才会去创建对象
内部类在什么时候初始化? 外部类调用内部类时候 才会初始化~
没有被初始化!
被初始化!
所以:
package com.toov5.desionModel; public class StaticInner { private StaticInner(){ } public static class SingleInstance{ //静态内部类 在类加载时候 不会初始化!! public static final StaticInner STATIC_INNER = new StaticInner(); } public static StaticInner getInstance(){ return SingleInstance.STATIC_INNER; } public static void main(String[] args) { StaticInner staticInner1 = StaticInner.getInstance(); StaticInner staticInner2 = StaticInner.getInstance(); System.out.println(staticInner1==staticInner2); } }
运行结果:
不调用不会创建
外部类 调用内部类 才会去初始化
如果不需要延迟加载单例,可以使用枚举或者饿汉式,相对来说枚举性好于饿汉式。
如果需要延迟加载,可以使用静态内部类或者懒韩式,相对来说静态内部类好于懒汉式。