编写一个Singleton示例

单例设计模式，即某个类在整个系统中只能有一个实例对象可以被获取和使用的代码模式。
例如：代表JVM运行环境的RunTime类。

1、要点

1）、某个类只能有一个实例。
- 实现：构造器私有化（外面不能随意去创建它）。
2）、它必须自行创建这个类。
- 实现：含有一个该类的静态变量来保存这个这个唯一实例。
3）、它必须向整个系统提供这个实例。
- 实现：①、直接暴露。 ②、提供getter方法。
4）、为了强调这个类是个单例，我们可以用final修饰。

如果 xx.properties放在src（类路径）下，那么我们可以通过prop.load( Singleton.class.getClassLoader().getResourceAsStream("xx.properties"))加载资源。

2、常见的单例形式

饿汉式：直接创建对象，不存在线程安全问题
- 直接实例化饿汉式
- 枚举式（推荐）
- 静态代码块饿汉式
懒汉式
- 线程不安全
- 线程安全
- 静态内部类（推荐）

第一种：直接实例化饿汉式（简单直接，不存在线程安全问题）

package org.example.singleton;

/**
 * 饿汉式：直接创建实例对象，不管是否需要这个对象都会创建实例。
 */
public class Singleton1 {

    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){

    }
}

第二种：枚举式（最简洁，跟上面一样效果还更简洁了，推荐）

package org.example.singleton;

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

第三种：静态代码块饿汉式（适合复杂实例化）

package org.example.singleton;

import java.io.IOException;
import java.util.Properties;

/**
 * 饿汉式：直接创建实例对象，不管是否需要这个对象都会创建实例。
 */
public class Singleton3 {

    public static final Singleton3 INSTANCE;
    private String info;

    static {
        Properties prop = new Properties();
        try {
            prop.load(Singleton3.class.getClassLoader().getResourceAsStream("xx.properties"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        INSTANCE = new Singleton3(prop.getProperty("info"));
    }

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

    public String getInfo() {
        return info;
    }
}

报错：

原因：

maven项目的默认classpath问题：classpath的路径指 src/main/resources

解决：

创建src/main/resources目录，然后把xx.properties移动进去即可。

第四种：懒汉式（只适合单线程，多线程会有安全性问题）

package org.example.singleton;

import java.io.IOException;
import java.util.Properties;

/**
 * 懒汉式：延迟创建实例。
 */
public class Singleton4 {

    private static Singleton4 instance;

    private Singleton4() {

    }

    public Singleton4 getInstance() {
        if (instance == null) {
            instance = new Singleton4();
        }
        return instance;
    }
}

测试：

第五种：双检查

package org.example.singleton;


public class Singleton5 {

    private static Singleton5 instance;

    private Singleton5() {

    }

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

为了安全，加上synchronized (Singleton5.class)同步监视器已经解决了，外面加上一层if判断是为了性能问题，如果有实例了就不等待锁了。

第六种：静态内部类

package org.example.singleton;

/**
 * 静态内部类：我们就不用一个静态变量去保存这个实例了，我们用一个内部类去存储实例。
 * 延迟创建实例：在当内部类被加载和初始化的时候，才创建INSTANCE实例对象。
 * 因为内部类是在加载和初始化时创建实例，所以是线程安全的。
 */
public class Singleton6 {

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

    private Singleton6() {

    }

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