各种单例模式的效率测试及实际运用（原）

单例模式有以下特点：
　　1、单例类只能有一个实例。
　　2、单例类必须自己创建自己的唯一实例。
　　3、单例类必须给所有其他对象提供这一实例。

懒汉式单例模式：

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-20 15:34
 * @Description:
 *      测试懒汉式单例模式
 *
 *      * 延时加载，用到了才创建对象，提高了资源的利用率。
 *
 *      * 但由于需要用到同步，导致并发效率很低。
 */
public class SingletonDemo {
    private static SingletonDemo singletonDemo;
    //构造器私有化
    private SingletonDemo(){}
    public static synchronized SingletonDemo getInstance(){
        if(singletonDemo==null){
            singletonDemo = new SingletonDemo();
        }
        return singletonDemo;
    }
}

饿汉式单例模式（直接new）：

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-20 15:37
 * @Description:
 *      测试饿汉单例模式（直接new）
 *
 *  * 饿汉式单例模式无延时加载。
 */
public class SingletonDemo1 {
    private static SingletonDemo1 singletonDemo1 = new SingletonDemo1();
    private SingletonDemo1(){}
    public static SingletonDemo1 getInstance(){
        return singletonDemo1;
    }
}

饿汉式单例模式（静态代码块）：

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-22 14:27
 * @Description:
 *      测试饿汉单例模式   静态代码块
 */
public class SingletonDemo5 {
    private static SingletonDemo5 singletonDemo5 = null;
    static {
        singletonDemo5 = new SingletonDemo5();
    }
    public static SingletonDemo5 getInstance(){
        return singletonDemo5;
    }
}

静态内部类单例模式：

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-20 15:39
 * @Description:
 *      测试静态内部类实现方式
 *  * 延迟加载
 *  * 线程安全
 *  * 并发高效调用
 */
public class SingletonDemo2 {
    //静态内部类，并私有化
    private static class SingletonDemo2ClassInstance{
        private static SingletonDemo2 singletonDemo2 = new SingletonDemo2();
    }
    //没有同步，调用效率高
    public static SingletonDemo2 getInstance(){
        return SingletonDemo2ClassInstance.singletonDemo2;
    }
    private SingletonDemo2(){}
}

双重检查单例模式（DCL）：

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-20 15:59
 * @Description: 双重检查模式 （DCL）
 * 这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章提到了双重检查模式是正确使用volatile关键字的场景之一。
 * 在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。
 */
public class SingletonDemo3 {
    private volatile static SingletonDemo3 singletonDemo3;
    private SingletonDemo3 (){}
    public static SingletonDemo3 getInstance(){
        if(singletonDemo3==null){
            synchronized (SingletonDemo3.class){
                if(singletonDemo3==null){
                    singletonDemo3 = new SingletonDemo3();
                }
            }
        }
        return singletonDemo3;
    }
}

枚举单例：
Joshua Bloch大神说过的这句话：“单元素的枚举类型已经成为实现Singleton的最佳方法”。
枚举类是JDK1.5才出现的，那之前的程序员面对反射攻击和序列化问题是怎么解决的呢？其实就是像Enum源码那样解决的，只是现在可以用enum可以使我们代码量变的极其简洁了。

package Dao.xxlDao;

/**
 * @BelongsPackage:Dao.xxlDao
 * @Author:Administrator
 * @CreateTime:2019-08-20 16:24
 * @Description:
 *      枚举单例
 */
public enum SingletonDemo4 {
    INSTANCE;
    public SingletonDemo4 getInstance(){
        return INSTANCE;
    }
}

测试各种单例模式效率代码：

 public static void testDao(){
        long start = System.currentTimeMillis();
        int threadNum = 100;
        final CountDownLatch countDownLatch = new CountDownLatch(threadNum);

        for (int i = 0; i < threadNum; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {

                    for (int i = 0; i < 1000000; i++) {
                        //1.测试饿汉式
                        //SingletonDemo1 singletonDemo1 = SingletonDemo1.getInstance();
                        //2.测试懒汉式
                        //SingletonDemo singletonDemo = SingletonDemo.getInstance();
                        /*//3.测试双重检测锁
                        SingletonDCL singletonDCL = SingletonDCL.getInstance();*/
                        //4.测试静态内部类
                        //SingletonDemo2 singletonDemo2 = SingletonDemo2.getInstance();
                        /*//5.测试枚举
                        SingletonEnum singletonEnum = SingletonEnum.singletonEnumInstance;*/
                        //6.测试双重检查模式
                        //SingletonDemo3 singletonDemo3 = SingletonDemo3.getInstance();
                        //7.测试枚举单利
                        SingletonDemo4 singletonDemo4 = SingletonDemo4.INSTANCE;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }

        try {
            countDownLatch.await(); // main线程阻塞，直到计数器变为0，才会继续往下执行！
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long end = System.currentTimeMillis();
        System.out.println("xx单例式总耗时：" + (end - start)+"ms");
    }

最后附上结果图，相信就能够一目了然了。运行三次测试：
第一次测试结果图：

第二次测试结果图：

第三次测试结果图：

对于结果，相信各位已有结论。

关注公众号

每周会更新干货知识