1. 饿汉模式
在类的内部构造这个类（通过构造函数，或者在定义处直接创建），并对外提供一个static getInstance方法提供获取该单例对象的途径。
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton() {
}
public static Singletonget Instance() {
return instance;
}
}
缺点：第一次加载类的时候会连带着创建Singleton实例。如果这个Singleton实例的创建非常消耗系统资源，而应用始终都没有使用Singleton实例，会消耗浪费系统资源。
2. 懒汉模式： 在使用的时候才去创建
public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
缺点： 多线程环境下会有问题。
3. 使用Class锁机制 给getInstance方法加上一个synchronize前缀，这样每次只允许一个现成调用getInstance方法：
public static synchronized Singleton getInstance() {
if (instance ==null) {
instance = newSingleton();
}
return instance;
}
缺点：影响性能，每次调用getInstance方法的时候都必须获得Singleton的锁，而实际上，当单例实例被创建以后，其后的请求没有必要再使用互斥机制了
4. 双重检查锁
public static Singleton getInstance() {
if (instance == null) {
synchronized(instance) {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
}
缺点：从JVM的角度讲，这些代码仍然可能发生错误， 可能因为指令重排序导致问题。
解释：对于JVM而言，它执行的是一个个Java指令。在Java指令中创建对象和赋值操作是分开进行的，
也就是说instance = new Singleton();语句是分两步执行的。但是JVM并不保证这两个操作的先后顺序，也就是说有可能JVM会为新的Singleton实例分配空间，然后直接赋值给instance成员，然后再去初始化这个Singleton实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例：
1). A、B线程同时进入了第一个if判断
2). A首先进入synchronized块，由于instance为null，所以它执行instance = new Singleton();
3). 由于JVM内部的优化机制，JVM先画出了一些分配给Singleton实例的空白内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
4). B进入synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调用该方法的程序。
5). 此时B线程打算使用Singleton实例，却发现它没有被初始化，于是错误发生了。
为了实现慢加载，并且不希望每次调用getInstance时都必须互斥执行，最好并且最方便的解决办法如下：（通过内部类实现多线程环境中的单例模式）
5. 通过关键字volatile，防止指令重排序，将实例变量声明为volatile：
private static volatile Singleton instance;
public static Singleton getInstance(){
if (instance == null) {
synchronized(instance) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
6. 利用jvm内部类加载机制。
public class Singleton {
private Singleton() {}
private static class SingletonContainer {
private static Singleton instance = new Singleton();
}
public static Singleton getInstance() {
return SingletonContainer.instance;
}
}
JVM内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的。这样当我们第一次调用getInstance的时候，JVM能够帮我们保证instance只被创建一次，并且会保证把赋值给instance的内存初始化完毕。
此外该方法也只会在第一次调用的时候使用互斥机制，这样就解决了低效问题(PS:1)。最后instance是在第一次加载SingletonContainer类时被创建的，而SingletonContainer类则在调用getInstance方法的时候才会被加载，因此也实现了惰性加载。
网友评论