Java 单例总结

1：懒汉式，不保证线程安全

package com.yan.singleton;



public class LazySingleton {



    private static final LazySingleton instance = null;

    

    private LazySingleton(){}

    

    public static LazySingleton getLazySingleton(){

        if(null==instance){

            return new LazySingleton();

        }

        

        return instance;

    }

}

2：饿汉式，线程安全

package com.yan.singleton;



public class HungrySingleton {

    private HungrySingleton(){}

    

    private static final HungrySingleton instance = new HungrySingleton();

    

    public static HungrySingleton getInstance(){

        return instance;

    }

}

3：静态内部类，线程安全

package com.yan.singleton;



public class InnerClassSingleton {

    

    private InnerClassSingleton(){}

    

    public static final InnerClassSingleton getInstance(){

        return InnerClassSingletonHolder.INSTANCE;

    }

    

    private static class InnerClassSingletonHolder{

        private static final InnerClassSingleton INSTANCE = new InnerClassSingleton();

    }

}

4：枚举，线程安全，可以反序列化（推荐此种方式）JDK1.5之后才可以使用

package com.yan.singleton;



public enum EnumSingleton {



    INSTANCE;

    

    public void todo(){

        System.out.println("todo");

    }

}

 

方式1,2,3都可以使用反射机制来破坏其单例特性，采用枚举类型可以避免反射的破坏。

例如：

package com.yan.test;



import com.yan.singleton.LazySingleton;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.util.logging.Level;

import java.util.logging.Logger;



public class Test {

    

    public static void main(String[] args) {

        

        Constructor<LazySingleton>cs ;

        

        try {

            cs = (Constructor<LazySingleton>)

                    Class.forName("com.yan.singleton.LazySingleton")

                            .getDeclaredConstructor();

            

            cs.setAccessible(true);//得到私有访问权限，如果不设置，则无法实例化对象

                

            LazySingleton ls = cs.newInstance();

            

            System.out.println("===ls:"+ls);

            System.out.println("===ls:"+cs.newInstance());

            

        } catch (ClassNotFoundException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        }catch (SecurityException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        } catch (InstantiationException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        } catch (IllegalAccessException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        } catch (IllegalArgumentException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        } catch (InvocationTargetException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        } catch (NoSuchMethodException ex) {

            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);

        }

        

    }



}