文章概要
1砰粹、什么是單例
2唧躲、為什么需要單例
3、單例的優(yōu)點(diǎn)和缺點(diǎn)
4碱璃、單例的寫法和比較
5弄痹、序列化破壞單例
6、反射破壞單例
7嵌器、不使用synchronized和lock肛真，如何實(shí)現(xiàn)一個(gè)線程安全的單例？
8爽航、JDK中的單例
9蚓让、引用
1、什么是單例
單例是23中設(shè)計(jì)模式之一讥珍，保證一個(gè)類只有一個(gè)實(shí)例历极，并且對(duì)外提供統(tǒng)一的訪問(wèn)入口。是創(chuàng)建型模式衷佃。
2趟卸、為什么需要單例
我們都知道，類的對(duì)象是由類的構(gòu)造函數(shù)創(chuàng)建的氏义，若構(gòu)造函數(shù)是public的衰腌，則外部可以通過(guò)構(gòu)造函數(shù)隨意創(chuàng)建對(duì)象，若想限制類對(duì)象的創(chuàng)建觅赊，可以將構(gòu)造函數(shù)改為private右蕊，至少也要protected。但是要保證類的可用性吮螺，就需要對(duì)外提供一個(gè)方法用于訪問(wèn)該類饶囚。
3帕翻、單例的優(yōu)點(diǎn)和缺點(diǎn)
優(yōu)點(diǎn)：在內(nèi)存中一個(gè)類只有一個(gè)實(shí)例，避免對(duì)象的不斷創(chuàng)建和銷毀萝风，減少內(nèi)存開(kāi)銷
缺點(diǎn)：在編寫單例代碼時(shí)需要解決線程安全問(wèn)題和序列化問(wèn)題
4嘀掸、單例的寫法和比較
單例的寫法分為餓漢式、懶漢式规惰、靜態(tài)內(nèi)部類睬塌、枚舉、
①餓漢式
public class Singleton {
//實(shí)例化
private static Singleton instance = new Singleton();
//私有化的構(gòu)造函數(shù)
private Singleton(){}
//對(duì)外提供一個(gè)統(tǒng)一獲取實(shí)例的靜態(tài)方法
public static Singleton getInstance(){
return instance;
}
}
線程安全：安全歇万。因?yàn)閕nstance對(duì)象是static修飾的揩晴，在類第一次被加載時(shí)，instance就已經(jīng)被初始化完成贪磺，所以線程安全硫兰。
缺點(diǎn)：類第一次被加載時(shí)就實(shí)例化，若實(shí)例用不到寒锚，會(huì)造成資源的浪費(fèi)劫映。若類被多次加載，會(huì)產(chǎn)生多個(gè)實(shí)例化對(duì)象刹前。
②靜態(tài)內(nèi)部類
public class Singleton {
//私有化的構(gòu)造函數(shù)
private Singleton(){}
//靜態(tài)內(nèi)部類實(shí)例化
private static class SingletonHolder{
private static final Singleton INSTANCE = new Singleton();
}
//對(duì)外提供統(tǒng)一方法
public static Singleton getInstance(){
return SingletonHolder.INSTANCE;
}
}
靜態(tài)內(nèi)部類的方式解決了餓漢式資源浪費(fèi)的問(wèn)題泳赋，當(dāng)Singleton類第一次被加載時(shí)，instance不一定初始化喇喉，只有顯示調(diào)用getInstance()方法時(shí)祖今，才會(huì)裝載SingletonHolder類，進(jìn)而instance被初始化轧飞，這種延遲加載的方式解決了餓漢式浪費(fèi)資源的問(wèn)題。
線程安全：安全撒踪。與餓漢式一樣用static修飾过咬，利用classLoader機(jī)制的線程安全性保證此種單例的線程安全。
③懶漢式
public class Singleton {
private static Singleton instance;
//私有化的構(gòu)造函數(shù)
private Singleton(){}
//對(duì)外提供統(tǒng)一方法
public static Singleton getInstance(){
if (null == instance){
instance = new Singleton();
}
return instance;
}
}
懶漢式是在對(duì)象第一次被使用時(shí)初始化instance制妄。
線程安全：不安全掸绞。若線程A和線程B同時(shí)請(qǐng)求調(diào)用getInstance()方法，當(dāng)A進(jìn)入if判斷耕捞，但是沒(méi)有執(zhí)行new操作時(shí)衔掸，B也進(jìn)行if判斷，此時(shí)inatance為null俺抽，這種情況線程A和線程B會(huì)分別new不同的Singleton對(duì)象敞映。
④懶漢式改進(jìn)版一
public class Singleton {
private static Singleton instance;
//私有化的構(gòu)造函數(shù)
private Singleton(){}
//對(duì)外提供統(tǒng)一方法
public static synchronized Singleton getInstance(){
if (null == instance){
instance = new Singleton();
}
return instance;
}
}
為了解決懶漢式的線程安全問(wèn)題，用synchronized修飾方法磷斧。
線程安全：安全振愿。
缺點(diǎn)：由于getInstance方法被整個(gè)鎖住捷犹，所以多線程環(huán)境下，此方法是串行執(zhí)行的冕末，執(zhí)行效率低萍歉。
⑤懶漢式改進(jìn)版二
public class DoubleCheckLazySingleton {
private static DoubleCheckLazySingleton instance;
private DoubleCheckLazySingleton(){};
public static DoubleCheckLazySingleton getInstance(){
if (instance == null){
synchronized (DoubleCheckLazySingleton.class){
if (instance == null){
instance = new DoubleCheckLazySingleton();
}
}
}
return instance;
}
}
雙重校驗(yàn)鎖懶漢式單例，將synchronized鎖范圍縮小至初始化代碼档桃，從而提高執(zhí)行效率枪孩，采用兩次空值判斷。
線程安全：不安全藻肄。
缺點(diǎn)：JVM可以執(zhí)行重排序蔑舞，指令的執(zhí)行順序：（1）分配內(nèi)存給instance對(duì)象。（2）初始化instance對(duì)象仅炊。（3）設(shè)置instance對(duì)象指向分配內(nèi)存地址斗幼。正常我們認(rèn)為的執(zhí)行順序是（1）（2）（3），由于指令重排序機(jī)制抚垄，最后執(zhí)行的順序可能是（1）（3）（2）蜕窿，此時(shí)線程A執(zhí)行（3），但沒(méi)有執(zhí)行（2）呆馁，線程B進(jìn)來(lái)之后判斷instance對(duì)象非空（正在執(zhí)行（2）或者未執(zhí)行（2））桐经，程序會(huì)產(chǎn)生錯(cuò)誤。
那么如何解決上面的問(wèn)題呢浙滤？volatile解決線程間的可見(jiàn)性和指令重排序問(wèn)題阴挣。
public class DoubleCheckLazySingleton {
private volatile static DoubleCheckLazySingleton instance;
private DoubleCheckLazySingleton(){};
public static DoubleCheckLazySingleton getInstance(){
if (instance == null){
synchronized (DoubleCheckLazySingleton.class){
if (instance == null){
instance = new DoubleCheckLazySingleton();
}
}
}
return instance;
}
}
將instance變量用volatile修飾之后可解決以上問(wèn)題。
但是它只是看上去完美無(wú)缺纺腊，其實(shí)還是有問(wèn)題的畔咧。
缺點(diǎn)：序列化問(wèn)題（后續(xù)展開(kāi)說(shuō)明）
⑥枚舉單例
public enum EnumSingleton {
INSTANCE;
private EnumSingleton(){};
public static EnumSingleton getInstance(){
return INSTANCE;
}
}
這種方式是Effective Java作者Josh Bloch 提倡的方式。枚舉類型單例揖膜，即解決了線程安全問(wèn)題誓沸，有解決了序列化問(wèn)題。
優(yōu)點(diǎn)：
線程安全
枚舉在底層做了線程安全的操作壹粟。
public final class EnumSingleton extends Enum
{
public static EnumSingleton[] values()
{
return (EnumSingleton[])$VALUES.clone();
}
public static EnumSingleton valueOf(String name)
{
return (EnumSingleton)Enum.valueOf(com/xxx/EnumSingleton, name);
}
private EnumSingleton(String s, int i)
{
super(s, i);
}
public static EnumSingleton getInstance()
{
return INSTANCE;
}
public static final EnumSingleton INSTANCE;
private static final EnumSingleton $VALUES[];
static
{
INSTANCE = new EnumSingleton("INSTANCE", 0);
$VALUES = (new EnumSingleton[] {
INSTANCE
});
}
}
以上代碼是枚舉類反編譯之后的代碼拜隧，我們發(fā)現(xiàn)變成了繼承Enum類的final class類，變量instance用static修飾趁仙，instance的初始化在static塊中洪添，其實(shí)就是上面我們講到的餓漢式單例。所以是線程安全的雀费。
5干奢、序列化破壞單例：
其他的單例模式都會(huì)有序列化問(wèn)題，我們來(lái)以雙重校驗(yàn)鎖單例對(duì)象的序列化和反序列化做個(gè)測(cè)試：
public class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testFile"));
//寫入雙重校驗(yàn)鎖單例對(duì)象
DoubleCheckLazySingleton s1 = DoubleCheckLazySingleton.getInstance();
oos.writeObject(s1);
oos.flush();
oos.close();
//反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testFile"));
DoubleCheckLazySingleton s2 = (DoubleCheckLazySingleton) ois.readObject();
ois.close();
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println("s1==s2:"+ (s1==s2));
}
}
輸出結(jié)果：
s1:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s2:com.zhangjq.DoubleCheckLazySingleton@6d03e736
s1==s2:false
從結(jié)果可以看出序列化和反序列化不是同一個(gè)對(duì)象盏袄，那么是什么原因造成的呢律胀？我們來(lái)看源碼分析：
ObjectInputStream.readObject()
public final Object readObject()
throws IOException, ClassNotFoundException
{
if (enableOverride) {
return readObjectOverride();
}
// if nested read, passHandle contains handle of enclosing object
int outerHandle = passHandle;
try {
Object obj = readObject0(false);
handles.markDependency(outerHandle, passHandle);
ClassNotFoundException ex = handles.lookupException(passHandle);
if (ex != null) {
throw ex;
}
if (depth == 0) {
vlist.doCallbacks();
}
return obj;
} finally {
passHandle = outerHandle;
if (closed && depth == 0) {
clear();
}
}
}
在這里調(diào)用了readObject0(),在這個(gè)方法中可以看到
private Object readObject0(boolean unshared) throws IOException {
...
case TC_OBJECT:
return checkResolve(readOrdinaryObject(unshared));
...
}
我們繼續(xù)進(jìn)入readOrdinaryObject方法
private Object readOrdinaryObject(boolean unshared)
throws IOException
{
if (bin.readByte() != TC_OBJECT) {
throw new InternalError();
}
ObjectStreamClass desc = readClassDesc(false);
desc.checkDeserialize();
Class<?> cl = desc.forClass();
if (cl == String.class || cl == Class.class
|| cl == ObjectStreamClass.class) {
throw new InvalidClassException("invalid class descriptor");
}
Object obj;
try {
obj = desc.isInstantiable() ? desc.newInstance() : null;
} catch (Exception ex) {
throw (IOException) new InvalidClassException(
desc.forClass().getName(),
"unable to create instance").initCause(ex);
}
·········
return obj;
}
可以看到這樣一段代碼obj = desc.isInstantiable() ? desc.newInstance() : null;
進(jìn)入isInstantiable方法宋光，發(fā)現(xiàn)就是一個(gè)判斷是否存在無(wú)參構(gòu)造函數(shù)的語(yǔ)句
/** serialization-appropriate constructor, or null if none */
private Constructor<?> cons;
·········
/**
* Returns true if represented class is serializable/externalizable and can
* be instantiated by the serialization runtime--i.e., if it is
* externalizable and defines a public no-arg constructor, or if it is
* non-externalizable and its first non-serializable superclass defines an
* accessible no-arg constructor. Otherwise, returns false.
*/
boolean isInstantiable() {
requireInitialized();
return (cons != null);
}
綜合以上所述：我們發(fā)現(xiàn)只要序列化的類存在無(wú)參構(gòu)造函數(shù)就調(diào)用desc.newInstance()，構(gòu)造一個(gè)新的對(duì)象返回炭菌。
解決方案：
只需要在序列化的類中添加readResolve()方法即可解決序列化問(wèn)題
public class DoubleCheckLazySingleton implements Serializable{
private volatile static DoubleCheckLazySingleton instance;
private DoubleCheckLazySingleton(){};
public static DoubleCheckLazySingleton getInstance(){
if (instance == null){
synchronized (DoubleCheckLazySingleton.class){
if (instance == null){
instance = new DoubleCheckLazySingleton();
}
}
}
return instance;
}
private Object readResolve(){
return instance;
}
}
再次運(yùn)行序列化和反序列化操作罪佳，結(jié)果如下：
s1:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s2:com.zhangjq.DoubleCheckLazySingleton@14ae5a5
s1==s2:true
為什么添加readResolve()方法就可以解決序列化問(wèn)題呢？我們來(lái)看源碼：
在readOrdinaryObject()方法中黑低，判斷是否存在無(wú)參構(gòu)造函數(shù)之后赘艳，又判斷了是否存在readResolve()的方法
if (obj != null &&
handles.lookupException(passHandle) == null &&
desc.hasReadResolveMethod())
{
Object rep = desc.invokeReadResolve(obj);
if (unshared && rep.getClass().isArray()) {
rep = cloneArray(rep);
}
if (rep != obj) {
// Filter the replacement object
if (rep != null) {
if (rep.getClass().isArray()) {
filterCheck(rep.getClass(), Array.getLength(rep));
} else {
filterCheck(rep.getClass(), -1);
}
}
handles.setObject(passHandle, obj = rep);
}
}
hasReadResolveMethod:
/**
* Returns true if represented class is serializable or externalizable and
* defines a conformant readResolve method. Otherwise, returns false.
*/
boolean hasReadResolveMethod() {
requireInitialized();
return (readResolveMethod != null);
}
若存在則執(zhí)行hasReadResolveMethod方法，結(jié)果覆蓋上面new 出來(lái)的對(duì)象克握，返回蕾管。
那么readResolveMethod 是在哪里賦值的呢？通過(guò)全局查找找到了賦值代碼在私有方法
ObjectStreamClass()方法中給 readResolveMethod 進(jìn)行賦值菩暗，來(lái)看代碼：
readResolveMethod = getInheritableMethod(cl, "readResolve", null, Object.class);
在 invokeReadResolve()方法中用反射調(diào)用了 readResolveMethod 方法掰曾。
通過(guò) JDK 源碼分析我們可以看出，雖然停团，增加 readResolve()方法返回實(shí)例旷坦，解決了單
例被破壞的問(wèn)題。但是佑稠，我們通過(guò)分析源碼以及調(diào)試秒梅，我們可以看到實(shí)際上實(shí)例化了兩
次，只不過(guò)新創(chuàng)建的對(duì)象沒(méi)有被返回而已舌胶。那如果捆蜀，創(chuàng)建對(duì)象的動(dòng)作發(fā)生頻率增大，就
意味著內(nèi)存分配開(kāi)銷也就隨之增大幔嫂。
枚舉單例序列化
對(duì)上述測(cè)試代碼做修改
public class SerializableTest {
public static void main(String[] args) throws IOException, ClassNotFoundException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("testFile"));
//寫入雙重校驗(yàn)鎖單例對(duì)象
// DoubleCheckLazySingleton s1 = DoubleCheckLazySingleton.getInstance();
EnumSingleton s1 = EnumSingleton.getInstance();
oos.writeObject(s1);
oos.flush();
oos.close();
//反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("testFile"));
// DoubleCheckLazySingleton s2 = (DoubleCheckLazySingleton) ois.readObject();
EnumSingleton s2 = (EnumSingleton) ois.readObject();
ois.close();
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println("s1==s2:"+ (s1==s2));
}
}
運(yùn)行結(jié)果：
s1:INSTANCE
s2:INSTANCE
s1==s2:true
沒(méi)什么任何附加的操作辆它，就可以保證序列化問(wèn)題，我們來(lái)看源碼分析：
繼續(xù)分析ObjectInputStream.readObject()履恩，在readObject0方法中
case TC_ENUM:
return checkResolve(readEnum(unshared));
我們看到在 readObject0()中調(diào)用了 readEnum()方法锰茉，來(lái)看 readEnum()中代碼實(shí)現(xiàn)：
private Enum<?> readEnum(boolean unshared) throws IOException {
if (bin.readByte() != TC_ENUM) {
throw new InternalError();
}
ObjectStreamClass desc = readClassDesc(false);
if (!desc.isEnum()) {
throw new InvalidClassException("non-enum class: " + desc);
}
int enumHandle = handles.assign(unshared ? unsharedMarker : null);
ClassNotFoundException resolveEx = desc.getResolveException();
if (resolveEx != null) {
handles.markException(enumHandle, resolveEx);
}
String name = readString(false);
Enum<?> result = null;
Class<?> cl = desc.forClass();
if (cl != null) {
try {
@SuppressWarnings("unchecked")
Enum<?> en = Enum.valueOf((Class)cl, name);
result = en;
} catch (IllegalArgumentException ex) {
throw (IOException) new InvalidObjectException(
"enum constant " + name + " does not exist in " +
cl).initCause(ex);
}
if (!unshared) {
handles.setObject(enumHandle, result);
}
}
handles.finish(enumHandle);
passHandle = enumHandle;
return result;
}
可以看出枚舉對(duì)象反序列化時(shí)是通過(guò)Enum.valueOf()方法根據(jù)名字查找枚舉對(duì)象 。不存在new新對(duì)象的情況似袁，所以枚舉單例的反序列化問(wèn)題是安全的洞辣。
6咐刨、反射破壞單例
在上述所有的單例模式中昙衅，構(gòu)造方法都是private權(quán)限的，很多人以為只要設(shè)置成private就是安全的了定鸟，其實(shí)不然而涉，利用反射機(jī)制可以強(qiáng)制訪問(wèn)private的構(gòu)造方法來(lái)創(chuàng)建對(duì)象。我們來(lái)看一個(gè)例子：
public class ReflectSingletonTest {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
//以雙重校驗(yàn)鎖單例為例
Class<?> clazz = DoubleCheckLazySingleton.class;
Constructor<?> declaredConstructor = clazz.getDeclaredConstructor();
//設(shè)置強(qiáng)制訪問(wèn)
declaredConstructor.setAccessible(true);
//初始化
Object o1 = declaredConstructor.newInstance();
Object o2 = declaredConstructor.newInstance();
System.out.println("o1:"+o1);
System.out.println("o2:"+o2);
System.out.println("o1==o2:"+ (o1==o2));
}
}
運(yùn)行結(jié)果：
o1:com.zhangjq.DoubleCheckLazySingleton@1b6d3586
o2:com.zhangjq.DoubleCheckLazySingleton@4554617c
o1==o2:false
解決方案:
針對(duì)這種情況联予，我們可以在構(gòu)造函數(shù)里面加一些判斷啼县，來(lái)解決反射破壞單例的問(wèn)題：
public class DoubleCheckLazySingleton implements Serializable{
private volatile static DoubleCheckLazySingleton instance;
private volatile static boolean initialized = false;
private DoubleCheckLazySingleton(){
if(!initialized){
initialized = !initialized;
}else{
throw new RuntimeException("不允許重復(fù)創(chuàng)建DoubleCheckLazySingleton對(duì)象材原！");
}
}
public static DoubleCheckLazySingleton getInstance(){
if (instance == null){
synchronized (DoubleCheckLazySingleton.class){
if (instance == null){
instance = new DoubleCheckLazySingleton();
}
}
}
return instance;
}
private Object readResolve(){
return instance;
}
}
再次運(yùn)行結(jié)果如下：
java.lang.reflect.InvocationTargetException
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:25)
Caused by: java.lang.RuntimeException: 不允許創(chuàng)建多個(gè)實(shí)例
at com.zhangjq.LazyDoubleCheckSingleton.<init>(LazyDoubleCheckSingleton.java:13)
... 5 more
枚舉單例反射問(wèn)題
那么枚舉類型的單例是否存在反射問(wèn)題呢？
public class ReflectSingletonTest {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
//以雙重校驗(yàn)鎖單例為例
Class<?> clazz = EnumSingleton.class;
Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(null);
//設(shè)置強(qiáng)制訪問(wèn)
declaredConstructor.setAccessible(true);
//初始化
Object o1 = declaredConstructor.newInstance();
Object o2 = declaredConstructor.newInstance();
System.out.println("o1:"+o1);
System.out.println("o2:"+o2);
System.out.println("o1==o2:"+ (o1==o2));
}
}
輸出結(jié)果：
Exception in thread "main" java.lang.NoSuchMethodException: com.zhangjq.EnumSingleton.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.getDeclaredConstructor(Class.java:2178)
at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:13)
異常的意思是沒(méi)有找到EnumSingleton無(wú)參的構(gòu)造函數(shù)季眷。
查看Enum類的源碼發(fā)現(xiàn)只有一個(gè)帶參數(shù)的構(gòu)造函數(shù)
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
我們將代碼修改一下余蟹，再次運(yùn)行：
public class ReflectSingletonTest {
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
//以雙重校驗(yàn)鎖單例為例
Class<?> clazz = EnumSingleton.class;
Constructor<?> declaredConstructor = clazz.getDeclaredConstructor(String.class,int.class);
//設(shè)置強(qiáng)制訪問(wèn)
declaredConstructor.setAccessible(true);
//初始化
Object o1 = declaredConstructor.newInstance("zhang",10);
Object o2 = declaredConstructor.newInstance("wang",11);
System.out.println("o1:"+o1);
System.out.println("o2:"+o2);
System.out.println("o1==o2:"+ (o1==o2));
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at com.zhangjq.ReflectSingletonTest.main(ReflectSingletonTest.java:19)
報(bào)錯(cuò)信息很明顯：不能用反射創(chuàng)建枚舉類對(duì)象。
我們查看newInstance()方法的源碼
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
if (!override) {
if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, null, modifiers);
}
}
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {
ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
可以看出當(dāng)修飾符是枚舉類型時(shí)子刮，拋出異常威酒，也就是說(shuō)jdk控制反射不能創(chuàng)建枚舉類對(duì)象。所以枚舉類的反射破壞問(wèn)題是不存在的挺峡。
7葵孤、不使用synchronized和lock，如何實(shí)現(xiàn)一個(gè)線程安全的單例橱赠？
以上我們講的所有單例的線程安全都顯示或者隱示的用到了ClassLoader的線程安全機(jī)制尤仍。
餓漢式：用static修飾，類第一次被加載時(shí)實(shí)例化狭姨，ClassLoader的類加載是synchronized修飾的宰啦。
懶漢式：顯示的用synchronized修改。
枚舉：編譯器編譯之后枚舉中的所有變量都用static final 修飾送挑，并且是初始化在static塊中
那么如果我們不用synchronized和lock绑莺，如何實(shí)現(xiàn)一個(gè)線程安全的單例呢？
答案是：CAS
CAS是項(xiàng)樂(lè)觀鎖技術(shù)惕耕，當(dāng)多個(gè)線程嘗試使用CAS同時(shí)更新同一個(gè)變量時(shí)纺裁，只有其中一個(gè)線程能更新變量的值，而其它線程都失敗司澎，失敗的線程并不會(huì)被掛起欺缘，而是被告知這次競(jìng)爭(zhēng)中失敗，并可以再次嘗試挤安。
實(shí)現(xiàn)單例代碼：
public class Singleton {
private static final AtomicReference<Singleton> INSTANCE = new AtomicReference<Singleton>();
private Singleton() {}
public static Singleton getInstance() {
for (;;) {
Singleton singleton = INSTANCE.get();
if (null != singleton) {
return singleton;
}
singleton = new Singleton();
if (INSTANCE.compareAndSet(null, singleton)) {
return singleton;
}
}
}
}
優(yōu)點(diǎn)：CAS依賴底層硬件的實(shí)現(xiàn)谚殊，沒(méi)有線程之間切換和阻塞問(wèn)題。
缺點(diǎn)：可能一直處于等待中蛤铜，不斷的循環(huán)嫩絮，對(duì)CPU造成資源開(kāi)銷。
8围肥、JDK中的單例
java.lang.Runtime
Runtime類封裝了Java運(yùn)行時(shí)的環(huán)境剿干。每一個(gè)java程序?qū)嶋H上都是啟動(dòng)了一個(gè)JVM進(jìn)程，那么每個(gè)JVM進(jìn)程都是對(duì)應(yīng)這一個(gè)Runtime實(shí)例穆刻，此實(shí)例是由JVM為其實(shí)例化的置尔。每個(gè) Java 應(yīng)用程序都有一個(gè) Runtime 類實(shí)例，使應(yīng)用程序能夠與其運(yùn)行的環(huán)境相連接氢伟。
由于Java是單進(jìn)程的榜轿，所以幽歼，在一個(gè)JVM中，Runtime的實(shí)例應(yīng)該只有一個(gè)谬盐。所以應(yīng)該使用單例來(lái)實(shí)現(xiàn)甸私。
public class Runtime {
private static Runtime currentRuntime = new Runtime();
public static Runtime getRuntime() {
return currentRuntime;
}
private Runtime() {}
}
以上代碼為JDK中Runtime類的部分實(shí)現(xiàn)，可以看到飞傀，這其實(shí)是餓漢式單例模式颠蕴。在該類第一次被classloader加載的時(shí)候，這個(gè)實(shí)例就被創(chuàng)建出來(lái)了助析。
一般不能實(shí)例化一個(gè)Runtime對(duì)象犀被，應(yīng)用程序也不能創(chuàng)建自己的 Runtime 類實(shí)例，但可以通過(guò) getRuntime 方法獲取當(dāng)前Runtime運(yùn)行時(shí)對(duì)象的引用外冀。
9寡键、引用
參考：
單例與序列化的那些事兒
設(shè)計(jì)模式（二）——單例模式
不使用synchronized和lock，如何實(shí)現(xiàn)一個(gè)線程安全的單例雪隧？
JDK中的那些單例
