彻底玩转单例模式

饿汉式 

// 饿汉式单例
 public class Hungry { 

// 可能会浪费空间
 private byte[] data1 = new byte[1024*1024];
 private byte[] data2 = new byte[1024*1024];
 private byte[] data3 = new byte[1024*1024]; 
 private byte[] data4 = new byte[1024*1024]; 

private Hungry(){ }

private final static Hungry HUNGRY = new Hungry(); 

public static Hungry getInstance()
{ 
return HUNGRY; 
} 

}

 

DCL 懒汉式（反射破坏单例）

import java.lang.reflect.Constructor;

 import java.lang.reflect.Field; 

// 懒汉式单例 // 道高一尺，魔高一丈！
 public class LazyMan { 
private static boolean qinjiang = false;

 private LazyMan()
{ 
synchronized (LazyMan.class){ 
if (qinjiang == false)
{ qinjiang = true; }
else { throw new RuntimeException("不要试图使用反射破坏异常"); }

} }
private volatile static LazyMan lazyMan;
 // 双重检测锁模式的 懒汉式单例 DCL懒汉式 
public static LazyMan getInstance(){ 
if (lazyMan==null){ 
synchronized (LazyMan.class)
{ if (lazyMan==null)
{ lazyMan = new LazyMan();
 // 不是一个原子性操作 
} 
} 
}return lazyMan; 
}
// 反射！
 public static void main(String[] args) throws Exception { 
// LazyMan instance = LazyMan.getInstance(); 
Field qinjiang = LazyMan.class.getDeclaredField("qinjiang"); 

qinjiang.setAccessible(true);
 Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null); declaredConstructor.setAccessible(true); 
LazyMan instance = declaredConstructor.newInstance();
 qinjiang.set(instance,false); 
LazyMan instance2 = declaredConstructor.newInstance();
 System.out.println(instance); 
System.out.println(instance2); } }
/*** 1. 分配内存空间
 * 2、执行构造方法，初始化对象 
* 3、把这个对象指向这个空间 
** 123
 * 132 A * B 
// 此时lazyMan还没有完成构造 
*/

静态内部类

// 静态内部类
 public class Holder 
{ private Holder()
{
}

public static Holder getInstace()
{ 
return InnerClass.HOLDER;
 }
public static class InnerClass
{ 
private static final Holder HOLDER = new Holder();
 } 
}

 

枚举

import java.lang.reflect.Constructor; 
import java.lang.reflect.InvocationTargetException;
 // enum 是一个什么？ 本身也是一个Class类
 public enum EnumSingle
 { 
INSTANCE;
 public EnumSingle getInstance()
{ return INSTANCE; 
} 
}

class Test{
 public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
 EnumSingle instance1 = EnumSingle.INSTANCE;
 Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class); declaredConstructor.setAccessible(true); 
EnumSingle instance2 = declaredConstructor.newInstance(); 
// NoSuchMethodException: com.kuang.single.EnumSingle.<init>() System.out.println(instance1); 
System.out.println(instance2); 
} 
}

 

枚举类型的最终反编译源码：

public final class EnumSingle extends Enum
 { public static EnumSingle[] values()

 { return (EnumSingle[])$VALUES.clone();

 }
public static EnumSingle valueOf(String name)

 { return (EnumSingle)Enum.valueOf(com/kuang/single/EnumSingle, name);
 }
private EnumSingle(String s, int i)
 { 
super(s, i); 
}
public EnumSingle getInstance() {

 return INSTANCE; }public static final EnumSingle INSTANCE;

 private static final EnumSingle $VALUES[]; 

static{ INSTANCE = new EnumSingle("INSTANCE", 0);

 $VALUES = (new EnumSingle[] { INSTANCE }); 

} 
}