单例模式的八种写法

1、饿汉式（静态常量）（线程安全）

public class Singleton {

    private final static Singleton INSTANCE = new Singleton();

    private Singleton(){}

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

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

2、饿汉式（静态代码块）（线程安全）

public class Singleton {

    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

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

这种方式和上面的方式类似，只不过将类实例化的过程放在了静态代码块中，也是在类装载的时候，就执行静态代码块中的代码，初始化类的实例。

3、懒汉式(线程不安全)

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

 

4、懒汉式(线程安全，同步方法)

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

说明：synchronized 将getInstance() 进行了线程同步，执行效率低下

5、懒汉式(线程不安全，同步代码块)

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

说明：当多个线程同时到达且均执行了if (singleton == null)判断语句时，便会创建多个实例。

6、双重检查（线程不安全）

public class Singleton {

    private static Singleton singleton;

    private Singleton() {}

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

说明：new操作不具有原子性，可能因指令重排导致singleton 引用指向了空间地址，但对象不存在。

分析：

new编译后的伪代码表示：

alloc = allocat(); // 分配内存地址 #1
constructor(alloc); // 执行构造函数，创建对象 #2
singleton = alloc;  //引用指向 #3

指令重排后表示

alloc = allocat(); // 分配内存地址 #1
singleton = alloc ;  //引用指向 #3  当第一个线程执行到这里时，由于线程调度，并未执行下面的对象创建指令，此时恰好有其他线程调用getInstance()，而singleton引用已不为null，就会返回没有对象的地址引用，使用时引发对象不存在异常
constructor(alloc ); // 执行构造函数，创建对象 #2

7、双重检查+volatile （线程安全）

public class Singleton {

    private static volatile Singleton singleton;

    private Singleton() {}

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

说明：volatile 关键字阻止了使用singleton代码行前后的指令重排

优点：线程安全；延迟加载；效率较高。

8、静态内部类（线程安全）

public class Singleton {

    private Singleton() {}

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

说明：这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

9、枚举（线程安全）

public enum Singleton {
    INSTANCE;
    public void whateverMethod() {

    }
}

说明：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

优点：系统内存中该类只存在一个对象，节省了系统资源，对于一些需要频繁创建销毁的对象，使用单例模式可以提高系统性能。

枚举单例示例：获取数据库连接。

public enum DataSourceEnum {     DATASOURCE;     private DBConnection connection = null;     private DataSourceEnum() {         connection = new DBConnection();     }     public DBConnection getConnection() {         return connection;     }
}   public class DBConnection {}

public class Main {     public static void main(String[] args) {         DBConnection con1 = DataSourceEnum.DATASOURCE.getConnection();         DBConnection con2 = DataSourceEnum.DATASOURCE.getConnection();          System.out.println(con1 == con2);     }
}