0%

单例模式

单例模式

确保某个类只有一个实例

饿汉模式

线程安全

1
2
3
4
5
6
7
8
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singleton getInstance() {
return instance;
}
}

懒汉模式

非线程安全的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
private static Singleton instance = null;

private Singleton(){

}

public static Singleton newInstance(){
// 在需要的时候进行创建,如果已存在,直接返回之前的对象
if(instance == null){
instance = new Singleton();
System.out.println("创建单例实例");
}
return instance;
}
}

线程安全加同步锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class SyncSingleton {
private static SyncSingleton instance = null;

private SyncSingleton(){

}

// 使用synchronized对方法进行加锁
public static synchronized SyncSingleton newInstance(){
// 在需要的时候进行创建,如果已存在,直接返回之前的对象
if(instance == null){
instance = new SyncSingleton();
System.out.println("创建实例");
}
return instance;
}
}

双重检查减少锁粒度

这种方式可能导致获取到未初始化完全的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class TwiceCheckSingleton {
private static TwiceCheckSingleton instance = null;

private TwiceCheckSingleton(){

}

public static TwiceCheckSingleton newInstance(){
// 在需要的时候进行创建,如果已存在,直接返回之前的对象
if(instance == null){
synchronized(TwiceCheckSingleton.class){
if(instance == null){
instance = new TwiceCheckSingleton();
System.out.println("创建单例实例1");
}
System.out.println("创建单例实例2");
}
}
return instance;
}
}
使用valotile进行优化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class VolatileSingleton {
// volatile保证原子性
private static volatile VolatileSingleton instance = null;

private VolatileSingleton() {

}

public static VolatileSingleton newInstance() {
// 在需要的时候进行创建,如果已存在,直接返回之前的对象
if (instance == null) {
synchronized (VolatileSingleton.class) {
if (instance == null) {
instance = new VolatileSingleton();
System.out.println("创建单例实例1");
}
System.out.println("创建单例实例2");
}
}
return instance;
}
}

使用静态内部类

通过类加载机制保证只创建一个单例对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class StaticOutterClassSingleton {
// 私有静态内部类,该静态内部类只会在newInstance()中使用
private static class SingletonHolder{
public static StaticOutterClassSingleton instance = new StaticOutterClassSingleton();
}

private StaticOutterClassSingleton(){

}

public static StaticOutterClassSingleton newInstance(){
return SingletonHolder.instance;
}
}

优点

  • 在内存只有一个对象实例,节省内存
  • 避免频繁创建销毁对象
  • 便面对共享资源的多重占用
  • 可以全局访问

使用场景

  • 需要频繁实例化后销毁的对象
  • 创建一个对象需要消耗的资源过多
  • 工具类