欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

Java设计模式之单例模式

程序员文章站 2022-05-04 17:11:12
...

前言

单例模式Java设计模式中最简单也是最常见的一种,它保证了在应用程序中,某个类只有一个实例存在。像配置文件的对象,数据库连接池,多线程的线程池,任务管理器等等,都是单例模式的典型应用。本文循序渐进,由简至繁,介绍单例模式的写法。

目录

单例模式写法

1.最原始的单例模式

public class Singleton {
    // 私有静态的实例
    private static Singleton singleton;
    // 私有的构造方法 
    private Singleton() {
        System.out.println("创建实例");// 打印输出,方便查看效果
    }
    // 公开的静态方法,获取单一实例
    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}
  • 通过私有化构造方法,使应用程序无法从外部通过new来实例化此类的对象
  • 私有化实例对象,防止外部通过.直接调用实例对象
  • 通过公开的静态方法getInstance(),在方法内部检验类是否已经实例化,如果没有则实例化此类的对象,并返回对象

这种写法看似满足了单例模式的条件,实际上没有考虑到并发访问的情况。这里我们模拟一个并发环境下的测试。

// 测试并发环境下的结果
public class Main {
    public static void main(String[] args) {
        // 通过for循环创建100个线程,每个线程都调用Singleton.getInstance()
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                Singleton singleton = Singleton.getInstance();
            }).start();
        }
    }
}

运行结果:
Java设计模式之单例模式
会发现创建了不只一个实例,至于原因我们可以设想这样的情况:

  • 并发访问开始,第一个调用getInstance方法的线程为线程A
  • 线程A判断完singletonnull后进入了if块准备创造实例
  • 但同时另外一个线程B线程A还未创造出实例之前,就又进行了singleton是否为null的判断
  • 由于这时singleton依然为null,所以线程B也会进入if块去创造实例
  • 此时就有两个以上的线程都进入了if块去创造实例,结果就造成单例模式并非单例。

为了避免这种情况,我们就可以接着往下看懒汉模式。

2懒汉模式

public class Singleton {
    // 私有静态的实例
    private static Singleton singleton;
    // 私有的构造方法 
    private Singleton() {
        System.out.println("创建实例");// 打印输出,方便查看效果
    }
    // 公开的静态方法,获取单一实例,使用synchronized加锁
    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种方法其实和上一种基本一样,唯一的区别在于getInstance方法增加了synchronized关键字来实现同步锁。重新进行并发测试,可以发现整个过程只会产生单一实例。

但是这种方法有个缺点,就是性能太低,因为每一次getInstance都会加锁,而加锁过程是非常耗时的,而这里的锁只在实例被创建之前有意义,当实例被创建之后,这里的锁反而成了拖慢性能的累赘

因此我们继续往下,学习双重校验模式

3.双重校验

public class Singleton {
    // 私有静态的实例
    private static Singleton singleton;
    // 私有的构造方法 
    private Singleton() {
        System.out.println("创建实例");// 打印输出,方便查看效果
    }
    // 公开的静态方法,获取单一实例,使用双重检验锁
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这一种就属于教科书式的写法,只是在当前实例为null,也就是实例还未创建时才进行同步,否则就直接返回,这样就节省了当实例已被创建后,由于锁机制产生无谓的线程等待时间。

这里进行了两次对于实例的非null判断,但是作用不一样:

  • 外层的if是为了减小无谓的性能开销,防止实例被创建后还继续触发机制
  • 内层的if是为了防止并发条件下,多个线程等待进入同步代码块,造成创建多个实例的情况。

不过这样写依然有微小的缺陷,因为虚拟机在执行创建实例的这一步操作的时候,其实是分了好几步去进行的,也就是说创建一个新的对象并非是原子性操作,编译器和处理器可能会对指令进行重排序,从而造成异常(虽然这种情况很少见)。

因此我们可以引入JDK1.5之后的volatile关键字,来修饰实例对象:

public class Singleton {
    // 私有静态的实例
    private volatile static Singleton singleton;
    // 私有的构造方法 
    private Singleton() {
        System.out.println("创建实例");// 打印输出,方便查看效果
    }
    // 公开的静态方法,获取单一实例,使用双重检验锁
    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

这么一来,可以避免指令重排序造成的异常情况。

4.饿汉模式

public class Singleton {
    // 私有静态的实例
    private static Singleton singleton = new Singleton();

    // 私有的构造方法
    private Singleton() {
        System.out.println("创建实例");// 打印输出,方便查看效果
    }

    // 公开的静态方法,获取单一实例
    public static Singleton getInstance() {
        return singleton;
    }
}

这种模式可以保证在任何情况,包括并发环境中永远获取单一实例,并且写法简单。但是缺点在于一旦我访问了Singleton的任何其他的静态域,就会造成实例的初始化,而事实是可能我们从始至终就没有使用这个实例,造成内存的浪费。

5.静态内部类

public class Singleton {

    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonInstance.instance;
    }

    private static class SingletonInstance{

        static Singleton instance = new Singleton();

    }
}

定义一个私有的内部类,在第一次用这个嵌套类时,会创建一个实例。而类型为SingletonInstance的类,只有在Singleton.getInstance()中调用,由于私有的属性,他人无法使用SingletonInstance,不调用Singleton.getInstance()就不会创建实例。达到了懒加载的效果,即按需创建实例。