java单例模式学习笔记

单例模式能保证无论你怎么new返回的都是同一个对象，会为我们节省很多内存开销和cpu使用率。这里引入两种经典的单例模式:饿汉式和懒汉式。
饿汉式，思想就是利用空间换取时间，把需要的数据开始就初始化放好，使用直接调用即可。因为数据在类加载的时候就初始化好了,所以也就不存在线程安全问题

public class Person {
    private static final Person SELF=new Person();
    private static int age=18;
    public static int getAge() {
        return age;
    }
    //调用只需要引用这个方法即可
    public static Person getInstance(){
        return SELF;
    }
    //方法一定要私有,单例模式下!!!
    private Person(){

    }
}

懒汉式,思想就是利用时间换取空间,使用时需要调用方法创建对象，存在线程安全隐患

public class Person {
    private static Person SELF;
    private int age=18;
    public int getAge() {
        return age;
    }
    public static Person getInstance(){
        if(SELF==null){
            SELF=new Person();
        }
        return SELF;
    }
    //方法一定要私有,单例模式下!!!
    private Person(){
    
    }
}

懒汉式线程安全问题是什么呢？那我们又如何解决呢？本文会给出一些思路
先来看看问题，首先利用sleep模拟线程问题，我们来看看结果


跑出来两个不同对象，显然不符合我们的预期

既然是线程安全嘛，那我们就上锁，并加上一些判断，但这样仍有一些问题。new Person并不具有原子性，可拆解成三步：分配内存空间，内存数据初始化,改变SELF的指向使得他指向内存空间。2,3步并不一定按顺序来，也可能是先改变指向，在初始化数据,也就是所谓的指令重排,这就导致了返回的对象具有不确定性，可能一个线程正在初始化数据，另一个线程直接返回指向进行操作，会出现一些莫名其妙的bug

所以我们最好再加一句volatile或者直接锁整个方法(但会降低效率)。

private static volatile Person SELF;

这样就大大提高了安全性，但安全也不是必然的，因为安全是建立在private权限上的，而反射就能突破这个限制，造成一些问题，解决方法也很简单，就是利用枚举,枚举里面封装了一些东西,保证了在反射场景下，也能加载同一个对象，并且线程安全,最重要的是,写法还简单！

public class  Person {
    private static enum PersonHolder{
        SINGLETON;
        private  Person person;
        PersonHolder(){
           person=new Person();
        }
        private Person getInstance(){
            return person;
        }
    }
    public Person getInstance(){
        return PersonHolder.SINGLETON.getInstance();
    }
    private Person(){

    }
}

public class Test {
    static class TestPersonThread extends Thread{
        @Override
        public void run() {
            Person.getInstance();;
        }
    }
    public static void main(String[] args) {
        new TestPersonThread().start();
        new TestPersonThread().start();

    }
}