单例模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。
注意：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

饿汉模式

/**
 * @author meikb
 * @desc 饿汉模式 是 类加载就初始化  无需考虑多线程
 * @date 2020-04-24 15:40
 */
public class SingleEager {
    private SingleEager(){}
    private static SingleEager singleEager = new SingleEager();
    public static SingleEager getObject(){
        return singleEager;
    }
}

懒汉模式

/**
 * @author meikb
 * @desc 多线程有问题
 * @date 2020-05-23 10:28
 */
public class SingleLazy {
    private SingleLazy(){}
    private static SingleLazy singleLazy = null;
    public static SingleLazy getObject(){
        if(null == singleLazy){
            singleLazy = new SingleLazy();
        }
        return singleLazy;
    }
}

懒汉多线程

/**
 * @author meikb
 * @desc
 * @date 2020-05-23 10:28
 */
public class SingleLazy2 {
    private SingleLazy2(){}
    private static volatile SingleLazy2 singleLazy = null;
    //如果有100个线程，那只有第一个需要加 synchronized 其他线程按理说不需要加锁，所以效率比较低
    public static synchronized SingleLazy2 getObject2(){
        if(null == singleLazy){
            singleLazy =  new SingleLazy2();
        }
        return singleLazy;
    }
    //如果有100个线程
    public static SingleLazy2 getObject(){
        if(null == singleLazy){
            //10个线程判断到singleLazy 为null
            //初始化加锁  只有一个线程  能获取锁 继续执行
            synchronized (SingleLazy2.class){
                //第一个线程直线完成后，后面的线程继续执行，这个时候 singleLazy 不为空，所以要判断是否为空
                if(null == singleLazy){
                    singleLazy =  new SingleLazy2();
                }
            }
        }
        return singleLazy;
    }
}

测试主函数

/**
 * @author meikb
 * @desc
 * @date 2020-05-23 10:38
 */
public class SingleMain {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 100; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        countDownLatch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    SingleLazy2 singleLazy2 =  SingleLazy2.getObject();
                    System.out.println(singleLazy2);
                }
            }).start();
        }
        countDownLatch.countDown();
    }
}