import java.util.concurrent.atomic.AtomicReference;
public class HungrySingleton {
private static HungrySingleton instance = new HungrySingleton();
private HungrySingleton() {
}
public static HungrySingleton getInstance() {
return instance;
}
}
/**
* 餓漢
*/
class HungrySingleton2 {
private static HungrySingleton2 instance;
static {
instance = new HungrySingleton2();
}
private HungrySingleton2() {
}
public static HungrySingleton2 getInstance() {
return instance;
}
}
/**
* lazy-loading
*/
class LazyLoadingSingleton {
private static class SingletonHolder {
private static final LazyLoadingSingleton instance = new LazyLoadingSingleton();
}
private LazyLoadingSingleton() {
}
public static final LazyLoadingSingleton getInstance() {
return SingletonHolder.instance;
}
}
class EnumSingleton {
private EnumSingleton() {
}
public static EnumSingleton getInstance() {
return Singleton.INSTANCE.getInstance();
}
enum Singleton {
INSTANCE;
/**
* 單例
*/
private EnumSingleton singleton;
//JVM會保證此方法絕對只調用一次
private Singleton() {
singleton = new EnumSingleton();
}
public EnumSingleton getInstance() {
return singleton;
}
}
}
class CasSingleton {
private static final AtomicReference<CasSingleton> INSTANCE = new AtomicReference<CasSingleton>();
private CasSingleton() {}
public static final CasSingleton getInstance() {
while (true) {
CasSingleton singleton = INSTANCE.get();
if (singleton != null) {
return singleton;
}
singleton = new CasSingleton();
INSTANCE.compareAndSet(null,singleton){
return singleton;
}
}
}
}
【面試】不使用synchronized和lock，如何實現一個線程安全的單例
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章