设计模式－单例

单例模式

单例设计模式是设计模式中使用最普遍的模式之一。用于产生一个对象的具体实例，它可以确保系统中一个类只产生一个实例。

单例带来的好处

1.对于频繁创建的对象，可以省略创建对象所花费的时间，这对于一些重量级的对象而言，是非常可观的一笔开销。
2.由于new操作的次数减少，因而对于系统内存的使用频率也会降低，这也将减轻GC压力，缩短GC停顿时间。

单例的实现

单例模式的核心在于通过一个接口返回唯一对象的实例，最简单的例子：

public class SimpleSingleInstance {
    private SimpleSingleInstance() { 
     System.out.println("SimpleSingleInstance");    
    }    
    private static SimpleSingleInstance instance = new SimpleSingleInstance();    
    public static SimpleSingleInstance getInstance() {
        return instance;
    }
}

这个例子实现方式非常简单，而且十分可靠。
1.一个private 访问级别的构造函数，确保单例不会再系统中被实例化
2.getInstance保证只能获取到一个唯一的单例对象

但是这个类有个很明显的缺点，没有做到延迟加载，也就是说在jvm加载单例类的时候，单例对象就会被创建。

public class SimpleSingleInstance {
    private SimpleSingleInstance() { 
     System.out.println("SimpleSingleInstance");    
    }    
    private static SimpleSingleInstance instance = new SimpleSingleInstance();    
    public static SimpleSingleInstance getInstance() {
        return instance;
    }
}
  public static void log(){
      System.out.println("log");
  }

当我们调用SimpleSingleInstance.log();的时候程序输出：

SimpleSingleInstance
log

虽然我们没有使用单例类，但是还是被创建出来了，如果这个单例创建比较耗时的话我们在调用他的静态方法的时候，也就造成了该方法第一次的执行时间加长，为了解决这种问题我们引入了赖加载。

public class LazySingleInstance {
    private LazySingleInstance() {
        System.out.println("LazySingleInstance");
    }    private static LazySingleInstance instance = null;
    public  synchronized static LazySingleInstance getInstance() {
                if (instance == null) {
                    instance = new LazySingleInstance();
                }
        return instance;
    }
}

首先将instance初始值为null,确保系统启动的时候不会加载，其次在getIntance判断instance是不是为null不为null采取创建对象，当然也加上了同步锁保障多线程同时访问不会创建出多个对象，也就违反了我们写单例的目的。

使用上面的例子虽然实现了延迟加载，但是也加入的同步锁，再多线程中，它的耗时也会大大增加。

for (int i = 0; i < 5; i++) {
    new Thread() {
        @Override
        public void run() {
            for (int i = 0; i < 100000; i++) {
                long beginTime = System.currentTimeMillis();
                SimpleSingleInstance.getInstance(); 
                  spendTime += (System.currentTimeMillis() - beginTime);
                if (i == 100000 - 1) { 
                   System.out.println("SimpleSingleInstance spend:" + (spendTime));
                }
            }
        }
    }.start();
}

我们开启五个线程去执行SimpleSingleInstance耗时

SimpleSingleInstance
SimpleSingleInstance spend:19
SimpleSingleInstance spend:17
SimpleSingleInstance spend:17
SimpleSingleInstance spend:19
SimpleSingleInstance spend:20

我们开启五个线程去执行SimpleSingleInstance耗时

LazySingleInstance
LazySingleInstance spend:268
LazySingleInstance spend:268
LazySingleInstance spend:273
LazySingleInstance spend:274
LazySingleInstance spend:274

开启五个线程同时执行，可以看出性能相差巨大。

为了解决这个问题，我们对LazySingleInstance进行改造

public class LazySingleInctanceV2 {
    private LazySingleInctanceV2() {
        System.out.println("LazySingleInctanceV2");
    }
    private volatile static LazySingleInctanceV2 instance = null;
    public static LazySingleInctanceV2 getInstance() {//去掉这里同步锁，在大部分情况下instance都不为null
        if (instance == null) {
            synchronized (LazySingleInctanceV2.class) {
                if (instance == null) {//双重判断避免构建多个对象
                    instance = new LazySingleInctanceV2();
                }
            }
        }
        return instance;
    }
}

LazySingleInctanceV2
LazySingleInctanceV2 spend:28
LazySingleInctanceV2 spend:29
LazySingleInctanceV2 spend:29
LazySingleInctanceV2 spend:29
LazySingleInctanceV2 spend:29

可以看出运行时间基本上和SimpleSingleInstance保持在了一个数量级

当然还有一种更加简单的实现方式

public class StaticSingleInstance {
    private StaticSingleInstance() {
        System.out.println("StaticSingleInstance");
    }
    public static StaticSingleInstance getInstance() {
        return SingleInstanceHolder.instance;
    }
    private static class SingleInstanceHolder {//内部类来维护单例的实例
        private static StaticSingleInstance instance = new StaticSingleInstance();
    }
}

在上面的实现中，使用内部类来维护单例的实例，当单例被加载的时候，其内部类并不会被初始化，当StaticSingleInstance类被加载入JVM的时候，不会初始化单例类，而当调用getInstance的时候才回去加载SingleInstanceHolder从而初始化instance。

StaticSingleInstance
StaticSingleInstance spend:22
StaticSingleInstance spend:23
StaticSingleInstance spend:23
StaticSingleInstance spend:23
StaticSingleInstance spend:24