单例模式--有些类也需要计划生育

　　单例模式：保证一个类仅有一个实例，并提供一个访问他的全局访问点。
　　通常我们可以让一个全局变量使得一个对象被访问，但他不能防止你实例化多个对象，一个最好的办法就是，让类自身负责保存他的唯一实例。这个类可以保证没有其它实例可以被创建，并且它可以提供一个访问该实例的方法。

　　单例模式又可以分为---饿汉式和懒汉式。

懒汉式：

//单例模式---懒汉式 第一次被使用时，才会被实例化
public class Single {
    private static Single instance;
    
    //构造方法让其private,这就杜丝勒外界利用new创建此类实例的可能
    private Single(){}
    
    //此方法是获得本类实例的唯一全局访问点。返回该类的实例
    public static Single getInstance(){
        //若实例不存在，则new 一个新实例，否则返回已有的实例
        if(instance==null){
            instance = new Single();
        }
        return instance;
    }
}

测试类：

public class TestClient {
    public static void main(String[] args) {
        Single s1 = Single.getInstance();
        Single s2 = Single.getInstance();
        //比较两次实例化后对象的结果是实例相同
        if(s1==s2){
            System.out.println("两个对象是相同的实例");
        }else{
            System.out.println("不同");
        }
        //打印结果：两个对象是相同的实例
    }
}

饿汉式：

//单例模式---饿汉式  在自己被加载时就将自己实例化
public class Single2 {
    private static Single2 instance = new Single2();
    
    //构造方法让其private,这就杜绝外界利用new创建此类实例的可能
    private Single2(){}
    
    //此方法是获得本类实例的唯一全局访问点，返回该类的实例。静态方法
    public static Single2 getInstance(){
        return instance;
    }
}

测试类：

public class TestClient2 {
    public static void main(String[] args) {
        Single2 s1 = Single2.getInstance();
        Single2 s2 = Single2.getInstance();
        //比较两次实例化后对象的结果是实例相同
        if(s1==s2){
            System.out.println("两个对象是相同的实例");
        }else{
            System.out.println("不同");
        }
        //打印结果：两个对象是相同的实例
    }
}

=================================================多线程下的单例模式====================================================>>>>>

多线程下的单例模式：

//多线程时的单例
public class Singleton {
    private static Singleton instance;
    private static  Object syncRoot = new Object();
    
    //让构造方法私有，这就杜丝勒外界利用new创建此类实例的可能。不让外界通过new创建对象
    private Singleton(){}
    
    //静态方法
    public static Singleton getInstance(){
        //先判断实例是否存在，不存在再加锁处理
        if(instance==null){
            synchronized (syncRoot) {
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
    /**
     * 为什么在外面已经判断了instance实例是否存在，还要在synchronized里面做一次实例是否存在的判断呢？
     *     对于instance存在的情况，就直接返回，这没有问题。
     *  当instance为null并且同时又两个线程调用getInstance()方法时，他们都可以通过第一重instance==null的判断。然后由于synchronized机制，
     *      这两个线程则只有一个进入，另一个在外排队等候，必须要其中的一个进入并出来后，另一个才能进入。
     *          而此时如果没有了第二重的instance是否为null的判断，则第一个线程创建了实例，而第二个线程还是可以继续再创建新的实例，这个就没有达到单例的目的了。
     */
}