单例模式的六种写法

1public class EagerSingleton {
 2    //饿汉单例模式
 3    //在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快
 4    private static EagerSingleton instance = new EagerSingleton();//静态私有成员，已初始化
 5
 6    private EagerSingleton() 
 7    {
 8        //私有构造函数
 9    }
10
11    public static EagerSingleton getInstance()    //静态，不用同步（类加载时已初始化，不会有多线程的问题）
12    {
13        return instance;
14    }
15
16}

 1    //懒汉式单例模式
 2    //比较懒，在类加载时，不创建实例，因此类加载速度快，但运行时获取对象的速度慢
 3    private static LazySingleton intance = null;//静态私用成员，没有初始化
 4
 5    private LazySingleton()
 6    {
 7        //私有构造函数
 8    }
 9
10    public static synchronized LazySingleton getInstance()    //静态，同步，公开访问点
11    {
12        if(intance == null)
13        {
14            intance = new LazySingleton();
15        }
16        return intance;
17    }
18}

 1public class SingletonKerriganD {
 2
 3    /**
 4     * 单例对象实例
 5     */
 6    private volatile static SingletonKerriganD instance = null;//这里加volatitle是为了避免DCL失效
 7
 8    //DCL对instance进行了两次null判断
 9    //第一层判断主要是为了避免不必要的同步
10    //第二层的判断则是为了在null的情况下创建实例。
11    public static SingletonKerriganD getInstance() {
12        if (instance == null) {
13            synchronized (SingletonKerriganD.class) {
14                if (instance == null) {
15                    instance = new SingletonKerriganD();
16
17            }
18        }
19        return instance;
20    }
21}

 1public class Singleton {
 2    private Singleton(){
 3
 4    }
 5    private static class SingletonHolder{
 6        private final static Singleton instance=new Singleton();
 7    }
 8    public static Singleton getInstance(){
 9        return SingletonHolder.instance;
10    }
11}

 1package eft.reflex;
 2
 3public class Singleton {
 4
 5    private int a;
 6
 7    private Singleton(){
 8        a=123;
 9    }
10    private static class SingletonHolder{
11        private final static Singleton instance=new Singleton();
12    }
13    public static Singleton getInstance(){
14        return SingletonHolder.instance;
15    }
16
17    public int getTest(){
18        return a;
19    }
20}

 1    public static void main(String[] args) throws Exception {
 2        //通过反射获取内部类SingletonHolder的instance实例fInstance
 3        Class cInner=Class.forName("eft.reflex.Singleton$SingletonHolder");
 4        Field fInstance=cInner.getDeclaredField("instance");
 5
 6        //将此域的final修饰符去掉
 7        Field modifiersField = Field.class.getDeclaredField("modifiers");
 8        modifiersField.setAccessible(true);
 9        modifiersField.setInt(fInstance, fInstance.getModifiers() & ~Modifier.FINAL);
10
11        //打印单例的某个属性，接下来要通过反射去篡改这个值
12        System.out.println("a="+ Singleton.getInstance().getTest());
13
14        //获取该单例的a属性fieldA
15        fInstance.setAccessible(true);
16        Field fieldA=Singleton.class.getDeclaredField("a");
17
18        //通过反射类构造器创建新的实例newSingleton（这里因为无参构造函数是私有的，不能通过Class.newInstance创建实例）
19        Constructor constructor=Singleton.class.getDeclaredConstructor();
20        constructor.setAccessible(true);
21        Singleton newSingleton= (Singleton) constructor.newInstance();
22
23        //让fInstance指向新的实例newSingleton，此时我们的单例已经被偷梁换柱了！
24        fInstance.set(null,newSingleton);
25        //为盗版的单例的属性a设置新的值
26        fieldA.setAccessible(true);
27        fieldA.set(newSingleton,888);
28
29        //测试是否成功入侵
30        System.out.println("被反射入侵后：a="+ Singleton.getInstance().getTest());
31        fieldA.set(newSingleton,777);
32        System.out.println("被反射入侵后：a="+ Singleton.getInstance().getTest());
33}

1a=123
2被反射入侵后：a=888
3被反射入侵后：a=777

1private Object readResolve() throws ObjectStreamException{
2    return sInstance;
3}

 1class Resource{
 2}
 3
 4public enum SomeThing {
 5    INSTANCE;
 6    private Resource instance;
 7    SomeThing() {
 8        instance = new Resource();
 9    }
10    public Resource getInstance() {
11        return instance;
12    }
13}

1...
2public static final eft.reflex.SomeThing INSTANCE;
3    flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL, ACC_ENUM
4
5...

 1public class SingletonManager { 
 2
 3 private static Map<String,Object> map=new HashMap<String, Object>(); 
 4
 5 private SingletonManager(){}
 6
 7 public static void registerService(String key,Object instance){
 8     if (!map.containsKey(key)){
 9         map.put(key,instance); 
10     } 
11 } 
12
13 public static Object getService(String key){ 
14    return map.get(key); 
15 } 
16
17}

 1final class SystemServiceRegistry {
 2    private static final HashMap<Class<?>, String> SYSTEM_SERVICE_NAMES = new HashMap<Class<?>, String>();
 3    private static final HashMap<String, ServiceFetcher<?>> SYSTEM_SERVICE_FETCHERS = new HashMap<String, ServiceFetcher<?>>();
 4    private SystemServiceRegistry() { }
 5
 6    static {
 7        registerService(Context.LAYOUT_INFLATER_SERVICE, LayoutInflater.class,
 8                new CachedServiceFetcher<LayoutInflater>() {
 9            @Override
10            public LayoutInflater createService(ContextImpl ctx) {
11                return new PhoneLayoutInflater(ctx.getOuterContext());
12            }});
13        registerService(Context.ACTIVITY_SERVICE, ActivityManager.class,
14                new CachedServiceFetcher<ActivityManager>() {
15            @Override
16            public ActivityManager createService(ContextImpl ctx) {
17                return new ActivityManager(ctx.getOuterContext(), ctx.mMainThread.getHandler());
18            }});
19        .......
20    }
21
22    public static Object getSystemService(ContextImpl ctx, String name) {
23        ServiceFetcher<?> fetcher = SYSTEM_SERVICE_FETCHERS.get(name);
24        return fetcher != null ? fetcher.getService(ctx) : null;
25    }
26    private static <T> void registerService(String serviceName, Class<T> serviceClass, ServiceFetcher<T> serviceFetcher) {
27        SYSTEM_SERVICE_NAMES.put(serviceClass, serviceName);
28        SYSTEM_SERVICE_FETCHERS.put(serviceName, serviceFetcher);
29    }
30    ......
31}

1public static WindowManagerGlobal getInstance() {
2    synchronized (WindowManagerGlobal.class) {
3        if (sDefaultWindowManager == null) {
4            sDefaultWindowManager = new WindowManagerGlobal();
5        }
6        return sDefaultWindowManager;
7    }
8}