第一种：
1
2
3
4
5
6
7
8
9
10
11
12
13
| public class SyncSingleton01 {
private static SyncSingleton01 singleton01 = new SyncSingleton01();
private SyncSingleton01() {
}
public static SyncSingleton01 getInstance() {
return singleton01;
}
}
|
这种方式虽然可以实现线程安全的单例模式，但是如果一个系统中这样的类存在较多的话，会拖慢系统启动的速度，所以，一般会使用延迟加载，在第一次使用的时候才初始化。
第二种：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| public class SyncSingleton02 {
private static SyncSingleton02 singleton02 = null;
private SyncSingleton02() {
}
public static synchronized SyncSingleton02 getInstance() {
if (null == singleton02) {
singleton02 = new SyncSingleton02();
}
return singleton02;
}
}
|
这种方法锁的粒度比较大，而且在后面的每次获取这个对象的时候，都要进行上锁，效率自然也会是比较低的。
第三种：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| public class SyncSingleton03 {
private static SyncSingleton03 singleton03 = null;
private SyncSingleton03() {
}
public static SyncSingleton03 getInstance() {
if (null == singleton03) {
synchronized (SyncSingleton03.class) {
if (null == singleton03) {
singleton03 = new SyncSingleton03();
}
}
}
return singleton03;
}
}
|
这种方法采用了双重锁机制对第二种做了修改，减小了锁的粒度，在第一次调用之后，在获取对象的时候不需要再进行上锁。
第四种：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| public class SyncSingleton04 {
private SyncSingleton04() {
}
private static class Inner{
private static SyncSingleton04 singleton04 = new SyncSingleton04();
}
public static SyncSingleton04 getInstance() {
return Inner.singleton04;
}
}
|
这种方式采用了无锁内部类的形式，也实现了懒加载，是较为优秀的实现方式。