单例模式

1.饿汉式：

public class Singleton {
    //1.将构造函数私有化，不允许外部直接创建对象
    private Singleton(){

    }
    //2.创建类的唯一实例
    private static Singleton instance=new Singleton();

    //3.提供一个用于获取实例的方法
    public static Singleton getInstance(){
        return instance;
    }
}

线程安全，加载类时会比较慢，获取对象时很快。

2.懒汉式：

public class Singleton2 {
    //1.将构造函数私有化，不允许外部直接创建对象
    private Singleton2(){

    }
    //2.创建类的唯一实例
    private static Singleton2 instance;

    //3.提供一个用于获取实例的方法
    public static Singleton2 getInstance(){
        if(instance==null){
            instance=new Singleton2();
        }
        return instance;
    }

线程不安全，加载类时比较快，获取对象时比较慢。

3.同步懒汉式：

public class Singleton2 {
    //1.将构造函数私有化，不允许外部直接创建对象
    private Singleton2(){

    }
    //2.创建类的唯一实例
    private static Singleton2 instance;

    //3.提供一个用于获取实例的方法
    public static Singleton2 getInstance(){
        if(instance==null){
            instance=new Singleton2();
        }
        return instance;
    }

就是在getInstance方法前加同步关键字，解决懒汉式线程不安全的问题，但每次获取实例时都要判断锁，效率低，不推荐使用。

4.双重锁懒汉式：

public class Singleton3 {
    private volatile static Singleton3 singleton3;
    private Singleton3(){

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

线程安全，懒加载，效率高，推荐使用

5.静态内部类方式：

public class Singleton4 {
    private Singleton4(){

    }
    private static class SingletonInstance{
        private static final Singleton4 insance=new Singleton4();
    }

    public static Singleton4 getInstance(){
        return SingletonInstance.insance;
    }
与饿汉式相似，但是内部类的这种方式可以懒加载。