1.饿汉式（不支持并发）

此模式只能运行在单线程下，且类在加载时就已经创建好了实例，不管需不需要用。

package com.lys;

//饿汉式
public class Singleton1 {
    private Singleton1() {
    }
    private static Singleton1 instance = new Singleton1();
    
    public static Singleton1 getInstance(){
        return instance;
    }

}

2.懒汉式(不支持并发)

此模式只能运行在单线程下，在调用获取实例的方法时才创建实例。

package com.lys;

//懒汉式、不支持多并发
public class Singleton2 {
    private Singleton2() {
    }
    private static Singleton2 instance = null;
    public static Singleton2 getInstance(){
        if (instance == null){
            instance = new Singleton2();
        }
        return instance;
    }

}

3.懒汉式(支持并发、synchronized)

synchronized 锁住了整个方法，当有多个线程需要访问方法时，不管实例有没有创建，都会要排队等待才能拿到实例，效率低。
需要改进：只有第一次创建实例时才需要锁，其他时候不需要加锁。

package com.lys;

//懒汉式、支持多并发、效率低
public class Singleton3 {
    private Singleton3() {
    }
    private static Singleton3 instance = null;
    public synchronized static Singleton3 getInstance(){
        if (instance == null){
            instance = new Singleton3();
        }
        return instance;
    }

}

4.双重检查锁 (volatile)–常用

volatile 关键字保证了内存可见性，所有线程都会去主存中取数据而不是在线程的缓存中取，保证了数据的更新能实时地对任何线程可见。
假如有两个线程同时到达了1，它们都去创建实例，这时候如果没有第二次判断，就会多次创建实例了。二次判断保证了多线程下只创建一个实例。

package com.lys;

//double checked locking、支持多并发、效率高、添加volatile关键字
public class Singleton4 {
    private Singleton4() {
    }
    private volatile static Singleton4 instance = null;
    public static Singleton4 getInstance(){
        if (instance == null){//1
            synchronized (Singleton4.class) {
                if (instance == null)//2
                    instance = new Singleton4();
            }
        }
        return instance;
    }
}

5.静态私有内部类（最常用）

内部类的好处：内部类在被调用的时候才实例化其静态成员变量，高！

package com.lys;

//静态私有内部类、支持多并发、效率高、
public class Singleton5 {
    private Singleton5() {
    }
    private static class SingletonHolder{
        private static Singleton5 instance = new Singleton5();
    }
    public static Singleton5 getInstance(){
        return SingletonHolder.instance;
    }
}