JAVA基础——单例模式

1.介绍单例模式之前我们先看什么是模式？
所谓模式就是一种规定好的范例，用白话讲就是套路，在java中遵循某个模式会让你的代码更加规范避免一些自己没有考虑到的错误。
2.再说什么是单例模式？
单例模式（singleton pattern）是java一种较为简单的设计模式，这中类的设计模式属于创建模式，它提供了一种创建对象的最佳方式，单例模式是指一个单一的类，该类负责自己创建对象，并确保只能创建出一个对象，并对外提供访问这个唯一的对象的方法。外部可以直接访问，而不需要再构造对象。
注意：
1.单例类只能由一个实例。
2.单例类必须自己创建这个实例。
3.必须给其他所有对象提供这一实例类。
单例模式大致上可以分为两种实现模式。
一、饿汉模式——在类加载时就创建对象，所以类加载过程慢，但调用速度快

/**
 * 单例模式-饿汉模式-一开始就构造一个对象，等着被调用。
 * 没有线程安全问题，天生线程安全，类的加载只有一次，对象只有一份，多线程只是调用了多次get方法。
 */
public  final class SingletonStarve {//final关键字修饰这个类，保证了该类不能再被继承，通过子类去构造对象。
    //定义一个引用，来指向这个类唯一对象的地址。
    //final 修饰保证了原子性
    private   static final SingletonStarve instance;

    //静态关键字 static 保证了它只能被new一次
    static {
        instance=new SingletonStarve();
    }

    //通过调用getInstance方法返回这个类的唯一对象
    public static SingletonStarve  getInstance(){
        return instance;
    }

    //防君子不妨小人，为了防止误用，把构造方法写为private
    private SingletonStarve() {

    }
}

调用饿汉模式的方法是

public class Main {
    public static void main(String[] args) {
        //正确的调用方法
        SingletonStarve right=SingletonStarve.getInstance();
        try {
            //反射方法也能拿到一个新的构造对象
            SingletonStarve error=SingletonStarve.class.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

实际上不论类内的属性是什么，public或者private…他们都是在编译时期的权限修饰符，而通过反射仍然可以创建一个新的对象。

二、懒汉模式——类加载时不进行初始化，第一次调用get方法时创建一个对象，以后不再创建新的对象。

/**
 * 单例模式-懒汉模式第一版-被调用才构造对象，第一次调用构造，以后不再构造
 * 存在线程安全问题
 */
public class SingletonLazy {
    //定义一个引用指向类唯一的instance对象的地址
    private static   SingletonLazy instance;

    //
    public static SingletonLazy getInstance(){
        if (instance==null){//如果指向的地址为空，那么是第一次创建，new一个 对象，不为空说明这个对象已经被创建。
            instance=new SingletonLazy();
        }
        return instance;//返回这个引用
    }

    //防止误调用而将构造方法设置为private
    private SingletonLazy() {
    }
}

这个版本的懒汉模式不是线程安全的。
典型的线程不安全的场景：
1.read and write 例如a=b,a++;
2.check and modify if（a）{ b };a和b看起来是立即执行但是实际上由于多线程的情况下，执行时可能发生了改变。
比如：

进入if语句判断instance为空，接着执行new语句，但是很有可能发生调度，再调度回来时，instance已经不为空了。所以也就是说如果想让他做到线程安全。需要保证判断和创建的过程的原子性。最简单就是加synchronized。

  public  synchronized static SingletonLazy getInstance(){
        if (instance==null){//如果指向的地址为空，那么是第一次创建，new一个 对象，不为空说明这个对象已经被创建。
            instance=new SingletonLazy();
        }
        return instance;//返回这个引用
    }

但是这种方法会造成抢锁，效率较低，可以通过二次判断，既保证了线程安全又保证了效率。

public  synchronized static SingletonLazy getInstance(){
        if (instance==null){
            synchronized (SingletonLazy.class){//instance可能为null也可能不是null
                if (instance==null)//因为锁的存在所以这里只会被执行一次。
                instance=new SingletonLazy();
            }//讨论第二个if不为null的情况，说明该线程在申请锁到申请成功这段时间内，已经有其他申请锁成功的线程实例化一次了，也就不需要再实例化了，直接返回就行了。

        }
        return instance;
    }

可能发生重排序。
如图这种情况，第三个线程可能会拿到instance为默认值的情况，此时的默认值是指instance对象的属性，比如String的name可能为null，int的age可能为o等情况，所以必须保证instance的内存可见性。

 private static  volatile   SingletonLazy instance;

完整代码：

public class SingletonLazy {
    //定义一个引用指向类唯一的instance对象的地址
    private static  volatile   SingletonLazy instance;

    //防止误调用而将构造方法设置为private
    private SingletonLazy() {
    }
    public  synchronized static SingletonLazy getInstance(){
        if (instance==null){
            synchronized (SingletonLazy.class){//instance可能为null也可能不是null
                if (instance==null)//因为锁的存在所以这里只会被执行一次。
                instance=new SingletonLazy();
            }//讨论第二个if不为null的情况，说明该线程在申请锁到申请成功这段时间内，已经有其他申请锁成功的线程实例化一次了，也就不需要再实例化了，直接返回就行了。

        }
        return instance;
    }
}

这就是常用的两种单例模式。