单例模式的两种方式

设计模式就是一个思想，代码只是个表现性而已，就好比我们吃饭，都知道用筷子，但是筷子只是一个表现的形式而已，我们的思想是：只要是组合起来，能夹起来东西就可以了，所以我们用两根树枝，也可以吃饭，这个时候的表现形式就变成了树枝了

单例设计模式：解决一个类在内存只存在一个对象

想要保证唯一：

1. 为了避免其他的程序过多的建立该类的对象，先禁止其他程序建立类对象
2. 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象
3. 为了方便其他程序对自定义的对象的访问，可以对外提供一些访问方式

三个步骤对应的实现思想

1. 将构造函数私有化
2. 在类中创建一个本类对象
3. 提供一个方法可以获取该对象

饿汉式

对象是先初始化的，在类加载时，就初始化了，类一进内存，就已经从创建好了，即

private static Single s = new Single();

在这里，一个静态变量，类加载时创建了对象

class Single {

    private int sin;

    private Single(){}

    private static Single s = new Single();

    public static Single getInstance(){
        return s;
    }

    public int getSin(){
        return sin;
    }

    public void setSin(int sin){
        this.sin = sin;
    }
}

public class Test {

    public static void main(String[] args) {
        Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        s1.setSin(10);
        System.out.println(s2.getSin());
    }
}

由结果我们已经看到了，s1和s2操作的是一个对象，即该类在内存只存在一个对象，都是之前类加载时创建的静态变量

懒汉式

对象是方法被调用时，才初始化，也叫做对象的延时加载，类进内存对象好没有存在，只有调用了getInstance()方法时，才创建了对象

class Single {

    private int sin;

    private Single(){}

    private static Single s = null;

    public static Single getInstance(){
        if(s == null){
            s = new Single();
        }
        return s;
    }

    public int getSin(){
        return sin;
    }

    public void setSin(int sin){
        this.sin = sin;
    }
}

public class Test {

    public static void main(String[] args) {
        Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        s1.setSin(10);
        System.out.println(s2.getSin());
    }
}

这个和上面的区别别就，对象只有在调用时，才会被创建，先判断是否是空的，如果是，则创建第一个对象，如果不是，则直接返回前面已经创建的静态变量，这样达到只有一个类在内存只存在一个对象的目的

懒汉式和饿汉式的比较

在实际开发中，我们应该尽量使用的是饿汉式，虽然说懒汉式是在使用时才加载，可以节省一点内存，但是，当只有一个客户访问时，懒汉式确实没什么毛病，但是如果时并发呢？

public static Single getInstance(){
        if(s == null){	
        	//注释1
        	//注释2
            s = new Single();
        }
        return s;
    }

当并发时，我们的第一个访问的先调用getInstance()，这个时候判断是否是null是，是空的，所以加入 if 里面去，但是CPU执行到注释1时，CPU进行上下文的切换，即这个时候，第二个访问来了，他也调用getInstance()方法，也进行判断，因为上一个才执行到，注解1的地方，还并没有实例化，所以这个时候他还是null所以它也加入 if ,这个时候就完蛋了呀，就会new两次，就没有达到单例模式一个类在内存只存在一个对象的目的，所以是危险的，而且也不能对getInstance（）方法加锁synchronized，因为这个一旦加上，就大大的让程序执行效率就降低了，所以一般我们都用饿汉式