面试之手写单例模式

当我们获得对象的时候，每次获得的都是同一个对象，所以我们可以先创建好一个实例，然后写一个get()方法，每次创建的时候，通过get()方法获取该实例，就达到了单例效果，需要注意：我们要有私有构造方法，以免外面new对象。这就是饿汉模式，顾名思义，因为在获取对象前就创建好了，感觉‘很饿’。

第一种

public class Singleton {
    private static Singleton instance=new Singleton();

    private Singleton(){

    }
    public static Singleton getInstance(){
        return instance;
    }
}

第二种：懒汉模式，上述的的模式存在一个弊端，对象都还没用到，就已经被创建构建了，浪费资源。于是改为:当用到的时候，判断instance是否为null,如果是，那我们就创建对象，否则就直接retrun。

第二种

public class Singleton {
    private static Singleton instance;
    private Singleton(){

    }
    public static Singleton getInstance(){
       if(instance==null){
           instance = new Singleton();
       }
       return instance;
    }
}

上述的写法其实存在线程安全的问题，当有多个线程调用getInstance()时，第一个线程进入if判断为null，还没来得及创建对象的时候，第二个线程也进入了if,判断为null，于是就会创建多个对象，无法达到单例模式，于是引入锁，也就是synchronized.

第三种

public class Singleton {
    private static Singleton instance;
    
    private Singleton(){}
    
    public static synchronized Singleton getInstance(){
       if(instance==null){
           instance = new Singleton();
       }
       return instance;
    }
}

上述写法有效的解决了线程安全问题，但是这个锁，锁的是方法，范围太大，我们只需要锁住出现线程安全的部分就够了。

第四种

public class Singleton {
    private static Singleton instance;

    private Singleton(){}

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

这样一来，只锁住了new的那部分，当线程来的时候，先判断instance是否为空，为空就上锁，不为空就return，但问题又来了，当多线程来临时，第一个instance判断为空，进入锁，还没来得及创建对象，第二个线程也来了判断instance也为空，当第一个线程走了之后，第二个线程也加入了锁，执行了new，还是会产生两个对象。于是，终极版来了：

第五种

public class Singleton {
    private static Singleton instance;

    private Singleton(){}

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

这样一来，再多线程的时候，当第二个线程进入了if,但是当第一个if执行完毕后，其他线程就算进锁，也无法通过第二个if判断。