单列模式

package com.java.singleton;

/**
 * 单例模式
 * 
 */
public class SingletonTest {

    public static void main(String[] args) {
        Singleton7 instance1 = Singleton7.getInstance();
        Singleton7 instance2 = Singleton7.getInstance();

        System.out.println(instance1 == instance2);
    }

}

/**
 * 饿汉式
 * 对象随着类的加载被创建，类只加载一次，因此饿汉式无多线程安全问题
 * 缺点：若某个实例不被使用，有点浪费资源
 */
enum Singleton1 {
    INSTANCE;
}

class Singleton2 {
    public static final Singleton2 INSTANCE = new Singleton2();
}

class Singleton3 {
    private static final Singleton3 INSTANCE = new Singleton3();

    private Singleton3() {

    }

    public static Singleton3 getInstance() {
        return INSTANCE;
    }
}

/**
 * 懒汉式
 * 不考虑多线程安全问题
 */
class Singleton4 {
    private static Singleton4 instance = null;

    private Singleton4() {

    }

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

        return instance;
    }
}

/**
 * 懒汉式需要考虑多线程安全问题
 * 缺点：每次调用方法，都需要先判断锁的操作，因此效率低，不建议使用
 */
class Singleton5 {
    private static Singleton5 instance = null;

    private Singleton5() {

    }

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

        return instance;
    }
}

/**
 * 懒汉式，虽然第一次多判断了一个if，但是后续的线程不需要每次都判断锁的操作，因此效率略高，建议使用
 */
class Singleton6 {
    private static Singleton6 instance = null;

    private Singleton6() {

    }

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

        return instance;
    }
}

/**
 * 静态内部类:该方式，外部类被加载，内部类中对象不会被创建，也可实现延迟加载，因此建议使用
 */
class Singleton7 {

    private static class InnerClass {
        private static final Singleton7 INSTANCE = new Singleton7();
    }

    public static Singleton7 getInstance() {
        return InnerClass.INSTANCE;
    }
}