单例

java中单例设计模式（学习笔记）

饿汉式

在类加载时就完成了初始化，获取对象的速度快，但是类加载较慢。

public class Hungry {
//    private byte[] data1 = new byte[1024*1024];
//    private byte[] data2 = new byte[1024*1024];
//    private byte[] data3 = new byte[1024*1024];
//    private byte[] data4 = new byte[1024*1024];
    private Hungry() {
    }
    private static Hungry HUNGRY = new Hungry();

    public Hungry getInstance() {
        return HUNGRY;
    }
}

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

懒汉式

单例实例在第一次被使用时构建，延迟初始化。

public class LazyMan {

    private LazyMan() {
        System.out.println(Thread.currentThread().getName()+"aaa");
    }
    private  static LazyMan lazyMan;

    public static LazyMan getInstance(){
        if(lazyMan==null) {
            return lazyMan = new LazyMan();
        }
        return lazyMan;
    }
}

打印的结果是true，但是在多线程中是有问题的，例如我们在main方法下写下一下程序

在getInstance方法中加锁和双重检测后

 public static LazyMan getInstance(){
        if(lazyMan==null) {
            synchronized (LazyMan.class){
                if(lazyMan==null) {
                    return lazyMan = new LazyMan();
                }
            }
        }
        return lazyMan;
    }

再次打印

但是lazyMan.getInstance();这个方法并不是一个原子性的操作
执行顺序
1.分配内存空间
2.执行构造方法，初始化对象
3.将对象指向该空间
执行顺序可能是123，也有可能是132，假设a线程先执行132，那么b线程再进来此时a已经执行到3，b发现内存已经被占用，认为对象已经被初始化，事实上还没有被初始化，那么我们就需要在

private static LazyMan lazyMan;

中加入关键字volatile

private volatile static LazyMan lazyMan;

反射

用反射在创建对象

还是创建了两个对象，在构造中加入判断

如果两个对象都用反射创建

继续在构造中改造