(JavaSE 学习记录) GOF设计模式之单例模式

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

1、饿汉式（线程安全、调用效率高、不可延时加载）
2、懒汉式（线程安全、调用效率不高、可延时加载）
3、双重检测锁式（由于JVM底层内部模型原因，偶尔会出问题，不建议用）
4、静态内部类式（线程安全、调用效率不高、可延时加载）
5、枚举单例（线程安全、调用效率高、不可延时加载）

饿汉式

public class SingletonDemo01 {
    private static SingletonDemo01 instance = new SingletonDemo01();    
    //类初始化时立即加载

    private SingletonDemo01(){
    }

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

懒汉式

public class SingletonDemo02 {
    private static SingletonDemo02 instance;

    private SingletonDemo02(){

    }

    //方法同步，调用效率低
    public static synchronized SingletonDemo02 getInstance(){
        if (instance == null){
            instance = new SingletonDemo02();
        }
        return instance;
    }
}

静态内部类式

public class SingletonDemo03 {
	//静态内部类调用时才加载
    private static class SingletonClassInstance{
        private static final SingletonDemo03 instance = new SingletonDemo03();
    }

    private SingletonDemo03(){

    }

    public static SingletonDemo03 getInstance(){
        return SingletonClassInstance.instance;
    }

}

枚举式

public enum SingletonDemo04 {

    //枚举元素本身就是单例对象
    INSTANCE;

    //添加自己需要的操作
    public void operation(){

    }
}

当不需要延迟加载，单例对象占用资源少时：枚举式 好于 饿汉式
当需要延迟加载，单例对象占用资源多时： 静态内部类式 好于 懒汉式

反射、序列化反序列化产生的漏洞处理

import java.io.Serializable;

//懒汉式
public class SingletonDemo05 implements Serializable {
    private static SingletonDemo05 instance;

    private SingletonDemo05(){
        //反射漏洞
        if (instance!=null){
            throw new RuntimeException();
        }

    }

    //方法同步，调用效率低
    public static synchronized SingletonDemo05 getInstance(){
        if (instance == null){
            instance = new SingletonDemo05();
        }
        return instance;
    }

    //序列化、反序列化漏洞
    private Object readResolve(){
        return instance;
    }
}

测试

利用CountDownLatch辅助类。

import java.util.concurrent.CountDownLatch;

public class Client2 {
    public static void main(String[] args) throws InterruptedException {
        int threadNum = 10;
        CountDownLatch count = new CountDownLatch(threadNum);
        long start = System.currentTimeMillis();

        for (int j = 0;j<threadNum;j++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000000; i++) {
                        //Object o = SingletonDemo01.getInstance();
                        Object o = SingletonDemo04.INSTANCE;
                    }
                    count.countDown();
                }
            }).start();
        }

        count.await(); //阻塞直到count为0；

        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }
}