一般情况下一个类能否做成单例，就在于，这个类在整个应用中，同一时刻有且只有一种状态。

第一种单例模式的构造方式。

public class Singleton{
    //一个静态的实例
    private static Singleton singleton;

    //私有化构造函数
    private Singleton(){

    }

    //给出一个公共的静态方法返回一个单一的实例
    public static Singleton getInstance(){
        if(singleton == null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

当然上面给出的代码是在不考虑并发访问的情况下的一种单例模式，这种方式通过几个地方来限制了我们取到的实例是唯一的。

• 静态实例，带有static关键字的属性在每一个类中都是唯一的。

• 限制客户端随意创造实例，即私有化构造方法。

• 给一个公共的获取实例的静态方法，注意，是静态的方法，因为这个方法是在我们未获取到实例的时候就要提供给客户端调用的，所以如果是非静态的话，那就变成一个矛盾体了，因为非静态的方法必须要拥有实例才可以调用。

• 判断只有持有的静态实例为null时，才调用构造方法创造一个实例，否则就直接返回。

考虑并发时，我们最先想到的是直接将整个方法同步。

public class SynchronizedSingleton {
    //一个静态的实例
    private static SynchronizedSingleton synchronizedSingleton;
    //私有化构造函数
    private SynchronizedSingleton(){}
    //给出一个公共的静态方法返回一个单一的实例
    public synchronized static SynchronizedSingleton getInstance(){
    if(synchronizedSingleton == null){
        synchronizedSingleton = new SynchronizedSingleton();
    }
    return synchronizedSingleton;
    }
}

上面的做法很简单，就是将整个获取实例的方法同步，这样在一个线程访问这个方法时，其它所有的线程都要处于挂起等待状态，倒是避免了刚才同步访问创造出多个实例的危险，但是这样会造成很多无谓的等待，因此效率很低。

所以我们要对上面的代码做一个优化，代码如下所示：

public SynchronizedSingleton {
    //一个静态的实例
    private static SynchronizedSingleton synchronizedSingleton;
    //私有化构造函数
    private SynchronizedSingleton(){}
    //给出一个公共的静态方法返回一个单一的实例
    public static SynchronizedSingleton getInstance(){
        if(synchronizedSingleton == null){
            synchronized (SynchronizedSingleton.class){
                if(synchronizedSingleton == null){
                    synchronizedSingleton = new SynchronizedSingleton();
                }
            }
        }
        return synchronizedSingleton;
    }
}

当然上面的代码已经是比较完美的了，但是依然存在一些小问题，这个问题我也弄的不是很明白，就不在这个显摆了。
下面直接给出最终的单例模式的解决方案：

public class Singleton {

    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonInstance.instance;
    }
    //私有化的内部类
    private static class SingletonInstance{

        static Singleton instance = new Singleton();

    }
}

单例模式应该保证一下几点：

• Singleton最多只有一个实例，在不考虑反射强行突破访问限制的情况下。
• 保证了并发访问的情况下，不会发生由于并发而产生多个实例。
• 保证了并发访问的情况下，不会由于初始化动作未完全完成而造成使用了尚未正确初始化的实例。