单例模式

单例模式是为了确保系统中某个类只存在一个实例。 在多种写法中，推荐使用静态内部类方式，利用类加载一次特性确保只有一个实例（线程安全）， 同时具备无锁和懒创建优点。 示例：

public class StaticInnerClassSingleton {
    // 私有化构造方法
    private StaticInnerClassSingleton(){}
    // 内部类
    static class Holder{
        static StaticInnerClassSingleton INSTANCE = new StaticInnerClassSingleton();
    }
    // 获取实例对象
    public static StaticInnerClassSingleton getInstance(){
        return Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for(int i=0;i<10;i++){
            new Thread(()->{
                System.out.println(StaticInnerClassSingleton.getInstance());
            }).start();
        }
    }
}

不变模式

在并发场景中，不变对象是不需要同步操作的。（因为对象不会改变，所以多个线程访问不会出现不一致问题） 特征：

  1. class被修饰为final
  2. 属性是私有且被final修饰的

JDK中所有的元数据类、包装类都是使用不变模式实现的。

java.lang.String
java.lang.Boolean
java.lang.Byte
java.lang.Character
java.lang.Double
java.lang.Float
java.lang.Integer
java.lang.Long
java.lang.Short

例子：

public final class FinalCat {// final 确保无子类
    private final String name;// final 确保属性
    private final Integer age;

    public FinalCat(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "FinalCat{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        FinalCat cat = new FinalCat("皮侃子", 4);
        System.out.println(cat);
    }
}