java 实现单例

1、饿汉式

//饿汉式单例类.在类初始化时，已经自行实例化
//天生线程安全，类加载机制，只会加载一次
public class Singleton1 {
    //私有的默认构造子
    private Singleton1() {}
    //已经自行实例化
    private static final Singleton1 single = new Singleton1();
    //静态工厂方法
    public static Singleton1 getInstance() {
        return single;
    }
}

2、懒汉式

// 传统懒汉式单例  【线程不安全】
public class Singleton2 {

    // 指向自己实例的私有静态引用
    private static Singleton2 singleton2;

    // 私有的构造方法
    private Singleton2(){}

    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton2 getSingleton2(){
        // 被动创建，在真正需要使用时才去创建
        if (singleton2 == null) {
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

3、懒汉式 【线程安全】

// 传统懒汉式单例  【线程安全】
//静态代码块中创建单例对象
public class Singleton3 {
    // 1、构造器私有化
    private Singleton3(){}
    // 2、本类内部创建对象实例
    private final static Singleton3 instance;
    // 3、在静态代码块中创建单例对象
    static {
        instance = new Singleton3();
    }

    // 4、提供一个公有静态方法返回实例对象
    public static Singleton3 getInstance(){
        return instance;
    }
}

4、懒汉式 【线程安全】双重检测锁DCL

/**
 * 懒汉式
 * 双重检测锁【线程安全】
 * 线程安全且效率较高，实现了延迟加载，推荐使用
 */
public class Singleton4 {

    //使用volatile关键字防止重排序，因为 new Instance()是一个非原子操作，可能创建一个不完整的实例
    private static volatile Singleton4 singleton4;

    private Singleton4() {
    }

    public static Singleton4 getSingleton4() {
        // Double-Check idiom
        if (singleton4 == null) {
            synchronized (Singleton4.class) {       // 1
                // 只需在第一次创建实例时才同步
                if (singleton4 == null) {       // 2
                    singleton4 = new Singleton4();      // 3
                }
            }
        }
        return singleton4;
    }
}

5、静态内部类【推荐使用】

/**
 * 静态内部类【推荐使用】
 * 1、外部类装载时静态内部类不会被装载
 * 2、类的静态属性只会在第一次加载类的时候初始化，所以在这里JVM帮助
 * 我们保证的线程的安全性，因为在类进行初始化时，别的线程无法进入
 */
public class Singleton5 {

    // 1、构造器私有化
    private Singleton5(){}

    // 2、静态内部类；该类中有一个静态属性
    private static class SingletonInstance{
        private static final Singleton5 INSTANCE = new Singleton5();
    }

    // 3、提供一个公有静态方法直接返回SingletonInstance.INSTANCE
    public static Singleton5 getInstance(){
        return SingletonInstance.INSTANCE;
    }
}

6、枚举【推荐使用】

/**
 * 枚举【推荐使用】，不存在反射攻击私有构造
 * 获取单例对象：Singleton.INSTANCE;
 */
public enum Singleton6 {

    INSTANCE;

    public static Singleton6 getInstance(){
        return INSTANCE;
    }
    
	public void sayOk(){
        System.out.println("ok");
    }
	
	// 单例对象的操作方法
    public void doSomething() {
        // 实现具体的业务逻辑
    }

}

7、枚举【推荐使用】

/**
 * 枚举【推荐使用】
 */
public class Singleton7 {

    // 1、构造器私有化
    private Singleton7(){}

    //定义一个静态枚举类
    static enum SingletonEnum{
        //创建一个枚举对象，该对象天生为单例
        INSTANCE;
        private Singleton7 singleton7;
        //私有化枚举的构造函数
        private SingletonEnum(){
            singleton7=new Singleton7();
        }
        public Singleton7 getInstnce(){
            return singleton7;
        }
    }

    //对外暴露一个获取Singleton7对象的静态方法
    public static Singleton7 getInstance(){
        return SingletonEnum.INSTANCE.getInstnce();
    }
}

**《effective java》中只简单的提了几句话：“享有特权的客户端可以借助AccessibleObject.setAccessible方法，通过反射机制调用私有构造器。如果需要低于这种攻击，可以修改构造器，让它在被要求创建第二个实例的时候抛出异常。**