主要分为两种:
- 直接初始化
- 延迟初始化
直接初始化
直接初始化final静态成员
线程安全:JVM保证final静态成员只会被初始化一次
公有静态成员是个final域,直接引用成员获取单例
/**
* 公有静态成员是个final域
* 直接引用成员获取单例
*/
public class Singleton1 {
public static final Singleton1 INSTANCE = new Singleton1();
/**
* 默认构造方法为private,避免用户用new构造出新对象
*/
private Singleton1() {}
public void someMethod() {}
public static void main(String[] args) {
Singleton1.INSTANCE.someMethod();
}
}
公有的成员是个静态工厂方法,通过该方法获取单例。
提供了灵活性,在不改变API的前提下,可以改变该类是否应该为单例的想法。
比如改成为每个调用该方法的线程返回一个唯一的实例(ThreadLocal<T>
)
/**
* 公有的成员是个静态工厂方法,通过该方法获取单例
*/
public class Singleton2 {
private static final Singleton2 INSTANCE = new Singleton2();
/**
* 默认构造方法为private,避免用户用new构造出新对象
*/
private Singleton2() {}
/**
* 获取单例的静态工厂方法
* @return Singleton2 单例
*/
public static Singleton2 getInstance() { return INSTANCE; }
public void someMethod() {}
public static void main(String[] args) {
Singleton2.getInstance().someMethod();
}
}
包含单个元素的枚举类型(enum)
由枚举类型的性质保证枚举常量INSTANCE
是唯一实例
/**
* 一个包含单个元素的枚举类型
* 枚举类型保证每个枚举常量都是一个单例
*/
public enum EnumSingleton {
INSTANCE;
public void someMethod() { /** .... */}
public static void main(String[] args) {
EnumSingleton.INSTANCE.someMethod();
}
}
延迟初始化
直接在静态工厂方法上加 synchronized
。缺点:每次调用都有线程开销
/**
* 延迟初始化单例
*/
public class LazyInitSingleton1 {
private static LazyInitSingleton1 INSTANCE;
/**
* 默认构造方法为private,避免用户用new构造出新对象
*/
private LazyInitSingleton1() {}
/**
* 获取单例的静态工厂同步方法
* 延迟初始化单例
* 使用同步方法保证多线程操作只实例化一个实力
* @return LazyInitSingleton1 单例
*/
public synchronized static LazyInitSingleton1 getInstance() {
if (INSTANCE == null) {
INSTANCE = new LazyInitSingleton1();
}
return INSTANCE;
}
public void someMethod() {}
public static void main(String[] args) {
Singleton2.getInstance().someMethod();
}
}
lazy initialization holder class 模式。(参考《Effective Java》第71条:慎用延迟初始化
优点:避免同步方法的开销。getInstance
第一次被调用时,读取SingletonHolder.field
,导致SingletonHolder
类得到初始化
/**
* lazy initialization holder class 模式
* 避免同步方法的开销
*/
public class LazyInitSingleton2 {
private static class SingletonHolder {
static final LazyInitSingleton2 field = computeFieldValue();
private static LazyInitSingleton2 computeFieldValue() {
return new LazyInitSingleton2();
}
}
private LazyInitSingleton2() {}
public static LazyInitSingleton2 getInstance() {
return SingletonHolder.field;
}
}
双重检测,降低同步方法开销。(参考《Effective Java》第71条:慎用延迟初始化)
INSTANCE 使用 volatile 修饰符:防止JVM的即时编译器对INSTANCE = new LazyInitSingleton3()
操作进行指令重排序。
/**
* 延迟初始化,双重检测,降低同步方法开销
*/
public class LazyInitSingleton3 {
/**
* 注意:使用了 volatile 修饰符
*/
private static volatile LazyInitSingleton3 INSTANCE;
private LazyInitSingleton3() {}
public static LazyInitSingleton3 getInstance() {
// 第一次判断无需同步,如果 INSTANCE 已经被初始化,
// 就直接返回,没有同步开销
if (INSTANCE == null) {
// 如果判断为空(多线程并发执行 getInstance,导致很多线程判断外层INSTANCE == NULL)
synchronized (LazyInitSingleton3.class) {
// 进入同步后再判断一次,
// 保证只有一个线程赋值给 INSTANCE,
// 后续进来执行的线程都会判断 INSTANCE != NULL,不会再赋值
if (INSTANCE == null) {
INSTANCE = new LazyInitSingleton3();
}
}
}
return INSTANCE;
}
}
为什么INSTANCE要使用volatile
修饰符
在JVM中,new操作做了下面3件事:
- 给要
new
的对象LazyInitSingleton3
分配内存空间 - 调用
LazyInitSingleton3
的构造函数来初始化对象 - 将INSTANCE指向步骤1中分配的内存空间
由于JVM存在指令重排序的优化,上面第2步和第3步顺序是无法保证的(1-2-3或者1-3-2)。
如果执行步骤是1-3-2,那么假设线程A执行到第3步,但第2步还未执行,此时线程B调用getInstance()
发现INSTANCE
非空(但未被初始化),直接返回INSTANCE
,之后线程B对INSTANCE
操作可能会发生错误(由于对象还未被初始化)。 volatile
修饰符防止指令重排序的优化,保证执行顺序是1-2-3。