Java单例模式
java单例模式是为了让全局只实例化一个对象,常用的方式包括懒汉模式、饿汉模式,考虑到线程安全,又分线程安全和线程不安全。单利的特性决定了其没有public的构造函数,懒汉/饿汉模式取决于实例化的时机,安全/非安全取决于是否支持多线程并发调用,根据这些特点,今天记录一下我所知道的10种实现单例模式的写法。
创建方法汇总
1、普通饿汉模式(安全)
/**
* 单例模式
*/
public class SingleTest {
private static final SingleTest singleTest = new SingleTest();
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return singleTest;
}
}
点评:私有构造函数、静态final对象,调用该类一上来就实例化,所以是饿汉、线程安全。
2、普通饿汉模式变形(线程安全)
/**
* 单例模式
*/
public class SingleTest {
private static final SingleTest singleTest;
static {
singleTest = new SingleTest();
}
private SingleTest() { }
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return singleTest;
}
}
点评:利用静态代码块,完成对于singleTest的实例化,原理和方法1一样,饿汉、安全。
3、枚举类型单例模式(饿汉、安全)
/**
* 单例模式
*/
public enum SingleTest {
INSTANCE;
public void methodXXX(){
}
}
点评:利用枚举的特性,保证只有一个对象,且线程安全,所以是饿汉、安全
4、普通懒汉模式(不安全)
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() { }
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
singleTest = new SingleTest();
}
return singleTest;
}
}
点评:在使用的时候判断是否实例化,没有则先实例化,多线程切换时,可能会重复创建,所以懒汉、不安全。
5、安全的懒汉模式(安全)
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public synchronized static SingleTest getSingleTest() {
if (singleTest == null) {
singleTest = new SingleTest();
}
return singleTest;
}
}
点评:无它,加了一个同步操作,保证安全,所以是懒汉、安全。但都知道synchronized性能低。
6、双重校验的懒汉模式(安全,非绝对)
/**
* 单例模式
*/
public class SingleTest {
private static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
synchronized(SingleTest.class){
if(singleTest == null){
singleTest = new SingleTest();
}
}
}
return singleTest;
}
}
点评:双重校验,优化了性能,但是由于可见性以及线程内存和主存的关系,所以是懒汉、非绝对安全。
7、升级版双重校验懒汉模式(安全)
/**
* 单例模式
*/
public class SingleTest {
//添加volatile,防止重排并保证可见性。
private volatile static SingleTest singleTest;
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
if (singleTest == null) {
synchronized(SingleTest.class){
if(singleTest == null){
singleTest = new SingleTest();
}
}
}
return singleTest;
}
}
点评:添加volatile关键词,防止重排,保证可见性,所以是懒汉、安全。
8、静态内部类,实现懒加载(安全)
/**
* 单例模式
*/
public class SingleTest {
private static class SingleGet {
private static final SingleTest singleTest = new SingleTest();
}
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return SingleGet.singleTest;
}
}
点评:利用静态内部类的加载特性,实现懒加载,保证线程安全,所以是懒汉、安全。
9、CAS自旋实现(懒汉、安全)
/**
* 单例模式
*/
public class SingleTest {
/**
* 利用AtomicReference,保证操作的
*/
private static final AtomicReference<SingleTest> INSTANCE = new AtomicReference<SingleTest>();
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
for (; ; ) {
SingleTest current = INSTANCE.get();
if (current != null) {
return current;
}
current = new SingleTest();
if (INSTANCE.compareAndSet(null, current)) {
return current;
}
}
}
}
点评:通过CAS自旋实现安全,所以是懒汉、安全。
10、仿android.util下的Singleton,获取单例对象(懒汉、安全)
Singleton.java
public abstract class Singleton<T> {
private T mInstance;
protected abstract T create();
public final T get() {
synchronized (this) {
if (mInstance == null) {
mInstance = create();
}
return mInstance;
}
}
}
单例实现
/**
* 单例模式
*/
public class SingleTest {
private static final Singleton<SingleTest> SINGLETON = new Singleton() {
@Override
protected Object create() {
return new SingleTest();
}
};
private SingleTest() {
}
/**
* 获取单例模式
*
* @return
*/
public static SingleTest getSingleTest() {
return SINGLETON.get();
}
}
点评:利用Singleton这个对象的特性,创建的是一个安全(synchronized)、唯一的对象。
11、其他
综合考虑,只要实现该对象在进程中理论上只创建一次,那么就对得起单例模式这个名字,不同的线程获取到的都是同一个对象,那么就是安全的,在获取时实例化,那么就是懒汉模式。可以看到上面的各种方法,都是在这三点上使用不同的技术方案来完成而已。
知识点汇总
synchronized可以保证安全,但会阻塞线程,消耗性能,所以要最小化的使用同步,来保证安全。
每个线程有自己的缓存,虚拟机有主存,数据存在主存上,各个线程拿一份到自己的缓存中操作,然后在刷新到主存,这样保证效率,但是也造成了线程安全问题。
volatile保证原子操作可见性(读的操作从主存取,写的操作立即刷新到主存),防止CPU指令重排(内存屏障)
静态代码块比构造方法先执行,只执行一次,代码块每次实例化对象都会被执行。
如果单例类被标记为可序列化,需要重写readResolve方法来确保在readObject时不创建新的对象。
枚举可以防止序列化。
ThreadLocal实现的是每一个线程一个对象,多个线程会有多个对象,所以我认为不是单例模式。
枚举模式最简洁,饿汉模式也很简洁,双重校验用的挺多,看各位写代码喜好吧。