前几天看了下公司代码中的一个单例类，发现居然是用静态内部类实现的。后面在网上找了下资料，发现使用静态内部实现的单例是懒加载的且线程安全。
从网上资料得出如下结论：
加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。
一、代码
package com.zxy.test;
/**
* 使用静态内部类实现的单例类
* @author ZENG.XIAO.YAN
* @date 2017-08-08 10:29:20
* @version V1.0
*/
public class UserSingleton {
/** 私有化构造器 */
private UserSingleton() {
}
/** 对外提供公共的访问方法 */
public static UserSingleton getInstance() {
return UserSingletonHolder.INSTANCE;
}
/** 写一个静态内部类，里面实例化外部类 */
private static class UserSingletonHolder {
private static final UserSingleton INSTANCE = new UserSingleton();
}
}26 1
package com.zxy.test;2
/** 3
* 使用静态内部类实现的单例类4
* @author ZENG.XIAO.YAN 5
* @date 2017-08-08 10:29:206
* @version V1.0 7
*/8
9
public class UserSingleton {10
11
/** 私有化构造器 */12
private UserSingleton() {13
}14
15
/** 对外提供公共的访问方法 */16
public static UserSingleton getInstance() {17
return UserSingletonHolder.INSTANCE;18
}19
20
21
/** 写一个静态内部类，里面实例化外部类 */22
private static class UserSingletonHolder {23
private static final UserSingleton INSTANCE = new UserSingleton();24
}25
26
}package com.zxy.test;
/**
* 使用静态内部类实现的单例类
* @author ZENG.XIAO.YAN
* @date 2017-08-08 10:29:20
* @version V1.0
*/
public class UserSingleton {
/** 私有化构造器 */
private UserSingleton() {
}
/** 对外提供公共的访问方法 */
public static UserSingleton getInstance() {
return UserSingletonHolder.INSTANCE;
}
/** 写一个静态内部类，里面实例化外部类 */
private static class UserSingletonHolder {
private static final UserSingleton INSTANCE = new UserSingleton();
}
}x 1
package com.zxy.test;2
/** 3
* 使用静态内部类实现的单例类4
* @author ZENG.XIAO.YAN 5
* @date 2017-08-08 10:29:206
* @version V1.0 7
*/8
public class UserSingleton {9
10
/** 私有化构造器 */11
private UserSingleton() {12
}13
14
/** 对外提供公共的访问方法 */15
public static UserSingleton getInstance() {16
return UserSingletonHolder.INSTANCE;17
}18
19
/** 写一个静态内部类，里面实例化外部类 */20
private static class UserSingletonHolder {21
private static final UserSingleton INSTANCE = new UserSingleton();22
}23
24
}二、小结
（1）为什么这样实现就是单例的？ 因为这个类的实例化是靠静态内部类的静态常量实例化的。 INSTANCE 是常量，因此只能赋值一次；它还是静态的，因此随着内部类一起加载。
（2）这样实现有什么好处？
我记得以前接触的懒汉式的代码好像有线程安全问题，需要加同步锁才能解决。
采用静态内部类实现的代码也是懒加载的，只有第一次使用这个单例的实例的时候才加载；
同时不会有线程安全问题
（3）参考文档
