前言

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：1.单例类只能有一个类。2单例类必须创建自己的唯一id.

3、单例类必须给所有其他对象提供这一实例。

单例模式的实现

单例设计模式分为两种：

饿汉式：类加载就会导致该单实例对象被创建。

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

饿汉式实现方式一：静态变量方式

public class Singleton {

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

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

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

public class Main {
    public static void main(String[] args) {
        //创建Singleton类的对象
       Singleton instance= Singleton.getInstance();
       Singleton instance1= Singleton.getInstance();

        System.out.println(instance==instance1);
    }
}

饿汉式实现方式二：静态代码块

public class Singleton {
    //1.私有构造方法，防止被外界创建
    private Singleton(){};

    //声明Singleton类型的变量
    private  static  Singleton instance;//null
    //在静态代码块中进行赋值
    static {
        instance=new Singleton();
    }
    //对外界提供获取该类对象的方法
    public static Singleton getInstance(){
        return instance;
    }


}

public class Main {

    public static void main(String[] args) {
        //创建Singleton类的对象
         Singleton instance= Singleton.getInstance();
         Singleton instance1= Singleton.getInstance();

        System.out.println(instance==instance1);
    }
}

饿汉式实现方式三：枚举

public enum Singleton {
    INSTANCE;
}

public class Main {


    public static void main(String[] args) {
        //创建Singleton类的对象
       Singleton instance= Singleton.INSTANCE;
      Singleton instance1= Singleton.INSTANCE;

        System.out.println(instance==instance1);
    }

}

懒汉式实现方法一：（线程不安全）

public class Singleton {

    //1.私有构造方法，防止被外界创建
    private Singleton(){};

    //声明Singleton类型的变量,并没有进行赋值
    private  static Singleton instance;//null

    //对外界提供获取该类对象的方法
    public static Singleton getInstance(){
        if(instance==null)
        {
            instance=new Singleton();
        }

        return instance;
    }


}

但是这种方法在多线程里是不安全的，当有两个线程时，一个线程执行到判断语句判断instance是否为null时，处于等待状态，而另一个线程获得CPU的执行权，也会进行判断里面，这时会创建两个Singleton对象。

懒汉式实现方法二：加入synchronized

public class Singleton {

    //1.私有构造方法，防止被外界创建
    private Singleton(){};

    //声明Singleton类型的变量,并没有进行赋值
    private  static Singleton instance;//null

    //对外界提供获取该类对象的方法
    public static synchronized Singleton getInstance(){
        if(instance==null)
        {
            instance=new Singleton();
        }

        return instance;
    }


}

懒汉式实现方法三：双重检查方式

public class Singleton {

    //1.私有构造方法，防止被外界创建
    private Singleton(){};

    //声明Singleton类型的变量,并没有进行赋值
    private  static Singleton instance;//null

    //对外界提供获取该类对象的方法
    public static Singleton getInstance(){
        //第一次判断，如果instance的值不为null,不需要抢占锁，直接返回对象
        if(instance==null)
        {
            synchronized (Singleton.class){
                //第二次判断
                if(instance==null)
                {
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式的优缺点：缺点：可能会出现空指针问题。解决方法：使用volatile关键字。 volatile保证可见性和有序性。

懒汉式实现方法四：静态内部类方式

public class Singleton {

    //1.私有构造方法，防止被外界创建
    private Singleton(){};

    //定义一个静态内部类
    private  static class SingletonHolder{
        //在内部类中声明并初始化内部类的对象
        private  static final Singleton INSTANCE=new Singleton();
    }

    //对外界提供获取该类对象的方法
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}