单例模式

Posted 2020-09-06 Tomorrow

定义： 一个类只能产生一个实例，并且该类提供一个唯一的全局访问点。

说明： 在设计系统时，有的对象，需要保证全局只有一个。例如如下对象（线程池，log对象， 注册表信息对象，性能设置对象，驱动类对象，打印机对象等 ）

基本思路：

　　1. 私有构造器。保证其他类无法实例化该类。

　　2. 静态方法。通过该静态方法能得到该对象的实例。

Java中有以下几种写法：

一. 懒汉（线程不安全）

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

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

总结： 这种写法起到了lazy loading的效果，即先判断实例是否存在，不存在的情况，再实例化。但是只能在单线程的情况下使用。在多线程的情况下，假如A线程进入到if(instance == null), 但是B线程已经执行到 instance = new Singleton()， 这种情况下，就会产生产生多个实例，未达到单例的效果。

二. 懒汉（线程安全，同步方法）

public class Singleton {

    private static Singleton instance;

    private Singleton() {

    }

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

总结：通过在方法前加关键字 synchronized来起到线程同步的作用，解决线程不安全。具备lazy loading效果。

缺点：效率太低。每个线程在执行getInstance() 方法时，都会进行同步。实际上，该方法仅仅需要在第一次执行时需要同步，99%情况下不需要同步，所以影响性能。

三. 懒汉（同步代码块）

public class Singleton {
    private static Singleton instance;

    private Singleton() {

    }

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

总结： 同步了代码块，但是仔细分析，多线程下，也会出现 写法一的情况，有可能会产生多个实例。

四. 饿汉（静态变量）

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

    private Singleton() {

    }

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

 

优点：写法简单，在类装载阶段就完成实例化（单例模式中，大多数是调用getInstance()方法时类装载）。基于classloader机制，避免线程同步问题。

缺点：没有lazy loading效果。如果一直没有使用这个实例，会造成内存的浪费。

五. 饿汉（静态代码块）

public class Singleton {
    private static Singleton instance;

    static {
        instance = new Singleton();
    }

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

总结： 和上面的，也就是第三种效果差不多。只是把实例化过程放在了静态代码块中，也是在类装载的时候，执行静态代码块，初始化类的实例。

六. 双重校验锁

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {

    }

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

总结：因为进行了两次if(instance == null)的检查，保证了线程的安全性。

优点：具有lazy loading效果；线程安全；效率高。

缺点：使用了volatile 关键字，JDK1.5以后才支持。

 七. 静态内部类

public class Singleton {

    private static class SingletonKeeper {
        private static final Singleton instance = new Singleton();
    }

    private Singleton() {

    }

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

总结： 利用classloader的机制来保证初始化instance实例时只有一个线程。和写法四 和 写法五，还是有区别的（只要Singleton类被装载，那么instance就会被实例化，也就没有lazy loading效果）。 而此写法，当Singleton类被装载了，instance不一定被实例化，因为SingletonKeeper类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonKeeper类，从而实例化instance。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

八. 枚举

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {

    }
}

总结： 借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

=====================================================================