单例模式

• 1. 懒汉模式
• 2. 饿汉模式
• 3. 内部类实现
• 4. 枚举实现

1. 懒汉模式

public class LazySingletonTest {
    public static void main(String[] args) {
        new Thread(() -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
        new Thread(() -> {
            LazySingleton instance = LazySingleton.getInstance();
            System.out.println(instance);
        }).start();
    }
}

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

2. 饿汉模式

public class HungrySingletonTest {
    public static void main(String[] args) {
        HungrySingleton instence1 = HungrySingleton.getInstance();
        HungrySingleton instence2 = HungrySingleton.getInstance();
        System.out.println(instence1 == instence2);
    }
}

class HungrySingleton {
    private static HungrySingleton instence = new HungrySingleton();
    private HungrySingleton() {
    }
    public static HungrySingleton getInstance() {
        return instence;
    }
}

3. 内部类实现

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class InnerClassSingletonTest {
    public static void main(String[] args) {
        InnerClassSingleton instance1 = InnerClassSingleton.getInstance();
        InnerClassSingleton instance2 = InnerClassSingleton.getInstance();
        System.out.println(instance1 == instance2);
        try {
            Constructor<InnerClassSingleton> declaredConstructor = InnerClassSingleton.class.getDeclaredConstructor();
            declaredConstructor.setAccessible(true);
            InnerClassSingleton instance3 = declaredConstructor.newInstance();
            System.out.println(instance1 == instance3);
            System.out.println(instance2 == instance3);
        } catch (InvocationTargetException e) {
            System.out.println(e);
            Throwable t = e.getTargetException();
            t.printStackTrace();
        } catch (Exception err) {
            System.out.println(err);
        }
    }
}

class InnerClassSingleton {
    private static class InnerClassHolder {
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }
    private InnerClassSingleton() {
        if (InnerClassHolder.instance != null) {
            throw new RuntimeException("Singleton can't new too much instances.");
        }
    }
    public static InnerClassSingleton getInstance() {
        return InnerClassHolder.instance;
    }
}

4. 枚举实现

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class EnumSingletonTest {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        EnumSingleton instance1 = EnumSingleton.INSTANCE;
        EnumSingleton instance2 = EnumSingleton.INSTANCE;
        System.out.println(instance1 == instance2);
        Constructor<EnumSingleton> declaredConstructor = EnumSingleton.class.getDeclaredConstructor();
        declaredConstructor.setAccessible(true);
        declaredConstructor.newInstance("INSTENCE", 0);
    }
}

enum EnumSingleton {
    INSTANCE;
    public void print() {
        System.out.println(this.hashCode());
    }
}