设计模式（一）单例模式

单例模式：保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

---

优点：1. 由于单例模式只生成一个实例，减少了系统性能开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久驻留内存的方式来解决。

        2. 单例模式可以在系统设置全局的访问点，例如可以设计一个单例类，负责所有数据表的映射处理。

常见的五种单例模式实现方式：

饿汉式：线程安全，调用效率高。但是，不能延时加载。

懒汉式：线程安全，调用效率不高。但是，可以延时加载。

双重检测锁式：由于JVM底层内部模型原因，偶尔会出现问题，不建议使用。

静态内部类式：线程安全，调用效率高。但是，可以延时加载。

枚举单例：线程安全，调用效率高，不能延时加载。

饿汉式：

public class Singleton{
    private static Singleton singleton = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleton;
    }
}

懒汉式：

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

双重检测锁式：

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

静态内部类式：

public class Singleton{
    private static class SingletonClassInstance{
        private static final Singleton singleton = new Singleton();
    }
    public static Singleton getInstance(){
        return SingletonClassInstance.singleton;
    }
    private Singleton(){}
}

注：外部类没有static属性，则不会像饿汉式那样立即加载对象。只有真正调用getInstance()，才会加载静态内部类。加载类时是线程安全的。singleton是static final（final可省略）类型，保证了内存中只有这样一个实例存在，而且只能被赋值一次，从而保证了线程安全性。兼备了并发高效调用和延迟加载的优势。

枚举单例：

public enum Singleton{
    //定义一个枚举的元素，它就代表了Singleton的一个实例
    INSTANCE;
    public void singletonOperation(){
        //功能处理
    }
}

public class GOF {
    public static void main(String[] args){
        Singleton s1 = Singleton.INSTANCE;
        Singleton s2 = Singleton.INSTANCE;
        System.out.println(s1==s2);
    }
}

打印结果：true

注：实现简单。枚举本身就是单例模式。由JVM从根本上提供保障，避免通过反射和反序列化的漏洞。但无延迟加载。

五种如何选用：

单例对象 占用资源少，不需要延时加载：枚举式好于饿汉式

单例对象 占用资源大，需要延时加载：静态内部类好于懒汉式

问题：

反射和反序列化可以破解上面几种（不包含枚举式）实现方式。

1. 例：通过反射的方式直接调用私有构造器。

代码中的SingletonDemo1为饿汉式

import java.lang.reflect.Constructor;

public class SingletonDemo1_1 {
    public static void main(String[] args)throws Exception{
        SingletonDemo1 s1 = SingletonDemo1.getInstance();
        SingletonDemo1 s2 = SingletonDemo1.getInstance();
        System.out.println(s1 == s2);
        
        Class<SingletonDemo1> clazz = (Class<SingletonDemo1>)SingletonDemo1.class;
        Constructor<SingletonDemo1> c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true);
        SingletonDemo1 s3 = c.newInstance();
        SingletonDemo1 s4 = c.newInstance();
        System.out.println(s3 == s4);
    }
}

打印结果：
true
false

解决方法：可以在构造方法中抛出异常控制。

修改后的饿汉式为：

public class SingletonDemo1{
    private static SingletonDemo1 single = new SingletonDemo1();
    private SingletonDemo1(){
        if(single != null){
            throw new RuntimeException();
        }
    }
    public static SingletonDemo1 getInstance(){
        return single;
    }
}

2. 例：通过反序列化的方式构造多个对象。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SingletonDemo1_1 {
    public static void main(String[] args)throws Exception{
        SingletonDemo1 s1 = SingletonDemo1.getInstance();
        SingletonDemo1 s2 = SingletonDemo1.getInstance();
        System.out.println(s1 == s2);
        
        FileOutputStream fos = new FileOutputStream("G:/a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(s1);
        oos.close();
        fos.close();
        
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("G:/a.txt"));
        SingletonDemo1 s3 = (SingletonDemo1)ois.readObject();
        System.out.println(s2 == s3);
    }
}

打印结果：
true
false

解决方法：定义readResolve()方法，则直接返回此方法指定的对象，而不需要单独再创建新对象。

如：

import java.io.ObjectStreamException;
import java.io.Serializable;

public class SingletonDemo1 implements Serializable {
    private static SingletonDemo1 single = new SingletonDemo1();
    private SingletonDemo1(){
        if(single != null){
            throw new RuntimeException();
        }
    }
    public static SingletonDemo1 getInstance(){
        return single;
    }
    private Object readResolve() throws ObjectStreamException{
        return single;
    }
}

五种单例模式在多线程环境下的效率测试：

CountDownLatch同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

countDown() 当前线程调此方法，则计数减一(建议放在finally里执行)

await() 调用此方法会一直阻塞当前线程，直到计时器的值为0

import java.util.concurrent.CountDownLatch;


public class Cilent {
    public static void main(String[] args)throws Exception{
        long start = System.currentTimeMillis();
        int threadNum = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);
        for(int i = 0; i < 10; i++){
            new Thread(new Runnable(){
                @Override
                public void run() {
                    for(int i = 0; i < 100000; i++){
                        Object o = SingletonDemo1.getInstance();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long end = System.currentTimeMillis();
        System.out.println("总耗时 = " + (end - start));
    }
}

经过测试 懒汉式耗时最多，其次是双重检查锁式，其他相差不大。