关于单例设计者模式的实现，Java面试题-CSDN博客

本文链接：https://blog.csdn.net/qq_52252193/article/details/124093563

4.懒汉式当你需要时，调用函数来获得，这里不加锁，是线程不安全的

5.这里加锁，是线程安全的

6.懒汉式，内部类的方式

测试

概要描述

代码实现

1.饿汉式的直接实例化的

package Singleton;
//饿汉式  的直接实例化的
/**  直接创建，不管是否需要这个对象
 *
 *   static 静态，类加载时，它  所修饰的代码块直接加载
 * 1.只能有一个实例（构造器私有）
 * 2.自行创建一个实例（用静态变量保存）
 * 3.向外提供这个实例， （静态访问，这个类.类名）
 *   4.强调是单列 （使用final修饰）
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();
      //定义静态的final的变量，用来向外提供
    private Singleton1(){
           //私有的构造器
    }
}

2.饿汉式枚举类型获得

//饿汉式  枚举类型获得
// 可以设定为 限定一个   --->就成为了单例
public enum Singleton2 {
     INSTANCE  //这个就是枚举类型的常量名
}

3.静态代码块创建

//静态代码块 创建
public class Singleton3 {

    public static final Singleton3 INSTANCE ;
    public String info;
     static {
         //INSTANCE=new Singleton3("我是你爸爸");
  放入静态代码块中，就是简单的实现 ，下面读取文件是扩充      

       //改为静态带代码块，适合可能会读取一些数据的情况
         try {
             Properties pro = new Properties();
             pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));

             //从配置文件中获取
             String  str = pro.getProperty("info");
             INSTANCE = new Singleton3(str);

         } catch (IOException e) {
             throw new RuntimeException();
         }
         
     }
    private  Singleton3(String info){
         this.info = info;
    }

4.懒汉式当你需要时，调用函数来获得，这里不加锁，是线程不安全的

/**延迟创建实例对象，需要时才创建
 *
 * 1.构造器私有化
 * 2.静态方法保存唯一实例对象，，--> 要是私有的，只能通过方法调用，不能直接类.
 * 3.提供静态方法，调用时创建这个实例
 */
public class Singleton4 {
    private static Singleton4 instance;

    private  Singleton4(){

    }
    public static Singleton4 getInstance(){
        if(instance==null){
            try {
                Thread.sleep(200);
                //猜测睡眠，多线程是否安全问题  ,会导致new 两个对象的
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            instance= new Singleton4();
        }
        return instance;
    }
 }

5.这里加锁，是线程安全的

6.懒汉式，内部类的方式

/** 在内部类被加载和初始化时，才会创建 INSTANCE 实例对象
 * 静态内部类 不会自动 随着外部类的加载和初始化 而初始化 ，他要单独的加载和从初始化
 *
 * 因为这个实例是在 内部类初始化和加载时，才创建的，所以是线程安全的
 *
 * 1.创建私有构造器
 * 2.创建私有的内部类
 * 3.内部类中封装 这个实例对象的静态变量
 * 4.创建返回对象的方法  (返回内部类的实例变量）
 */
public class Singleton6 {
   private Singleton6(){

   }
   private static class Inner{
       private static final Singleton6 INSTANCE = new Singleton6();
   }
   public  static  Singleton6 getInstance(){
       return Inner.INSTANCE;
   }

}