1.单例模式概念：

2.饿汉式

饿汉就是一个迫切的意思，类加载就会导致该单实例被创建

饿汉式第一种方式：

class Singleton{

//在本类中创建本类对象
    private static Singleton instance=new Singleton();

//提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }

//私有构造方法
    private Singleton() {
    }
}

我们来对上面这个饿汉式解析一下：

饿汉式第二种方式：

class Singleton2{

private static Singleton2 instance ;

static {
    instance=new Singleton2();
}

//对外提供方法获取该对象
public static Singleton2 getInstance(){
    return instance;
}

    //私有化的构造方法
    private Singleton2() {
    }
}

饿汉式第三种方式（枚举方式）：

public enum Singleton3{
    instance;
}

饿汉式总结说明：

这种方式在成员位置声明Singlleton类型的静态变量，并创建Singleton类的对象instance。instance对象会随着类的加载而创建。如果对象足够大1的话，而一直没有使用就会造成内存的浪费

2.懒汉式

类加载不会导致该单实例对象被创建，而是首次使用才会被创建

懒汉式第一种方式（线程不安全的）：

class Singleton3{
//声明成员变量，不进行初始化
    private static Singleton3 instance;

//提供获取对象的方法
    public static Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }

//私有化的构造方法
    private Singleton3() {
    }
}

懒汉式第二种方式（线程安全的）：

class Singleton3{
    private static Singleton3 instance;

    public static synchronized Singleton3 getInstance(){
        if(instance==null){
            instance=new Singleton3();
        }
        return instance;
    }
    private Singleton3() {
    }
}

懒汉式第三种方式（双重检查锁）：

class Singleton3{
    private static Singleton3 instance;

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

对双重检查锁的优化：

class Singleton3{
    private static volatile Singleton3 instance;

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

添加volatile关键字之后，能够保证多线情况下的线程安全也不会有性能问题

懒汉式第四种方式（静态内部类）：

class Singleton4{
private static class SingletonHolder{
private final static Singleton4 INSTANCE=new Singleton4();    
}

public static Singleton4 getInstance(){
    return SingletonHolder.INSTANCE;
}
    private Singleton4() {
    }
}

静态内部类的方式在没有加锁的情况下，保证了线程安全，有没有影响性能和空间的浪费