前几天看了下公司代码中的一个单例类，发现居然是用静态内部类实现的。后面在网上找了下资料，发现使用静态内部实现的单例是懒加载的且线程安全。
从网上资料得出如下结论：
加载一个类时，其内部类不会同时被加载。一个类被加载，当且仅当其某个静态成员（静态域、构造器、静态方法等）被调用时发生。
一、代码
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:20
6
* @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:20
6
* @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）参考文档