设计模式之单例模式

程序员在编写代码的过程中，面临着耦合性、内聚性以及可维护性，可扩展性、重用性和灵活性等多方面的挑战，因此设计模式是为了让程序具有更好的：

①代码重用性；（相同功能不用多次编写）
②可读性；（便于其他程序员阅读和理解）
③可扩展性；（当增加新的功能时，非常方便）
④可靠性；（增加新的功能后，对原来的功能没有影响）
⑤使程序程序高内聚，低耦合；

单例模式

所谓单例模式就是采取一定的方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法（静态方法）

比如获取Mybatis里的SqlSessionFactory，充当数据存储源的代理，并负责创建SqlSession对象，这种情况下，一个项目通常只需要一个SqlSessionFactory就可以了，因此就会使用到单例模式。

（1）饿汉式（静态常量）

构造器私有化；类的内部创建对象；向外暴露一个静态的公共方法。
代码：

public class Type01 {

    public static void main(String[] args) {

        SingleTon s1 = SingleTon.getInstance();
        SingleTon s2 = SingleTon.getInstance();

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

class SingleTon {

    private SingleTon() {

    }

    private final static SingleTon instance = new SingleTon();

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

优缺点:
优点：写法简单，在类加载的时候就完成了实例化，避免了线程同步问题。
缺点：没有达到懒加载的效果，如果从始至终都没有使用过这个类，将会造成内存浪费。

（2）饿汉式（静态代码块）

代码：

package com.wzp.singleton;

/**
 * @Author: wzp
 * @Date: 2020/5/4 14:27
 */
public class Type02 {

    public static void main(String[] args) {
        SingleTon1 s1 = SingleTon1.getInstance();
        SingleTon1 s2 = SingleTon1.getInstance();

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

class SingleTon1 {

    private SingleTon1() {

    }

    private static SingleTon1 instance;

    static {
        instance = new SingleTon1();
    }

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

优缺点:
这种方法和上面的方法是一样的，只是将类的实例化放在了静态代码块中，类在加载时，也会执行静态代码块中的代码。优缺点和上面一样。

（3）懒汉式（线程不安全）

public class Type03 {

    public static void main(String[] args) {
        SingleTon2 s1 = SingleTon2.getInstance();
        SingleTon2 s2 = SingleTon2.getInstance();

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

class SingleTon2 {

    private SingleTon2() {

    }

    private static SingleTon2 instance;

    public static SingleTon2 getInstance() {

        if (instance == null) {
            instance = new SingleTon2();
        }

        return instance;
    }
}

优缺点:
优点：起到了懒加载的效果。
缺点：但只能在单线程下使用，如果在多线程下，一个线程进入if (instance == null)判断语句块，还没来得及往下执行，这时另一个线程也通过了这个判断块，就会产生多个实例。在实际开发中，不能用这种方式。

（4）懒汉式（线程安全）

这种方法只是在上面创建实例对象的方法加了synchronized
代码：

public class Type04 {

    public static void main(String[] args) {
        SingleTon3 s1 = SingleTon3.getInstance();
        SingleTon3 s2 = SingleTon3.getInstance();

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

class SingleTon3 {

    private SingleTon3() {

    }

    private static SingleTon3 instance;

    public static synchronized SingleTon3 getInstance() {

        if (instance == null) {
            instance = new SingleTon3();
        }

        return instance;
    }
}

优缺点:
优点：解决了线程不安全的问题
缺点：但效率太低了，每个线程要想获得实例对象时都要通过synchronized，而其实这个方法只执行一次实例化代码就够了，后面的想获得实例，直接return就行。在实际开发中，也不推荐这种方式。

（5）懒汉式（线程不安全和同步代码块）

代码：

public class Type05 {

    public static void main(String[] args) {
        SingleTon4 s1 = SingleTon4.getInstance();
        SingleTon4 s2 = SingleTon4.getInstance();

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

class SingleTon4 {

    private SingleTon4() {

    }

    private static SingleTon4 instance;

    public static SingleTon4 getInstance() {

        if (instance == null) {

            synchronized (SingleTon4.class) {
                instance = new SingleTon4();
            }
        }

        return instance;
    }
}

优缺点:
虽然较上面的方法效率高了，但这种同步并不能起到线程安全的作用。

（6）双重校验锁

代码：

public class Type07 {    
    
    public static void main(String[] args) {
        SingleTon6 s1 = SingleTon6.getInstance();
        SingleTon6 s2 = SingleTon6.getInstance();
    
        System.out.println(s1 == s2);
}
}

class SingleTon6 {

    private SingleTon6() {

    }

    //volatile的作用是立即更新到主存
    private static volatile SingleTon6 instance;

    public static SingleTon6 getInstance() {

        if (instance == null) {

            synchronized (SingleTon5.class) {

                if (instance == null) {
                    instance = new SingleTon6();
                }
            }
        }

        return instance;
    }
}

优缺点:
①进行了两次if (instance == null)的检查，保证了线程安全；
②实例化代码只执行一次，后面再次访问时，判断if (instance == null)，直接return实例化对象，避免反复进行方法同步。
③延迟加载，效率高。在开发中，经常用这种单例设计模式。

（7）静态内部类

代码：

public class Type08 {

    public static void main(String[] args) {
        SingleTon7 s1 = SingleTon7.getInstance();
        SingleTon7 s2 = SingleTon7.getInstance();

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

class SingleTon7 {

    private SingleTon7() {}

    private static class SingletonInstance {
        private static final SingleTon7 INSTANCE = new SingleTon7();
    }

    public static SingleTon7 getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

优缺点:
①这种方式采用了类装载的机制来保证初始化实例时只有一个线程。
②静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。
③类的静态属性只会在第一次加载类的时候才会初始化，在这里JVM帮我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。
④实现了延迟加载，避免了线程不安全，推荐使用。

（8）枚举

public class Type09 {

    public static void main(String[] args) {

        Singleton8 s1 = Singleton8.INSTANCE;
        Singleton8 s2 = Singleton8.INSTANCE;

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

    }
}

enum Singleton8 {

    INSTANCE; //只有一个属性，保证它是单例的

}

优缺点:
不仅能避免多线程问题，而且能防止反序列化重新创建新的对象，推荐使用。

（9）jdk中使用到单例模式的例子

java.lang.Runtime是经典的单例模式，采用饿汉式（静态常量）。