写一个单例，无论什么情况下都能保证只有一个

方式一：双重检查

package app;

/**
 * @author devilu
 */
public class Single{

    private static volatile Single instance;

    private Single() throws Exception {
        // 如果用反射的方式new，直接抛异常
        if(instance != null){
            throw new Exception(getClass()+"already instance");
        }
    };

    public static Single  getInstance() throws Exception {
        // 提高性能，不要一上来就加锁。
        if(instance == null){
            // 这里加锁其实就是因为 Volatile 不具备原子性
            synchronized (Single.class){
                if (instance == null){
                    instance = new Single();
                }
            }
        }
        return instance;
    }

}

方式二：静态代码块

package app;

public class SingleStatic {

    private static SingleStatic singleStatic;

    static {
        singleStatic = new SingleStatic();
    }

    private SingleStatic(){
        if(singleStatic != null){
            throw  new RuntimeException(getClass()+" already instance");
        }
    }

    public static SingleStatic getInstance(){
        return singleStatic;
    }

}

方式一测试：

public static void main(String[] args) throws Exception {


    Single single  = Single.getInstance();
    Single single1  = Single.getInstance();
    Single single2  = Single.getInstance();

    System.out.println(single);
    System.out.println(single1);
    System.out.println(single2);
    System.out.println("--------");


    Class<Single> singleClass = (Class<Single>) Class.forName("app.Single");
    Constructor<Single> declaredConstructor = singleClass.getDeclaredConstructor(null);
    declaredConstructor.setAccessible(true);
    Single single3 = declaredConstructor.newInstance();
    Single single4 = declaredConstructor.newInstance();
    System.out.println(single3);
    System.out.println(single4);

}

结果：