常用设计模式 （一、单例模式）

设计模式

创建型

单例模式 (Singleton)

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

比如Hibernate的SessionFactory，它充当数据存储源的代理，并负责创建Session对象。SessionFactory并不是轻量级的，
一般情况下，一个项目通常只需要一个SessionFactory就够，这里就用到单例模式

• 八种单例模式

1.饿汉式（静态变量）
2.饿汉式（静态代码块）

3.懒汉式（线程不安全）
4.懒汉式（线程安全，同步方法）
5.懒汉式（线程安全，同步代码块）

6.双重检查锁
7.静态内部类
8.枚举

• 单例模式分为两种

饿汉式：类加载就会导致该单实例对象被创建

懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建

饿汉式（静态变量）

public class Test01 {
    public static void main(String[] args) {

        A instance1 = A.getInstance();
        A instance2 = A.getInstance();

        System.out.println(instance1 == instance2);//true

    }
}

class A{

    //构造器私有化，确保不能通过 new 实例化对象
    private A(){}

    //static修饰 在类加载时创建本类的实例对象
    private static final A a = new A();

    //提供公有静态方法，让外界获取该对象
    public static A getInstance(){
        return a;
    }
}

饿汉式（静态代码块）

public class Test02 {
    public static void main(String[] args) {

        A1 instance = A1.getInstance();
    }
}

class A1{

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

    //声明 本类类型 变量
    private static A1 a1;

    //静态代码块 赋值
    static {
        a1 = new A1();
    }

    //静态方法 用于外界获取本类对象
    public static A1 getInstance(){
        return a1;
    }
}

懒汉式（线程不安全）

/**
 * 懒汉式一 把创建实例化对象放在静态方法中 线程不安全 符合懒加载
 * */
public class Test01 {
    public static void main(String[] args) {

        A instance = A.getInstance();
        System.out.println(instance);
    }
}

class A {

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

    //声明 该类类型的变量
    private static A a;

    //提供公有静态方法 将该类对象赋值给变量
    public static A getInstance(){
        if (a == null){
            a = new A();
        }
        return a;
    }
}

• 懒汉式（线程不安全）优缺点说明

1）起到了 Lazy loading的效果，但是只能在单线程下使用
2）如果在多线程下，一个线程进入了 if(a == null)判断语句块，还未来得及往下执行，另外一个线程也通过了这个判断语句，这时便会产生多个实例。
    所以在多线程环境下不可使用这种方式
3）结论：在实际开发中，不能使用这种方式

懒汉式（线程安全，同步方法）

/**
 * 懒汉式二 把静态代码块用 synchronized 修饰，做成同步方法，线程安全
 * 
 * 问题：每次执行getInstance的时候都需要同步，效率太低
 *      其实只需要在第一次加载的时候实例化对象，后面只需要调用该对象；
 * */
public class Test01 {
    public static void main(String[] args) {

        A instance = A.getInstance();
        System.out.println(instance);
    }
}

class A {

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

    //实例化A
    private static A a;

    //提供公有静态方法
    public static synchronized A getInstance(){
        if (a == null){
            a = new A();
        }
        return a;
    }
}

• 懒汉式（同步方法，线程安全）优缺点

1）解决了线程不安全问题
2）效率太低，每个线程都想获得类的实例的时候，执行getInstance()方法都要进行同步，而其实这个方法只执行一次实例化代码就够，
    后面的想获得该类实例，直接return就行了。方法进行同步效率太低
3）结论：在实际开发中，不推荐使用这种方式

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

双重检查锁

public class Test01 {
    public static void main(String[] args) {
        A instance = A.getInstance();
    }
}

class A {

    private A(){}

    private static volatile A a;

    /**
     * 双重检查锁
     *
     * 1、第一次多个线程通过第一个if判断，其中一个线程走同步代码块，a==null，赋值实例对象
     * 2、第一个线程走完，其他线程判断同步代码块的第二个if，a!=null
     * 3、再有线程调用，走第一个if就会判断为 a!=null，也就不用走同步代码块
     *
     * 结论：解决线程安全，懒加载问题，同时也保证效率
     * */
    public static A getInstance(){
        if (a == null){
            synchronized (A.class){
                if (a == null){
                    a = new A();
                }
            }
        }
        return a;
    }
}

静态内部类

public class Test01 {
    public static void main(String[] args) {

        A instance = A.getInstance();
        System.out.println(instance);
    }
}

class A {

    private A(){}

    /**
     * 静态内部类
     * 1、类加载时不会被实例化
     * 2、第一次调用静态内部类中的静态属性，进行类的初始化，JVM会保证线程安全
     *
     * 结论：即保证 懒加载 线程安全 效率高
     * */
    private static class AInstance{
        private static final A INSTANCE = new A();
    }

    //静态方法，方法静态内部类中实例化对象
    public static A getInstance(){
        return AInstance.INSTANCE;
    }
}

• 静态内部类 优缺点

1）这种方式采用了类装载的机制来保证初始化实例时只有一个线程
2）静态内部类方式在A类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载AInstance类，完成A的实例化
3）类的静态属性只会在第一次加载类时初始化，所以在这里，JVM帮助我们保证了线程安全性，在类进行初始化时，别的线程是无法进入的
4）优点：避免了线程不安全，利用静态内部类特点来实现延迟加载，效率高

枚举

public class Test01 {
    public static void main(String[] args) {
        A instance = A.INSTANCE;
        A instance1 = A.INSTANCE;
        System.out.println(instance == instance1);
        System.out.println(instance.hashCode());
        System.out.println(instance1.hashCode());

    }
}

enum A{ //枚举类
    INSTANCE;//属性
    public void say(){
        System.out.println("hello");
    }
}

• 优缺点

枚举类实现单例模式是极力推荐的单例模式，因为枚举类型是线程安全的，并且只会装载一次，设计者充分利用了枚举这个特征来实现单例模式，
枚举的写法非常简单，而且枚举类型是所有单例实现中唯一一种不会被破坏的单例实现模式

单例模式 总结

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