单例模式的设计思想和代码实现

单例模式：

• Singleton:在Java中即指单例设计模式，它是软件开发中最常见的设计模式
• 单：唯一
• 例：实例
• 单例设计模式，即某个类在整个系统中只能出现一个实例，对象可被获取和使用的代码模式
• 例如：代表JVM运行环境的Runtime类

要点：

• 一是某个类只能有一个实例（构造器私有化）
• 二是它必须自行创建这个实例（含有一个该类的静态变量来保存这个唯一的实例）
• 三是它必须自行向整个系统提供这个实例（可以直接暴露，也可以用get方法）

几种常见形式：

• 饿汉式：直接创建对象，不存在线程安全问题

1. 直接实例化饿汉式（简洁直观）
2. 枚举式（最简洁）
3. 静态代码块饿汉式（适合复杂实例化）

• 懒汉式：延迟创建对象

1. 线程不安全（适用于单线程）
2. 线程安全（适用于多线程）
3. 静态内部类形式（适用于多线程）

代码实现：

• 直接实例化饿汉式

package javaSE.Test2;

import org.omg.PortableInterceptor.INACTIVE;

/**
 * 饿汉式：在类初始化的时候，不管你需不需要，直接创建
 * 构造器私有化
 * 内部创建，并且用静态变量保存
 * 向外提供这个实例
 * static修饰的属性强调它们只有一个,随着类的加载而创建，可以类名直接调用
 * 用final修饰,被final修饰的变量可以保证在使用中不能被改变
 */
public class Singleton1 {
    //static 程序关闭，才回收该变量
    public static Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){
    }
}

• 枚举式

package javaSE.Test2;

/**
 * 饿汉式
 * 枚举类型：表示该类型的对象是有限的几个
 * 我们可以限定一个，就成了单例
 */
public enum Singleton2 {
    INSTANCE
}

• 静态代码块饿汉式（这个跟直接饿汉式最大的区别就是可以在实例化之前，增加一些操作）

package javaSE.Test2;

/**
 * 饿汉式
 */
import java.io.IOException;
import java.util.Properties;

public class Singleton3 {
   public static Singleton3 INSTANCE;
   private String info;
   static {
       try {
           Properties pro = new Properties();
          
    pro.load(Singleton3.class.getClassLoader().getResourceAsStream("single.properties"));
           INSTANCE = new Singleton3(pro.getProperty("info"));
       } catch (IOException e) {
           e.printStackTrace();
       }

   }

    public Singleton3(String info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Singleton3{" +
                "info='" + info + '\'' +
                '}';
    }
}

• 线程不安全

package javaSE.Test2;

/**
 * 懒汉式：延时创建这个实例对象
 * 构造器私有化
 * 用一个静态变量保存唯一的实例
 *
 */
public class Singleton4 {
    private static Singleton4 INSTANCE;
    private Singleton4(){

    }
    public static Singleton4 getInstance(){
        if (INSTANCE == null){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new Singleton4();
        }
        return INSTANCE;
    }
}

• 线程安全（对上面的代码进行加锁操作）

package javaSE.Test2;

/**
 * 懒汉式：延时创建这个实例对象
 * 构造器私有化
 * 用一个静态变量保存唯一的实例
 *
 */
public class Singleton5 {
    private static Singleton5 INSTANCE;
    private Singleton5(){

    }
    public static Singleton5 getInstance(){
        if (INSTANCE == null){
            synchronized (Singleton5.class){
                if (INSTANCE == null){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Singleton5();
                }
            }
        }

        return INSTANCE;
    }
}

• 静态内部类形式（静态内部类不会随着类的加载而加载，而是调用时会加载）

package javaSE.Test2;

/**
 * 懒汉式
 * 内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是要单独去加载和初始化
 */
public class Singleton6 {
    private Singleton6(){

    }

    private static class Inner{
        private static final Singleton6 INSTANCE = new Singleton6();
    }

    public static Singleton6 getInstance(){
        return Inner.INSTANCE;
    }
}