大厂面试--单例设计模式

饿汉式:
直接实例化饿汉式

package com.main.single;


/**
 * 饿汉式：
 *      直接创建实例对象，不管你是否需要这个对象都会创建
 *
 *      （1）构造器私有化
 *      （2）自行创建，并且用静态变量保存
 *      （3）向外提供这个实例
 *      （4）强调这是一个单例，我们可以用final修改
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();
    private Singleton1(){

    }
}

枚举：

package com.main.single;

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

静态代码块式：（properties文件中的内容为info=xxxx）

package com.main.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("application.properties"));
            INSTANCE = new Singleton3(pro.getProperty("info"));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
    public Singleton3(String info){
        this.info = info;
    }

    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }

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

懒汉式：
线程不安全的

package com.main.single;
/**
 * 线程不安全（单线程）
 *  懒汉式：
 *     延迟创建这个实例对象
 *      1.构造器私有化
 *      2，用一个静态变量保存这个唯一的实例
 *      3，提供一个静态方法，获取这个实例对象
 */
public class Singleton4 {
    private static Singleton4 instance;
    public Singleton4(){

    }

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

线程安全的：

package com.main.single;
/**
 * 线程安全（多线程）
 *  懒汉式：
 *     延迟创建这个实例对象
 *      1.构造器私有化
 *      2，用一个静态变量保存这个唯一的实例
 *      3，提供一个静态方法，获取这个实例对象
 */
public class Singleton5 {
    private static Singleton5 instance;
    public Singleton5(){

    }

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

        }
        return instance;
    }
}

静态内部类：

package com.main.single;
/**
 * 线程安全(多线程)
 *  懒汉式：
 *     延迟创建这个实例对象
 *      1.构造器私有化
 *      2，用一个静态变量保存这个唯一的实例
 *      3，提供一个静态方法，获取这个实例对象
 */

//静态内部类
public class Singleton6 {
    public Singleton6(){

    }

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

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

饿汉式枚举最简单，懒汉式静态内部类最简单。