单例模式介绍

单例模式，是为了确保在整个软件体统中，某个类对象只有一个实例，并且该类通常会提供一个对外获取该实例的public方法(静态方法)。
比如日志、数据库连接池等对象，通常需要且只需要一个实例对象，这就会使用单例模式。

单例模式的7种模式

饿汉式
- 静态常量
- 静态代码块
懒汉式
- 线程不安全
- 同步方法
- 同步代码块
双重检查
静态内部类
枚举
容器实现单例模式
线程池实现单例模式

下面依次来说明一下：

饿汉式(静态常量)

通常，我们创建一个对象的方式就是new，但是，当我们考虑只创建一个实例的时候，就应该禁止外部来通过new的方式进行创建。同时，由于无法使用new，你应该考虑提供一个获取单例对象的方式给别人。

思路

1.将构造器私有化(防止外部new，但是对反射还是有局限)
2.类的内部创建对象
3.对外提供一个获取实例静态的public方法

代码实现：

public class Singleton1 {
    public static void main(String[] args) {
        HungrySingleton hungrySingleton = HungrySingleton.getInstance();
        HungrySingleton hungrySingleton1 = HungrySingleton.getInstance();
        System.out.println(hungrySingleton == hungrySingleton1);
    }
}

class HungrySingleton {
    //1.私有化构造器
    private HungrySingleton() {
    }

     // 2.类内部创建对象，因为步骤3是static的，
    // 所以实例对象是static的
    private final static HungrySingleton instance = new HungrySingleton();

    //3.对外提供一个获取对象的方法，
    // 因为调用方式的目的就是为了获取对象，
    // 所以该方法应该是static的。
    public static HungrySingleton getInstance() {
        return instance;
    }
}

运行程序显示，我们的确只创建了一个对象实例。

小结

优点：代码实现比较简单，在类加载的时候就完成了实例化，同时，该方式能够避免线程安全问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
这种方式基于classloder机制避免了多线程的同步问题，不过， instance在类装载时就实例化，在单例模式中大多数都是调用getInstance方法，但是导致类装载的原因有很多种，因此不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化instance就没有达到lazy loading的效果。
总结：这种单例模式可以使用，但是可能造成内存的浪费。

饿汉式(静态代码块)

该方式和第一种区别不大，只是将创建实例放在了静态代码块中。
由于无法使用new，你应该考虑提供一个获取单例对象的方式给别人。

思路

1.将构造器私有化(防止外部new，但是对反射还是有局限)
2.类的内部创建对象(通过静态代码块)
3.对外提供一个获取实例静态的public方法

代码实现：

public class Singleton2 {
    public static void main(String[] args) {
        HungrySingleton hungrySingleton = HungrySingleton.getInstance();
        HungrySingleton hungrySingleton1 = HungrySingleton.getInstance();
        System.out.println(hungrySingleton == hungrySingleton1);
    }
}

class HungrySingleton {
    //1.私有化构造器
    private HungrySingleton() {
    }

    // 2.类内部创建对象，因为步骤3是static的，
    // 所以实例对象是static的
    private final static HungrySingleton instance;

    static {
        instance = new HungrySingleton();
    }

    //3.对外提供一个获取对象的方法，
    // 因为调用方式的目的就是为了获取对象，
    // 所以该方法应该是static的。
    public static HungrySingleton getInstance() {
        return instance;
    }
}

小结

该方式只是将对象的创建放在静态代码块中，其优点和缺点与第一种方式完全一样。
总结：这种单例模式可以使用，但是可能造成内存的浪费。(同第一种)

懒汉式(线程不安全)

该方式的主要思想就是为了改善饿汉式的缺点，通过懒加载(在使用的时候再去加载)，达到节约内存的目的。
由于无法使用new，你应该考虑提供一个获取单例对象的方式给别人。

思路

1.将构造器私有化(防止外部new，但是对反射还是有局限)
2.类的内部创建对象，懒加载，在使用的时候才去加载
3.对外提供一个获取实例静态的public方法

代码实现：

public class Singleton3 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

class LazySingleton {
    //1.私有化构造器
    private LazySingleton() {}

    //2.类的内部声明对象
    private volatile static LazySingleton instance;

    //3.对外提供获取对象的方法
    public static LazySingleton getInstance() {
        //判断类是否被初始化
        if (instance == null) {
            //第一次使用的时候，创建对象
            instance = new LazySingleton();
        }
        return instance;
    }
}

class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LazySingleton instance = LazySingleton.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

执行程序后，发现了问题：

//运行结果：
线程Thread-0开始执行
线程Thread-1开始执行
线程Thread-1初始化对象1391273746
线程Thread-0初始化对象547686109

小结

优点：起到了懒加载的作用，但是只能在单线程情况下使用。
缺点：多线程下不安全，如果一个线程进入到if语句中阻滞(还未开始创建对象)，另一线程进入并通过了if判断，则会创建多个实例，这一点就违背了单例的目的。
结论：实际情况下，不要使用这种方式。

懒汉式(线程安全，同步方法)

思路

同上一中方式一样，但是为了解决多线程安全问题，使用同步方法。

代码演示：

public class Singleton4 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

class LazySingleton {
    //1.私有化构造器
    private LazySingleton() {}

    //2.类的内部声明对象
    private volatile static LazySingleton instance;

    //3.对外提供获取对象的方法
    public synchronized static LazySingleton getInstance() {
        //判断类是否被初始化
        if (instance == null) {
            //第一次使用的时候，创建对象
            instance = new LazySingleton();
        }
        return instance;
    }
}

class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LazySingleton instance = LazySingleton.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

运行结果如下所示：

线程Thread-1开始执行
线程Thread-0开始执行
线程Thread-0初始化对象681022576
线程Thread-1初始化对象681022576

小结

优点：起到了懒加载的效果，同时，解决了线程安全问题。
缺点：效率低下，每次想要获取对象的时候，去执行getInstance()都是通过同步方法。而且，初始化对象后，再次使用的时候，应该直接return这个对象。
总结：可以在多线程条件下使用，但是效率低下，不推荐。

懒汉式(线程安全，同步代码块)

思路

同样是为了解决多线程安全问题，不过采用的是同步代码块。首先，最先想到的是：

1.将getInstance()方法体全部加上同步锁。

代码实现：

public class Singleton5 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

//对getInstance()的方法体整体加同步代码块
class LazySingleton {
    //1.私有化构造器
    private LazySingleton() {}

    //2.类的内部声明对象
    private volatile static LazySingleton instance;

    //3.对外提供获取对象的方法
    public static LazySingleton getInstance() {
        //同步代码块
        synchronized (LazySingleton.class) {
            //判断类是否被初始化
            if (instance == null) {
                //第一次使用的时候，创建对象
                instance = new LazySingleton();
            }
        }
        return instance;
    }
}

class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LazySingleton instance = LazySingleton.getInstance();
//     LazySingleton1 instance = LazySingleton1.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

运行的结果：

线程Thread-0开始执行
线程Thread-1开始执行
线程Thread-1初始化对象1419349448
线程Thread-0初始化对象1419349448

这种方式的优缺点和同步方法一样，能够实现多线程安全，但是效率低下。那么，能不能提高一下效率呢？我们发现，每次调用getInstance()的时候，都要进入同步代码块，但是，一旦对象初始化后，第二次使用的时候，应该能够直接获取这个对象才对。
按照这个思路，对代码进行更改(为了说明这个，新建一个类LazySingleton1)：

2.只在初始化对象部分加上同步锁

代码实现：

//为了提高效率，通过if判断，初始化之前进入同步锁
class LazySingleton1 {
    //1.私有化构造器
    private LazySingleton1() {}

    //2.类的内部声明对象
    private volatile static LazySingleton1 instance;

    //3.对外提供获取对象的方法
    public static LazySingleton1 getInstance() {
        //判断类是否被初始化
        if (instance == null) {
            //第一次使用的时候，创建对象
            synchronized (LazySingleton1.class) {
                instance = new LazySingleton1();
            }
        }
        return instance;
    }

将类TestClass的run()方法进行更改，获取的实例改为LazySingleton1类型。代码看上去没有问题，那么运行效果如何呢：

//运行结果：
线程Thread-1开始执行
线程Thread-0开始执行
线程Thread-1初始化对象1368942806
线程Thread-0初始化对象1187311731

那么，我们发现，打脸了，多线程情况下，创建了两个对象，并未达到单例的目的。

小结

对整个方法体加同步代码块
可以达到要求，优缺点同同步方法。
只在初始化对象的代码添加同步锁
不能满足线程安全要求，实际工作中，不能使用这种方式。

懒汉式(线程安全，双重检查机制)

思路

针对懒汉式的多线程问题，我们可谓是操碎了心：同步方法可以解决问题，但是效率太低了；同步代码块则根本不能保证多线程安全。如何能做到“鱼和熊掌兼得”呢？既然同步代码块的效率较好，那么我们就针对这个方式进行改良：双重检查机制，即在getInstance()内进行两次检查，第一次通过if判断后，初始化对象之前，进行同步并再次进行判断。这样做的目的：既能解决线程安全问题，同时避免第二次使用对象的时候还要执行同步的代码。

代码实现：

public class Singleton6 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

class LazyDoubleCheckSingleton {
    //1.私有化构造器
    private LazyDoubleCheckSingleton() {}

    //2.类的内部声明对象
    private volatile static LazyDoubleCheckSingleton instance;

    //3.对外提供获取对象的方法
    public static LazyDoubleCheckSingleton getInstance() {
        //判断类是否被初始化
        if (instance == null) {
            //第一次使用，通过if判断
            //加锁
            synchronized (LazyDoubleCheckSingleton.class) {
                //拿到锁后，初始化对象之前，再次进行判断
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }
}

class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        LazyDoubleCheckSingleton instance = LazyDoubleCheckSingleton.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

运行结果如下所示：

//运行结果：
线程Thread-0开始执行
线程Thread-1开始执行
线程Thread-1初始化对象996963733
线程Thread-0初始化对象996963733

小结

优点：

解决了上一种方式中的线程安全问题，同时实现了延迟加载的效果，节约内存；
第二次使用的时候，if判断为false，直接返回创建好的对象，避免进入同步代码，提高了效率；
结论：推荐使用这种方式，实际工作中也比较常见这种方式。

静态内部类

思路

为了实现多线程情况下安全，除了手工加锁，还有别的方式。现在，我们采用静态内部类的方式。这种方式利用了JVM加载类的机制来保证只初始化一个对象。
思路同样是私有化构造器，对外提供静态的公开方法；不同之处是，类的创建交给静态内部类来时实现。

代码实现

public class Singleton7 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

class StaticInnerSingleton {
    // 1.构造器私有化
    private StaticInnerSingleton() {}

    // 2.通过静态内部类来初始化对象
    private static class InnerClass {
        private static final StaticInnerSingleton INSTANCE = new StaticInnerSingleton();
    }

    // 3.对外提供获取对象的方法
    public static StaticInnerSingleton getInstance() {
        return InnerClass.INSTANCE;
    }
}


class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        StaticInnerSingleton instance = StaticInnerSingleton.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

运行结果：

线程Thread-0开始执行
线程Thread-1开始执行
线程Thread-0初始化对象1326533480
线程Thread-1初始化对象1326533480

OK，我们发现，这种方式达到了预期的效果。

小结

优点：

这种静态内部类的方式，通过类加载机制来保证了初始化实例时只有一个实例。
类的静态属性只有在第一次加载类的时候初始化，而JVM能保证线程安全，在类的初始化过程中，只有一个线程能进入并完成初始化。
静态内部类方式实现了懒加载的效果，这种方式不会在类StaticInnerSingleton加载的时候进行初始化，而是在第一次使用时调用getInstance()方法初始化，能够起到节约内次的目的。
该方式的getInstance()方法，通过调用静态内部类的静态属性返回实例对象，避免了每次调用时进行同步，效率高。
结论：线程安全，效率高，代码实现简单，推荐使用。

枚举

思路

在静态内部类的方式中，我们借用了JVM的类加载机制来实现了功能，同样，还可以借用Java的枚举来实现单例模式。

public class Singleton8 {
    public static void main(String[] args) {
        TestThread testThread = new TestThread();
        Thread thread = new Thread(testThread);
        Thread thread1 = new Thread(testThread);
        thread.start();
        thread1.start();
    }
}

enum EnumSingleton {
    INSTANCE;

    public void sayHi() {
        System.out.println("Hi, " + INSTANCE);
    }
}

class TestThread implements Runnable {

    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        EnumSingleton instance = EnumSingleton.INSTANCE;
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance.hashCode());
    }
}

运行结果如下：

线程Thread-0开始执行
线程Thread-1开始执行
线程Thread-1初始化对象1134798663
线程Thread-0初始化对象1134798663

小结

优点：

这中方式需要在JDK1.5以上的版本中使用，利用枚举来实现单例模式。能避免多线程同步问题。
能防止反序列化重新创建新的对象。
能防止反射机制来破断单例模式。
在《Effective Java》中提到了这种方式，其作者推荐。
结论：推荐使用。

使用容器来创建单例

思路

我们可以先初始化单例对象，通过容器来管理，然后在使用的时候从容器中获取对象。

代码实现：

class ContainSingleton {
    private ContainSingleton() {}

    private static Map singletonMap = new HashMap<>();

    public static Object getInstance(String key) {
        return singletonMap.get(key);
    }

    public void putInstance(String key, Object instance) {
        if (StringUtils.isNotEmpty(key) && instance != null) {
            if (!singletonMap.containsKey(key)) {
                singletonMap.put(key,instance);
            }
        }
    }
}

小结

这种单例模式是有一定的安全隐患的，如果你多个线程去创建实例，并且key相同，是有可能创建多个实例的。这种形式，建议在使用的时候，先去使用一个线程初始化数据后再使用。

线程池实现单例模式

思路

思路也前面的几种形式一样，无非就是用线程池来创建对象而已。

代码实现

class ThreadLocalSingleton {
    //私有化构造器
    private ThreadLocalSingleton() {}

    //类的内部创建单例对象
    private static final ThreadLocal instanceThreadLocal =
            new ThreadLocal() {
                @Override
                protected ThreadLocalSingleton initialValue() {
                    return new ThreadLocalSingleton();
                }
            };
    // 获取对象的方法
    public static ThreadLocalSingleton getInstance() {
        return instanceThreadLocal.get();
    }
}

但是，这种形式的单例模式是要带引号的。为什么这么说呢?写一个代码测试一下吧：

class TestClass implements Runnable {
    @Override
    public void run() {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");
        try {
            //为了演示多线程情况
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        ThreadLocalSingleton instance = ThreadLocalSingleton.getInstance();
        System.out.println("线程" + Thread.currentThread().getName() + "初始化对象" + instance);
    }
}

public class Singleton10 {
    public static void main(String[] args) {
        TestClass testClass = new TestClass();
        Thread t1 = new Thread(testClass);
        Thread t2 = new Thread(testClass);
        t1.start();
        t2.start();

        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
        System.out.println(ThreadLocalSingleton.getInstance());
    }
}

OK , 我们发现了，多线程下创建了不同的对象，但是，对于同一线程，你多次获取的对象始终是同一个。

image

小结

这种形式的单例模式，和之前的懒汉式加锁的形式不一样，加同步锁的思路是牺牲时间(效率)来实现；这种形式是保证同一线程中的单例，
属于牺牲空间来实现。

单例模式的序列化漏洞

在上面的枚举类的总结中，我们提高枚举方式能够避免反序列化对象的时候重新建立新的对象(反序列化漏洞)，那么什么是反序列化漏洞呢？Java对象进行反序列化的时候会通过反射机制来创建实例，反射机制的存在使得我们可以越过Java本身的静态检查和类型约束，在运行期直接访问和修改目标对象的属性和状态。这里理解的不是很准确，有错误的话请指出。

代码演示：

public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//        HungrySingleton instance = HungrySingleton.getInstance();
//        //序列化
//        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("serializable_singleton"));
//        oos.writeObject(instance);
//
//        //反序列化
//        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("serializable_singleton"));
//        HungrySingleton newInstance = (HungrySingleton) ois.readObject();

        LazyDoubleCheckSingleton instance = LazyDoubleCheckSingleton.getInstance();
        //序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("serializable_singleton"));
        oos.writeObject(instance);

        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("serializable_singleton"));
        LazyDoubleCheckSingleton newInstance = (LazyDoubleCheckSingleton) ois.readObject();

        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }

}
class HungrySingleton implements Serializable {


    private static final long serialVersionUID = -4913346286867374832L;

    //1.私有化构造器
    private HungrySingleton() {
    }

    // 2.类内部创建对象，因为步骤3是static的，
    // 所以实例对象是static的
    private final static HungrySingleton instance;

    static {
        instance = new HungrySingleton();
    }

    //3.对外提供一个获取对象的方法，
    // 因为调用方式的目的就是为了获取对象，
    // 所以该方法应该是static的。
    public static HungrySingleton getInstance() {
        return instance;
    }

    //解决单例模式的反序列化漏洞
  //    public Object readResolve() {
//        return instance;
//    }
}

class LazyDoubleCheckSingleton implements Serializable {
    private static final long serialVersionUID = -8459475238793042042L;

    //1.私有化构造器
    private LazyDoubleCheckSingleton() {}

    //2.类的内部声明对象
    private volatile static LazyDoubleCheckSingleton instance;

    //3.对外提供获取对象的方法
    public static LazyDoubleCheckSingleton getInstance() {
        //判断类是否被初始化
        if (instance == null) {
            //第一次使用，通过if判断
            //加锁
            synchronized (LazyDoubleCheckSingleton.class) {
                //拿到锁后，初始化对象之前，再次进行判断
                if (instance == null) {
                    instance = new LazyDoubleCheckSingleton();
                }
            }
        }
        return instance;
    }

//    public Object readResolve() {
//        return instance;
//    }
}

这里，我们分别提供了懒汉式和饿汉式(双重检查)来验证这个现象。运行后会报错，实现Serializable接口后能够正常运行，结果如下：

com.bm.desginpattern.pattern.creational.singleton.serialization.LazyDoubleCheckSingleton@7f31245a
com.bm.desginpattern.pattern.creational.singleton.serialization.LazyDoubleCheckSingleton@6d03e736
false

创建了两个对象，没有实现多线程安全。首先说明一下解决方案，然后再讲解一下原理。我们发现饿汉式还是懒汉式都新增了一个方法readResolve()，将注释取消后，再次运行的结果如下：

com.bm.desginpattern.pattern.creational.singleton.serialization.LazyDoubleCheckSingleton@7f31245a
com.bm.desginpattern.pattern.creational.singleton.serialization.LazyDoubleCheckSingleton@7f31245a
true

奇迹出现了，只是增加一个方法，情况完全不同了。那么背后的原理是什么呢？我们通过debug来讲解：

image

1.在23行打一个断点，进入并进入该方法：

image

2.我们发现，该方法首先是进行一些判断，然后执行readObject0()方法，进入该方法查看：

image

//该方法完成代码
 private Object readObject0(boolean unshared) throws IOException {
        boolean oldMode = bin.getBlockDataMode();
        if (oldMode) {
            int remain = bin.currentBlockRemaining();
            if (remain > 0) {
                throw new OptionalDataException(remain);
            } else if (defaultDataEnd) {
                /*
                 * Fix for 4360508: stream is currently at the end of a field
                 * value block written via default serialization; since there
                 * is no terminating TC_ENDBLOCKDATA tag, simulate
                 * end-of-custom-data behavior explicitly.
                 */
                throw new OptionalDataException(true);
            }
            bin.setBlockDataMode(false);
        }

        byte tc;
        while ((tc = bin.peekByte()) == TC_RESET) {
            bin.readByte();
            handleReset();
        }

        depth++;
        totalObjectRefs++;
        try {
            switch (tc) {
                case TC_NULL:
                    return readNull();

                case TC_REFERENCE:
                    return readHandle(unshared);

                case TC_CLASS:
                    return readClass(unshared);

                case TC_CLASSDESC:
                case TC_PROXYCLASSDESC:
                    return readClassDesc(unshared);

                case TC_STRING:
                case TC_LONGSTRING:
                    return checkResolve(readString(unshared));

                case TC_ARRAY:
                    return checkResolve(readArray(unshared));

                case TC_ENUM:
                    return checkResolve(readEnum(unshared));

                case TC_OBJECT:
                    return checkResolve(readOrdinaryObject(unshared));

                case TC_EXCEPTION:
                    IOException ex = readFatalException();
                    throw new WriteAbortedException("writing aborted", ex);

                case TC_BLOCKDATA:
                case TC_BLOCKDATALONG:
                    if (oldMode) {
                        bin.setBlockDataMode(true);
                        bin.peek();             // force header read
                        throw new OptionalDataException(
                            bin.currentBlockRemaining());
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected block data");
                    }

                case TC_ENDBLOCKDATA:
                    if (oldMode) {
                        throw new OptionalDataException(true);
                    } else {
                        throw new StreamCorruptedException(
                            "unexpected end of block data");
                    }

                default:
                    throw new StreamCorruptedException(
                        String.format("invalid type code: %02X", tc));
            }
        } finally {
            depth--;
            bin.setBlockDataMode(oldMode);
        }
    }

我们发现，该方法还是对传入的对象进行一些判断，在这里，我们匹配到TC_OBJECT，执行对应的方法。
3.进入该方法：

image

4.进一步查看：

image

我们看到一个名为resolveEx的属性，说明很接近了。
5.继续往下调试：

image

image

我们发现，这三个条件都满足，因为我们在LazyDoubleCheckSingleton类中定义了readResolve()方法。

image

6.if判断通过，进入到下一个方法：

image

7.在该方法中，我们发现经过一些条件判断后，通过反射方式来调用我们在类LazyDoubleCheckSingleton中新定义的方法readResolve():

image

如果我们没有新增这个方法，反射的时候会新建一个LazyDoubleCheckSingleton对象，并将其返回；
当我们新增这个readResolve()的时候，反射的时候还是会创建一个新的对象，但是，返回的是我们在readResolve()中的定义的返回对象。从而达到了多线程安全的目的。

单例模式的反射漏洞

除了反序列化漏洞，单例模式还有反射漏洞。下面介绍一下：
通过反射，能够破坏单例模式，进而生成多个对象。

先来一个例子，以饿汉式为例：

class HungrySingleton {
    private HungrySingleton() {}

    private final static HungrySingleton instance = new HungrySingleton();

    public static HungrySingleton getInstance() {
        return instance;
    }
}

  public static void main(String[] args) throws Exception {
        //测试，饿汉式
        Constructor constructor = HungrySingleton.class
                .getDeclaredConstructor();
        constructor.setAccessible(true);
        HungrySingleton instance = HungrySingleton.getInstance();
        HungrySingleton newInstance = constructor.newInstance();
        System.out.println(instance);
        System.out.println(newInstance);
        System.out.println(instance == newInstance);
    }

运行一下，就能发现，生成了两个实例，破坏了单例模式。同样的情况，也会发生在静态内部类、懒汉式中。

解决方案

饿汉式、静态内部类：
直接改造一下构造器即可，防止生成多个对象。

 private HungrySingleton() {
        if (instance != null) {
            throw new RuntimeException("禁止反射机制生成实例");
        }
    }

静态内部类同理。

懒汉式：
当你采用懒汉式的时候，关于防止反射攻击，我是比较悲观的。当然，解决问题的思路和饿汉式一样，但是效果却不尽人意。代码演示如下：
首先，改造构造器。

 private HungrySingleton() {
        if (instance != null) {
            throw new RuntimeException("单例构造器禁止反射机制调用");
        }
    }

但是，当你先执行getInstance()方法来生成实例的时候，问题能够解决，可以当你先通过反射来生成对象的时候，就出问题了：

image

这时，你的运行结果就如下图所示：

image

怎么办？有人说，新增一个变量，在构造器中根据变量的值该判断，但是，这种方式其实没啥用。因为同样可以通过反射机制该修改属性值。
在这里，再一次想起神奇的枚举类，既能防止反序列化漏洞，又能防止反射漏洞，推荐大家使用。

单例模式在框架源码中的使用

jdk中的使用案例

例如Runtime类，使用的就是单例模式的饿汉式(Runtime类在lang包中，在JVM运行的时候就被加载)来实现：

image

还有Desktop类，使用的就是单例模式的容器模式结合同步锁来实现的：

image

Spring中单例模式的应用

Spring单例Bean与单例模式的区别：它们关联的环境不一样，单例模式是指在一个JVM进程中仅有一个实例，而Spring单例是指一个Spring Bean容器(ApplicationContext)中仅有一个实例。

image

image

当你配置一个bean为单例的时候(默认就是singleton)，在获取对象的时候，spring会读取判断为true，然后如果这个对象已经创建好则直接返回，否则就调用方法getEarlySingletonInstance()来创建对象(其源码为第二张图片)。

总结

单例模式保证了系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。
当想实例化一个单例类的时候，必须要记住使用相应的获取对象的方法，而不是使用new。
单例模式使用的场景：需要频繁的进行创建和销毁的对象、创建对象时耗时过多或耗费资源过多(即：重量级对象)，但又经常用到的对象、工具类对象、频繁访问数据库或文件的对象(比如数据源、 session工厂等)。

DesignPattern系列__10单例模式

单例模式介绍

单例模式的7种模式

饿汉式(静态常量)

思路

代码实现：

小结

饿汉式(静态代码块)

思路

代码实现：

小结

懒汉式(线程不安全)

思路

代码实现：

小结

懒汉式(线程安全，同步方法)

思路

代码演示：

小结

懒汉式(线程安全，同步代码块)

思路

1.将getInstance()方法体全部加上同步锁。

代码实现：

2.只在初始化对象部分加上同步锁

代码实现：

小结

懒汉式(线程安全，双重检查机制)

思路

代码实现：

小结

静态内部类

思路

代码实现

小结

枚举

思路

小结

使用容器来创建单例

思路

代码实现：

小结

线程池实现单例模式

思路

代码实现

小结

单例模式的序列化漏洞

代码演示：

单例模式的反射漏洞

先来一个例子，以饿汉式为例：

解决方案

单例模式在框架源码中的使用

jdk中的使用案例

Spring中单例模式的应用

总结

你可能感兴趣的:(DesignPattern系列__10单例模式)