Java设计模式之单例模式

在一个程序中有时候对于一个类只产生一个对象是很重要的，比如数据库中进行连接数控制就是利用单例模式的思想，只不过可能是产生多个对象，这个也是通过单例模式来实现的；再比如Windows中的任务管理器的窗口，只会打开一个，如果能够打开多个那么怎样显示呢，因为同时系统资源利用，CPU占有率是一样的，控制只会产生一个窗口就不会出现问题，而且就算多个窗口显示都一样，这样就会浪费内存资源；

单例模式想要做到的是这样一件事，保证一个类只有一个实例并且这个实例易于访问；首先需要定义一个全局变量可以确保对象随时都可以被访问，但是这样没有办法保证只产生一个对象；那么就需要提供一个方法来创建实例，而且保证只产生一个实例，这个方法是一个全局都可以访问的。

结构：

私有构造方法，这样可以防止在外部直接创建多个对象，并且需要有一个Singleton类型的静态对象作为共享访问地唯一实例。

代码：

public class Singleton{
    private static Singleton instance = null;   //静态私有成员变量
    
    //私有构造方法
    private Singleton(){
    
    }

    //静态共有工厂方法，返回的是唯一实例
    public static Singleton getInstance(){
        if(instance == null)
            instance = new Singleton();
        return instance;
    }
}

饿汉式：

顾名思义就是类加载时就已经加载好了，想使用时直接拿来使用，不用等待创建实例。

代码：

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

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

懒汉式：

和饿汉式相反，是在使用时才开始创建；这种技术又称为延迟加载技术（Lazy Load），即需要时再加载实例。加了synchronized是为了在多线程环境中也保证一个线程只创建一个实例。

代码：

public class LazySingleton{
    private static LazySingleton instance = null;

    private LazySingleton(){}

    //使用synchronized关键字对方法加锁，确保任意时刻只有一个线程可以执行此方法
    synchronized public static LazySingleton getInstance(){
        if(instance == null)
            instance = new LazySingleton();
        return instance;
    }
}

但是加synchronized锁会导致每一次调用该方法是都要检查，在高并发环境中创建对象效率降低，降低系统性能。可以改变加锁的位置，不对整个方法加锁，只对创建对象处加锁。

改进代码：

public class LazySingleton{
    private static LazySingleton instance = null;

    private LazySingleton(){}

    //使用synchronized关键字对方法加锁，确保任意时刻只有一个线程可以执行此方法
    public static LazySingleton getInstance(){
        if(instance == null)
            synchronized(LazySingleton.class){   //此处加锁
                instance = new LazySingleton();
            }
        return instance;
    }
}

但是改进后的代码，还是会有问题，如果两个线程同时进行判断，进入了if(instance == null){}中，此时如果其中一个线程创建了对象离开后，另一个线程并不知道已经创建了对象，所有就会去创建对象，这就导致创建对象不唯一，改进是加锁后在进行判断对象是否已经被创建，没有的话就继续创建，这就保证了对象的唯一性；但是需要在静态成员变量前加volatile变量，使得线程之间对于instance变量都是可见的，这就保证了如果有线程创建了对象，instance不为空，别的线程能够立马看到，不会再创建实例了（其实就是第二次判断起作用了）。

代码如下：

public class LazySingleton{
    private volatile static LazySingleton instance = null;

    private LazySingleton(){}

    //使用synchronized关键字对方法加锁，确保任意时刻只有一个线程可以执行此方法
    public static LazySingleton getInstance(){
        if(instance == null)   //第一次判断
            synchronized(LazySingleton.class){   //此处加锁
                if(instance == null){  //第二次判断
                    instance = new LazySingleton();
                }
            }
        return instance;
    }
}

比较两种方式：

饿汉式单例类在类加载时就创建，在调用速度和反应时间上要优于懒汉式，但是在类加载时可能加载的资源较多，加载的时间可能比较长，而且并不是每一次启动程序都需要创建该类，有时会造成资源上的浪费。

懒汉式在第一次使用时就创建，虽说只会在使用时才占用系统资源，但是处理多个线程访问时，需要进行并发控制，加锁会降低系统的性能；如果初始化时需要创建很多资源，那么第一次使用该实例时将会等待很久。

使用静态内部类来实现：

由于采用内部类的方式，所以在初始化外部类时并不会加载内部类，在第一次调用getInstance()方法时，会加载内部类并创建实例，此时instance是static类型，JVM会对其进行并发控制，所以不需要再加锁控制并发，提高了系统性能，而且也是延迟加载的方式。

代码：

public class Singleton{
    private Singleton(){}

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

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