什么是单例模式，有哪些应用？

/**
 * 懒汉式  线程不安全
 */
public class SingletonLazy {
    //定义一个私有构造方法
    private SingletonLazy(){}
    //创建该类对象
    private static SingletonLazy instance;
    //对外提供静态方法获取该对象
    public static SingletonLazy getInstance(){
        if(instance==null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

2、懒汉式，线程安全

由于上述会出现线程不安全问题，所以我们通过加同步锁，保证每次只有一个线程可以对当前对象进行操作，确保了线程安全。但加锁会影响效率。

/**
 * 懒汉式  线程安全
 */
public class SingletonLazy {
    //定义一个私有构造方法
    private SingletonLazy(){}
    //创建该类对象
    private static SingletonLazy instance;
    //对外提供静态方法获取该对象 , 加锁
    public static synchronized SingletonLazy getInstance(){
        if(instance==null){
            instance = new SingletonLazy();
        }
        return instance;
    }
}

3、双检锁/双重校验锁（DCL，即 double-checked locking）

我们使用volatile关键字, volatile 关键字可以保证可见性和有序性，这个关键字禁止了对当前修饰的变量上下文重排序。保证了方法的可靠性。采用双锁机制，安全且在多线程情况下能保持高性能。

进行二次判断的原因：

假设有两个线程a，b，他们都去请求我们单例模式下类的实例，当第一个判断的时候，两个线程都会进入判断代码块中进行锁的抢占，最终a抢占到了锁，那么b只能在加锁的代码块外部进行等候。这个时候a创建了对象的实例，完成功能后归还了锁，这个时候线程b马上抢占到了锁，然后进入内部代码块。假如没有第二次判断的话，线程a就会再次创建一个新的对象，导致线程不安全。所以，要在这里再加一次判断。

/**
 * 懒汉式  双重校验锁
 */
public class SingletonLazy {
    //定义一个私有构造方法
    private SingletonLazy(){}
    //创建该类对象
    private volatile static SingletonLazy instance;
    //对外提供静态方法获取该对象 , 加双重锁
    public static SingletonLazy getInstance(){
        if(instance==null){
            synchronized (instance.getClass()){
                if(instance == null){
                    instance = new SingletonLazy();
                }
            }
        }
        return instance;
    }
}

4、静态内部类方式-------只适用于静态域

静态内部类单例模式中实例由内部类创建，由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的，只有内部类的属性/方法被调用时才会被加载，并初始化其静态属性。静态属性由于被 static 修饰，保证只被实例化一次，并且严格保证实例化顺序。

/**
 * 静态内部类方式
 */
public class SingletonLazy {
    //私有构造方法
    private SingletonLazy() {}
    //定义静态类
    private static class SingletonHolder {
        //静态方法
        private static final SingletonLazy INSTANCE = new SingletonLazy();
    }
    //对外提供静态方法获取该对象
    public static SingletonLazy getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

5、饿汉式

它基于 classloader 机制避免了多线程的同步问题，instance 在类装载时就实例化。

/**
 * 饿汉式
 */
public class SingletonEhan {
    //私有构造方法
    private SingletonEhan(){}
    //创建并实例化该类对象
    private static SingletonEhan instance = new SingletonEhan();
    //对外提供静态方法获取该对象
    public static SingletonEhan getInstance(){
        return instance;
    }
}

6、枚举

这种实现方式还没有被广泛采用，但这是实现单例模式的最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

四、总结

一般情况下，使用第5种饿汉式。