单例模式没你想的那么简单

网上到处都是懒汉，饿汉模式。给两个Demo就算过去了吧。

饿汉单例模式：在类加载的时候，就开始实例化了。

public class HungrySingleton {

    private static  HungrySingleton one=new HungrySingleton();

    private HungrySingleton(){}

    public  static HungrySingleton getInstance(){
        return one;
    }

    public static void main(String[] args) {
        HungrySingleton one1=HungrySingleton.getInstance();
        HungrySingleton one2=HungrySingleton.getInstance();
        System.out.println(one1==one2);
    }
}

懒汉模式：在第一次获取实例化对象的时候，开始实例化。

public class LazySingleton {
    private static LazySingleton one=null;

    private LazySingleton() {
    }
    public  static LazySingleton getInstance(){
        if(one==null){
            one=new LazySingleton();
        }
        return one;
    }

    public static void main(String[] args) {
        LazySingleton one1=LazySingleton.getInstance();
        LazySingleton one2=LazySingleton.getInstance();
        System.out.println(one1 == one2);
    }
}

无论何种模式先要把构造函数给私有化，否则就变成了“勤快汉”模式了；这名字是我瞎编的。

饿汉模式典型用法：Spring中IOC容器ApplictionContext,连接池.

懒汉模式典型用法：不知道啊。

饿汉模式没缺点，最多也就在没使用的时候，分配个内存空间。

下面着重说说懒汉模式，所以来个分割线吧。

=================================

懒汉单例模式的线程安全

上面的懒汉模式有线程安全问题，就是多个线程在同时执行的时候，怎么保证LazySingleton只被实例化了一次。

线程类：

public class ExectorThread implements Runnable {
    @Override
    public void run() {
        LazySimpleSingleton one=LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + one);
    }
}

单例类：

public class LazySimpleSingleton {

    private static LazySimpleSingleton one=null;

    private LazySimpleSingleton() {
    }
    public static LazySimpleSingleton getInstance(){
        if(one==null){
            one= new LazySimpleSingleton();
        }
        return one;
    }
}

测试类：

public class LazyTest {
    public static void main(String[] args) {
        Thread t1=new Thread(new ExectorThread());
        Thread t2=new Thread(new ExectorThread());

        t1.start();
        t2.start();

        System.out.println("end");
    }
}

第一个线程把one实例化完成之后，还没有来得及刷新到内存，第二个线程就把one读入内存，又进行了一次实例化。

最简单的办法就是给实例化方法getInstance()添加一个synchronized.

修改后代码如下

public class LazySimpleSingleton {

    private static LazySimpleSingleton one=null;

    private LazySimpleSingleton() {
    }
    public static synchronized LazySimpleSingleton getInstance(){
        if(one==null){
            one= new LazySimpleSingleton();
        }
        return one;
    }
}

这种模式有一个性能问题；比如100个线程在同时调用getInstance()的时候，99个全部都阻塞在这个位置了，

包括one已经不是空值的时候，依然在阻塞中；改造上面的代码，让已经实例化之后的线程不在阻塞。

public class LazySimpleSingleton {

    private static LazySimpleSingleton one=null;

    private LazySimpleSingleton() {
    }
    public static  LazySimpleSingleton getInstance(){
        //索前判断是否实例化了，实例化了就不用进入synchronized中了
        if(one==null){
            synchronized(LazySimpleSingleton.class){
                //上面one==null了，不代表此时还是null
                if(one==null){
                    one= new LazySimpleSingleton();
                }
                return one;
            }
        }
        return one;
    }
}

反射破坏单例

以饿汉单例的Demo为例子进行改造。

public class HungrySingleton {
    
    private static  HungrySingleton one=new HungrySingleton();

    private HungrySingleton(){}

    public  static HungrySingleton getInstance(){
        return one;
    }

    public static void main(String[] args)  throws Exception{
        HungrySingleton one1=HungrySingleton.getInstance();
        Constructor constructor=HungrySingleton.class.getDeclaredConstructor(null);
        //强制访问构造器，包括私有成员
        constructor.setAccessible(true);
        HungrySingleton one2=(HungrySingleton) constructor.newInstance();
        System.out.println(one1==one2);
    }
}

打印结果显示false.说明被实例化了两次；修改代码如下。

public class HungrySingleton {

    private static  HungrySingleton one=new HungrySingleton();

    private HungrySingleton(){
        if(one!=null){
            throw new RuntimeException("已经实例化过了,本次实例化失败");
        }
    }

    public  static HungrySingleton getInstance(){
        return one;
    }

    public static void main(String[] args)  throws Exception{
        HungrySingleton one1=HungrySingleton.getInstance();
        Constructor constructor=HungrySingleton.class.getDeclaredConstructor(null);
        //强制访问构造器，包括私有成员
        constructor.setAccessible(true);
        HungrySingleton one2=(HungrySingleton) constructor.newInstance();
        System.out.println(one1==one2);
    }
}

打印结果：

序列化破坏单例模式 

以饿汉模式为例：

public class SeriableSingleton  implements Serializable {
    public final  static SeriableSingleton one=new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance(){
        return one;
    }  
}

测试类：

public class SeriableSingletonTest {
    public static void main(String[] args) {
        SeriableSingleton s1=null;
        SeriableSingleton s2=SeriableSingleton.getInstance();

        FileOutputStream fos=null;
        try {
            fos=new FileOutputStream("one.obj");
            ObjectOutputStream oos=new ObjectOutputStream(fos);
            oos.writeObject(s2);
            oos.flush();
            oos.close();

            FileInputStream fis=new FileInputStream("one.obj");
            ObjectInputStream ois=new ObjectInputStream(fis);
            s1=(SeriableSingleton) ois.readObject();
            ois.close();

            System.out.println(s1 == s2);

        } catch (Exception e){

        }
    }
}

显示结果是false.

这个问题很好办，加一行代码的事情。

public class SeriableSingleton  implements Serializable {
    public final  static SeriableSingleton one=new SeriableSingleton();

    private SeriableSingleton() {
    }

    public static SeriableSingleton getInstance(){
        return one;
    }

    private Object readResolve(){
12         return one;
13     }
}

上面红色就是添加的一个方法。

这是一个奇怪的现象，直接从源码中找答案吧。

readObject()源码

readObject0()源码 

private Object readObject0(boolean unshared) throws IOException {
       
...
                case TC_OBJECT:
                    return checkResolve(readOrdinaryObject(unshared));
........
                
    }

上面代码去除了一些无用代码。

继续看readOrdinaryObject()源码

private Object readOrdinaryObject(boolean unshared)
        throws IOException
    {   
      
      //判断是否有readResolve()方法
        if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {        
            Object rep = desc.invokeReadResolve(obj);
           
        }

        return obj;
    }

invokeReadResolve()源码

 Object invokeReadResolve(Object obj)
        throws IOException, UnsupportedOperationException
    {
       ..........
        if (readResolveMethod != null) {
            try {//利用反射调用readResolve()方法
                return readResolveMethod.invoke(obj, (Object[]) null);
            }
        } 
    }

因为JDK在readObject（）时候，判断了有没有readResolve()方法，如果有的话就执行这个方法，没有就不执行了，我们充分利用了这个特点，给他直接返回了一个one对象；

所以就不执行实例化了。其实这个地方在readObject（）时候实例化了一次，只不过新创建的对象没有被返回而已。