单例模式

1、懒汉式

     懒汉式实现代码：

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

懒汉式在方法调用的时候才会加载，实现了延时加载，但由于通过加锁实现线程安全，效率较低。

2、饿汉式

     懒汉式实现代码：

class Singleton1{
    private static Singleton1 singleton1 = new Singleton1();
    private Singleton1(){}
    public static Singleton1 getInstance() {
        return singleton1;
    }
}

饿汉式在类加载的时候就会创建对象存入内存中，所以是线程安全的，但是也正是这样导致会浪费内存空间。

3、双重检查模式

     双重检查模式其实类似于懒汉式，代码如下：

class Singleton4{
    private static Singleton4 singleton4 = null;
    public static Singleton4 getInstance(){
        if (singleton4 == null) {
            synchronized (Singleton4.class) {
                if (singleton4 == null) {
                    singleton4 = new Singleton4();
                }
            }
        }
        return singleton4;
    }
}

这里锁是在代码块中，而不是在方法上，所以需要检查两次，这个同样实现了延时加载，线程安全，但是效率较低。

4、静态内部类

     静态内部类的代码如下：

class Singleton3{
    private static class Single3Class{
        private static final Singleton3 SINGLETON3 = new Singleton3();
    }
    private Singleton3(){}
    public static Singleton3 getInstance() {
        return Single3Class.SINGLETON3;
    }
}

静态内部类是目前来讲比较好的单例实现方式，只有在方法调用的时候内部类才会被类加载，类加载的时候会创建对象，所以也是线程安全的，并且也实现了延时加载，效率较高。