02_javaSE面试题:单例设计模式

还记得很多年前，面试就让在白板上写个单例模式，当时技术渣渣，还写的是class A.面试官还说，你就不能写个Singleton.

面试题

• 编程题：写一个Singleton示例

解析

什么是Singleton?

• Singleton: 就是指的java中的单例设计模式

• 单例模式：即某个类在整个系统中只有一个实例对象可被获取和使用的代码模式

  单例模式的特点

• 单例类只能有一个实例。
  • 构造函数私有化
• 单例类必须自己创建自己的唯一实例。
  • 含有一个该类的静态变量来保存这个唯一实例
• 单例类必须给所有其他对象提供这一实例。
  • 对外提供获取该实例对象的方式

单例模式常见的形式

• 饿汉式：直接创建对象，不存在线程安全的问题
  • 直接实例化饿汉式（简洁直观）
  • 枚举式（最简洁）
  • 静态代码块饿汉式（适合复杂实例化）
• 懒汉式：延迟创建对象
  • 线程不安全 （适合单线程）
  • 线程安全（适合多线程）
  • 静态内部类形式（适合多线程）

代码实战

饿汉式

(1) 直接实例化饿汉式

/**
 * 饿汉式（直接创建实例对象）
 * 直接通过类名调用
 *
 * @author kevin
 * @date 2019/7/8 11:23
 */
public class Singleton1 {
    public static final Singleton1 INSTANCE = new Singleton1();

    private Singleton1() {

    }
}

(2)枚举式

/**
 * 饿汉式（枚举）
 *
 * @author kevin
 * @date 2019/7/8 11:29
 */
public enum Singleton2 {
    INSTANCE;
}

(3) 静态代码块

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

/**
 * @author kevin
 * @date 2019/7/8 13:35
 */
public class Singleton3 {

    public static final Singleton3 INSTANCE;
    private String info;

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

    }

    private 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 + '\'' +
                '}';
    }
}

注意：这里还有个properties文件

info=kevin

测试

 Singleton3 s = Singleton3.INSTANCE;
 System.out.println(s);

结果

 Singleton3{info='kevin'}

懒汉式

（1）线程不安全

public class Singleton4 {

    private static Singleton4 instance;

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

    }
}

(2) 线程安全

/**
 * @author kevin
 * @date 2019/7/8 13:56
 */
public class Singleton5 {

    private static Singleton5 instance;

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

        return instance;
    }

    private Singleton5() {

    }
}

(3)静态内部类 线程安全

/**
 * 静态内部类不会自动随着外部类的加载而初始化
 *
 * @author kevin
 * @date 2019/7/8 13:56
 */
public class Singleton6 {
    private static class Inner {
        private static final Singleton6 INSTANCE = new Singleton6();
    }

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

    private Singleton6() {

    }
}

注意：静态内部类不会自动随着外部类的加载而初始化

总结

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

好了，玩的开心。

转载于:https://www.cnblogs.com/zhenghengbin/p/11150886.html