单例模式深入理解

public class HungrySingleton  implements Serializable
{
    private HungrySingleton(){
        if(null != instance){//防止反射破坏单例，场景为二方库调用者强行破坏单例
            throw new IllegalOperationException();
        }
    }
    public  static final HungrySingleton instance = new HungrySingleton();
    public static HungrySingleton getInstance(){
        return instance;
    }
    // 防止反序列化获取多个对象，Java这儿比较奇特，因为在Serializable
    private Object readResolve() throws ObjectStreamException {
        return instance;
    }
}
    
public class HungrySingletonTest {
    @Test
    public void testGetInstance() throws Exception {
        Class<HungrySingleton> clazz = HungrySingleton.class;
        Constructor<?> ctor = clazz.getDeclaredConstructor(null);
        ctor.setAccessible(true);
        HungrySingleton first = HungrySingleton.getInstance();
        HungrySingleton second = (HungrySingleton)ctor.newInstance(null);//破坏单例失败
    }
}

//加同步锁的懒汉式，比较简单，但每次获取实例时都需要获得锁，对性能有一定影响
public static synchronized LazySingleton01 getInstance(){
    if(instance == null){
        instance = new LazySingleton01();
    }
    return instance;
}

//防止指令重排优化的懒汉式
//对常见的双锁进行了优化，对instance使用volatile修饰
//再JAVA中，同步块外的判空操作有可能看到已存在，但不完整的实例.
//如果使用不完整的实例则会造成系统崩溃，造成该问题的原因是由于Java内存模型的重排序机制。
public  static volatile LazySingleton02 instance = null;
public static LazySingleton02 getInstance(){
    if(null  == instance){
        synchronized (LazySingleton02.class) {
            if(null == instance){
                instance  = new LazySingleton02();
            }
        }
    }
    return instance;
}

//单测时一定要注意，需要使用多个线程进行测试，不然就失去了意义
public class LazySingleton02Test {
    @Test
    public void getInstance() throws  InterruptedException, ExecutionException{
        ExecutorService threadPool = Executors.newFixedThreadPool(2);
        Future<LazySingleton02> futureA = threadPool.submit(
                new Callable<LazySingleton02>() {
                    @Override
                    public LazySingleton02 call() {
                        return LazySingleton02.getInstance();
                    }
                }
        );
        Future<LazySingleton02> futureB = threadPool.submit(
                new Callable<LazySingleton02>() {
                    @Override
                    public LazySingleton02 call() {
                        return LazySingleton02.getInstance();
                    }
                }
        );
        Assert.assertNotNull(futureA.get());
        Assert.assertNotNull(futureB.get());
        Assert.assertTrue(futureA.get().equals(futureB.get()));
    }
}

public class LazySingleton03 {
    private LazySingleton03(){}
    private  static class  LazyHolder{
            private  static final LazySingleton03 INSTANCE = new LazySingleton03();
        }
        //借助了静态内部类的特性，其要被引用后才会装载到内存
        //通常的理解是，只要是当前jar中的静态属性或方法都会被加载到内存，但静态内部类却不是，它只有在第一次调用getInstance方法，产生了LazyHolder的引用，才会被真正加载。
        //实际上也是懒加载。
        public static final LazySingleton03 getInstance(){
            return LazyHolder.INSTANCE;
    }
}

memory = allocate();//分配内存空间，C语言中应该很熟悉
instance = memory;//这时instance会变成非空，但还未初始化
ctor(instance);//初始化对象

public class InnerClass {
    private static String staticName = "xionger";
    private String objectName = "xiongda";

    public static final class InnerClass01 {//静态内部类
        private statißßc String name = InnerClassInterface.class.getName();
        public static String getName() {
            return InnerClass.staticName + "--" + name;
        }
    }
    public class InnerClass02 {//成员内部类
        public String getName() {
            return InnerClass.this.objectName;//注意这儿获取外部类属性的形式
        }
    }
}

public class AnonymousInnerClass {
    public void createThread(){
        Thread thd = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(AnonymousInnerClass.class.getName());
            }
        });
    }
    //注意方法参数上的final关键字，由于内部类编译时生成单独的.class文件，内部类与外部类不在同一文件。
    //内部类是通过将传入的参数先通过构造器复制到自己内部再被使用的，因此为了保持数据的一致需要添加final。
    public InnerClassInterface getInnerClass(final String prefixName){
            return new InnerClassInterface(){
                @Override
                public String getName() {
                    return prefixName + "--suffixName";
                }
            };
        }
    }
    
    interface InnerClassInterface {
       String getName();
    }