单例模式详解（JAVA）

两种常见形式

1.饿汉式

• 特点：直接创建对象，不存在线程安全问题
• 直接实例化饿汉式（简洁直观）
• • 直接创建实例对象，不管你是否需要这个对象都会创建

1. 构造器私有化。
2. 自行创建，并且用静态变量保存。
3. 向外提供这个实例。
4. 强调这是一个单例，我们可以用final修饰

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

• 枚举式（最简洁）

public enum Singleton2 {
    INSTANCE;
}

• 静态代码块饿汉式（适合复杂实例化）

package com.single;


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

public class Singleton3 {
    public static final 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) {
            throw new RuntimeException(e);
        }
    }

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

    public String getInfo() {
        return info;
    }

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

2.懒汉式

• 特点：延迟创建对象
• 线程不安全（适用于单线程）

package com.single;

/**
 * 懒汉式：
 *  延迟创建这个实例对象,适合单线程，线程不安全
 *
 *  1.构造器私有化。
 *  2.用一个静态变量保存这个唯一的实例。
 *  3.提供一个静态方法，获取这个实例对象。
 */
public class Singleton4 {
    public static Singleton4 instance ;
    private Singleton4(){
    }
    public static Singleton4 getInstance(){
        if (instance == null){
            instance = new Singleton4();
        }
        return instance;
    }
}

• 线程安全（适用于多线程）

package com.single;

/**
 * 懒汉式：线程安全版
 *  延迟创建这个实例对象
 *
 *  1.构造器私有化。
 *  2.用一个静态变量保存这个唯一的实例。
 *  3.提供一个静态方法，获取这个实例对象。
 */
public class Singleton5 {
    public static Singleton5 instance ;
    private Singleton5(){
    }
    public static Singleton5 getInstance(){
        if (instance == null) {
            synchronized (Singleton5.class) {
                if (instance == null) {
                    try {
                        Thread.sleep(10000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    instance = new Singleton5();
                }
            }
        }

        return instance;
    }
}

• 静态内部类形式（适用于多线程）

package com.single;

/**
 * 在内部类别加载和初始化是，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化二初始化，他是要单独去加载和初始化的。
 * 因为实在内部类加载和初始化时，创建的，因此是线程安全的
 */
public class Singleton6 {

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