Java实现不加锁的线程安全的单例模式

Java架构师交流群：793825326

java版本：jdk1.8

IDE：idea 18

public class Singleton {
    public Singleton()
    {
        System.out.println("初始化");
    }
    private static class Inner
    {
        private static Singleton s=new Singleton();
    }
    public static Singleton getInstance()
    {
        return Inner.s;
    }

这种单例模式既是线程安全的，也是延迟加载的，既使用的时候才会被加载。

单例模式中所谓恶汉模式，是指还未使用的时候，就提前实例化好，懒汉模式是指使用的时候才开始实例化。

本例中是如何保证线程安全的呢，看下面的代码：

public class Singleton {
    public static final Singleton ton=new Singleton();
    public Singleton()
    {
        System.out.println("初始化");
    }
}

当有代码尝试获取ton，虚拟机就会自动把这个Singleton初始化，这个工作由虚拟机来做，而且是保证线程安全的。这个代码我们经常用，应该不会有什么疑问。现在再写一个类Inner：

public class Inner {
    public static Singleton s=new Singleton();
}

把原来的Singleton类改为如下：

public class Singleton {
    public Singleton()
    {
        System.out.println("初始化");
    }
    public static Singleton getInstance()
    {
        return Inner.s;
    }
}

这个显然也是线程安全的，因为Inner类的Singleton对象是虚拟机来自动完成的，它会保证线程安全。既然是这样，那么如果把Inner类改为Singleton的内部类，那么Singleton的实例化是否仍然是线程安全的呢，答案是肯定的，因为仍然是虚拟机自动完成的。改了之后的代码如下：

public class Singleton {
    public Singleton()
    {
        System.out.println("初始化");
    }
    public static Singleton getInstance()
    {
        return Inner.singleton;
    }

    private static class Inner
    {
        private static Singleton singleton=new Singleton();
    }
}

这样就和最初我们看到的代码一样了。事实上我之前在另一篇博客里面讲过，所谓内部类，其实在编译的时候最终都会自动生成一个class文件的，如下：

这个类通过编译器打开，看到的代码如下：

它和我们之前创建的Inner类是完全一样的。