经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » Java相关 » 设计模式 » 查看文章
浅析Java单例设计模式(自写demo)
来源:jb51  时间:2021/12/15 8:46:29  对本文有异议

单例模式特点

1、构造器私有

2、在一个Java应用程序中,可保证只有一个实例对象

3、只提供一个供外界调用的getInstance()方法

单例模式优点

1、减少某些对象的频繁创建,降低系统开销和内存占用

2、外部调用不使用new关键字,降低系统内存的使用频率

3、对于特殊的类,在系统中只能存在一个实例,否则系统无法正常运行,比如Controller

实现方式

这里简单介绍两种实现方式

饿汉式(线程安全)

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 12:07
  4. * @description: 单例模式(饿汉式)
  5. **/
  6. public class Singleton {
  7. //创建实例
  8. private static Singleton instance = new Singleton();
  9. //私有构造器
  10. private Singleton(){
  11. }
  12. //获取实例的静态方法
  13. public static Singleton getInstance(){
  14. return instance;
  15. }
  16. }

实例对象在类被加载的时候就已经完成初始化,外界调用拿到的都是这个唯一的实例对象

懒汉式

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 12:22
  4. * @description: 单例模式(懒汉式)
  5. **/
  6. public class Singleton {
  7. //声明一个变量
  8. private static Singleton instance;
  9. //私有构造器
  10. private Singleton(){
  11. }
  12. //获取实例的静态方法
  13. public static Singleton getInstance(){
  14. //如果是首次调用,实例对象还没有被创建,就需要创建,否则都是返回已经创建过的那个对象
  15. if (instance == null){
  16. instance = new Singleton();
  17. }
  18. return instance;
  19. }
  20. }

对比饿汉式可见,实例对象在类被加载的时候并没有进行创建,在首次调用的时候才被创建,以后再被调用,返回的也是那个唯一的实例对象。

在多线程情况下,这种写法存在线程安全问题,比如:线程A在执行完if判断条件后进入阻塞状态,此时并没有进行对象创建,此时线程B来了,在执行完if条件后直接进行对象创建,等线程A恢复运行状态后也会进行对象创建,这个时候就不符合单例模式了,即出现了线程不安全的问题。

解决方案:在获取实例的静态方法上加synchronized关键字,即加锁

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 12:22
  4. * @description: 单例模式(懒汉式)
  5. **/
  6. public class Singleton {
  7. //声明一个变量
  8. private static Singleton instance;
  9. //私有构造器
  10. private Singleton(){
  11. }
  12. //获取实例的静态方法
  13. public static synchronized Singleton getInstance(){
  14. //如果是首次调用,实例对象还没有被创建,就需要创建,否则都是返回已经创建过的那个对象
  15. if (instance == null){
  16. instance = new Singleton();
  17. }
  18. return instance;
  19. }
  20. }

简单粗暴,可达到我们的目的,但是每次获取实例对象都要有加锁操作,影响系统性能。

改进后的方案:双重检查

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 12:22
  4. * @description: 单例模式(懒汉式)
  5. **/
  6. public class Singleton {
  7. //声明一个变量
  8. private static Singleton instance;
  9. //私有构造器
  10. private Singleton(){
  11. }
  12. //获取实例的静态方法
  13. public static synchronized Singleton getInstance(){
  14. //第一次检查
  15. if (instance == null){
  16. //获取锁
  17. synchronized (Singleton.class){
  18. //第二次检查
  19. if (instance==null){
  20. //两次检查都确定没有已存在的实例对象,这才进行对象的创建操作
  21. instance = new Singleton();
  22. }
  23. }
  24. }
  25. return instance;
  26. }
  27. }

这样不必每次获取实例对象的时候都进行加锁操作,只有在第一次创建对象的时候才进行加锁操作,提高了系统性能。

但是,即使这样有可能会出现。因为 instance = new Singleton()这行代码在JVM中是两个操作,赋值和初始化实例,但JVM并不保证这两个操作的顺序,有可能JVM给新对象分配了空间,直接赋值给instance变量,然后才去做初始化实例操作。比如下面这种情况

1,A,B两个线程都进入第一个if条件

2,A线程先抢到锁进入到synchronized代码块,执行了instance = new Singleton()这行代码,然后释放锁,此时有可能JVM只给实例对象分配了空白的内存空间,并没有执行初始化操作

3,B线程抢到锁,进入到synchronized代码块,第二次判断的时候发现instance不是null,直接返回使用却发现得到的对象还没有被初始化,于是出现了问题。

再次改进:使用volatile关键字修饰声明的成员变量instance

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 12:22
  4. * @description: 单例模式(懒汉式)
  5. **/
  6. public class Singleton {
  7. //声明变量,被volatile修饰
  8. private volatile static Singleton instance;
  9. //私有构造器
  10. private Singleton(){
  11. }
  12. //获取实例的静态方法
  13. public static synchronized Singleton getInstance(){
  14. //第一次检查
  15. if (instance == null){
  16. //获取锁
  17. synchronized (Singleton.class){
  18. //第二次检查
  19. if (instance==null){
  20. //两次检查都确定没有已存在的实例对象,这才进行对象的创建操作
  21. instance = new Singleton();
  22. }
  23. }
  24. }
  25. return instance;
  26. }
  27. }

volatile关键字作用:通过volatile修饰的变量,不会被线程本地缓存,所有线程对该对象的读写都会第一时间同步到主内存,从而保证多个线程间该对象的准确性。

这个写法已经比较完美了,既能保证安全的创建出唯一实例,又不会对系统性能有太大影响。

不过,还有更优的写法:静态内部类实现

  1. ?
  2. /**
  3. * @author: xuzhilei6656
  4. * @create: 2021-12-12 15:17
  5. * @description: 单例模式
  6. **/
  7. public class Singleton {
  8. //私有构造器
  9. private Singleton() {
  10. }
  11. //静态内部类声明实例
  12. private static class SingletonFactory{
  13. private static Singleton instance = new Singleton();
  14. }
  15. //获取实例的静态方法
  16. public static Singleton getInstance(){
  17. return SingletonFactory.instance;
  18. }
  19. }
  20. ?

使用内部类来维护单例的实现,JVM内部的机制能够保证当一个类被加载的时候,这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance()方法的时候,JVM能够保证创建出唯一的实例对象,并且这个实例对象是已经被初始化完成的,就解决了上面的线程安全问题

最后一种实现单例的写法也很完美,代码最简洁

通过枚举

  1. /**
  2. * @author: xuzhilei6656
  3. * @create: 2021-12-12 15:33
  4. * @description: 单例模式
  5. **/
  6. public enum Singleton {
  7. //代表一个Singleton实例
  8. INSTANCE;
  9. }

通过枚举来实现单实例代码更加简洁,而且JVM从根本上保证实例对象的唯一性,是更简洁、高效、安全的实现单例的方式?

以上就是浅析Java单例设计模式(自写demo)的详细内容,更多关于Java单例模式的资料请关注w3xue其它相关文章!

 友情链接:直通硅谷  点职佳  北美留学生论坛

本站QQ群:前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

W3xue 的所有内容仅供测试,对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接(目前9元/月)请联系QQ:27243702 沸活量
皖ICP备17017327号-2 皖公网安备34020702000426号