如何手写一个单例模式

vlambda
2020-06-16

如何手写一个单例模式

什么是单例模式

单例模式，指的是在程序运行过程中，类只有一个对象实例。

为了实现单例，就不能允许程序员在使用这个类时，可以用new关键字来创建一个该类的对象。为了实现这一目的，我们可以将类的构造器设为私有，并提供一个方法来返回唯一的一个实例对象。

那么，这里引出了一个问题：该类的实例对象是在什么时候创建的呢？

一种思路是：在该类加载的时候就创建该类的实例对象，这种方式叫作饿汉式单例。

饿汉式单例可以的具体实现如下所示：

public class Singleton{
 private static Singleton instance = new Singleton();

 private Singleton(){}

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

另一种思路是：只有在第一次使用该类的实例化对象的时候，才去创建该类的实例对象，这种方式叫作懒汉式单例。

懒汉式单例的具体实现方式如下：

public class Singleton{
    private static Singleton instance;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

有什么问题

以上代码在单线程的时候并不会产生问题，但是在多线程高并发情况下，类Singleton可能会有多个实例对象，这就破坏了单例。

我们用具体代码来演示这一种情况：

在这里，我们使用20个线程，每个线程都会调用类Singleton的getInstance()方法，打印获取的对象的哈希码。按照单例模式的定义，由于类Singleton只有一个实例化的对象，那么按理说每一次调用getInstance()方法得到的是同一个对象，打印的哈希码是一致的。

public class Test {
    public static void main(String[] args) {
        int len = 20;
        Thread[] tn = new Thread[len];
        for(int i = 0; i < len; i++){
            tn[i] = new Thread(()->{
                System.out.println(Singleton.getInstance());
            });
            tn[i].start();
        }
    }
}

然而，我们发现，上述代码的运行结果出现了不同的哈希码，说明创建出了不同的对象，这不符合单例模式的特点。

单例模式被破坏的原因是：当启动多线程后，假设线程A进入if(instance==null){...}之后，判断instance的值为null,之后线程A将会执行创建类Singleton的对象的语句。在线程A将要创建类Singleton的对象的时候，线程B也进入到if(instance == null){...}，此时由于线程A还没创建类Singleton的对象，线程B判断instance的值为null,也执行了创建类Singleton的对象的语句。这样子，就会造成类Singleton有多个实例对象。

如何解决线程安全的问题

声明synchronized关键字

由于多线程下调用getInstance()方法会产生线程安全的问题，因此通过synchronized关键字加锁，就可以解决这个问题。这个方法的效率比较低

 synchronized public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }

对代码块用synchronized关键字修饰，这个效率比用synchronized关键字修饰整个方法效率高一点

public static Singleton getInstance(){
    synchronized(Singleton.class){
        if(instance == null){
            instance = new Singleton();
        }
    }
    return instance;
}

使用DCL双检查锁机制

public class Singleton{
    private volatile static Singleton instance;
    
    private Singleton(){}
    
    public static Singleton getInstance(){
        if(instance == null){
            synchronized(Singleton.class){
                if(instance == null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

使用静态内部类实现单例

public class Singleton{
    private Singleton(){}
    private static class SingletonHandler{
        private static Singleton instance = new Singleton();
    }
    
    public static Singleton getInstance(){
        return SingletonHandler.instance;
    }
}

序列化和反序列化单例模式的实现

使用静态内部类可以达到线程安全，但是如果遇到序列化对象时候，使用默认的方式运行得到的结果还是多例的

问题：当一个单例序列化后再反序列化，序列化前对象的hashCode和反序列化后对象的hashCode不一样

解决办法：在反序列化中使用readResolve()方法

readResolve()需要定义在单例类中，但是不需要显式地调用，在反序列化过程中，JVM会自动调用；

注意，该方法是私有的

public class Singleton implements Serializable{
    private static final long serialVersionUID = 888L;
    //内部类方式
    private static class SingletonHandler{
        private static Singleton instance = new Singleton();
    }
    private Singleton(){}
    public static Singleton getInstance(){
        return SingletonHandler.instance;
    }
    private Object readResolve() throws ObjectStreamException{
        return SingletonHandler.instance;
    }
}

vlambda博客
学习文章列表