Java单例模式：懒加载（延迟加载）和即时加载
引⾔
在开发中，如果某个实例的创建需要消耗很多系统资源，那么我们通常会使⽤惰性加载机制（或懒加载、延时加载），也就是说只有当使⽤到这个实例的时候才会创建这个实例，这个好处在单例模式中得到了⼴泛应⽤。这个机制在单线程环境下的实现⾮常简单，然⽽在多线程环境下却存在隐患。
1、单例模式的惰性加载
通常当我们设计⼀个单例类的时候，会在类的内部构造这个类（通过构造函数，或者在定义处直接创建），并对外提供⼀个static getInstance() ⽅法提供获取该单例对象的途径。
public class Singleton
{
private static Singleton instance = new Singleton();
private Singleton(){
…
}
public static Singleton getInstance(){
return instance;
}
}
这样的代码缺点是：第⼀次加载类的时候会连带着创建 Singleton 实例，这样的结果与我们所期望的不同，因为创建实例的时候可能并不是我们需要这个实例的时候。同时如果这个Singleton 实例的创建⾮常消耗系统资源，⽽应⽤始终都没有使⽤ Singleton 实例，那么创建Singleton 消耗的系统资源就被⽩⽩浪费了。
为了避免这种情况，我们通常使⽤惰性加载的机制，也就是在使⽤的时候才去创建。
public class Singleton{
private static Singleton instance = null;
private Singleton(){
…
}
public static Singleton getInstance(){
if (instance == null)
instance = new Singleton();
return instance;
}
}
2、惰性加载在多线程中的问题
先将惰性加载的代码提取出来：
public static Singleton getInstance(){
if (instance == null)
instance = new Singleton();
return instance;
java单例模式双重锁}
这是如果两个线程 A 和 B 同时执⾏了该⽅法，然后以如下⽅式执⾏：
A 进⼊ if 判断，此时 foo 为 null，因此进⼊ if 内
B 进⼊ if 判断，此时 A 还没有创建 foo，因此 foo 也为 null，因此 B 也进⼊ if 内
A 创建了⼀个 Foo 并返回
B 也创建了⼀个 Foo 并返回
此时问题出现了，我们的单例被创建了两次，⽽这并不是我们所期望的。
3. 各种解决⽅案及其存在的问题
3.1 使⽤ Class 锁机制
以上问题最直观的解决办法就是给 getInstance ⽅法加上⼀个 synchronize 前缀，这样每次只允许⼀个现成调⽤ getInstance ⽅法：
public static synchronized Singleton getInstance(){
if (instance == null)
instance = new Singleton();
return instance;
}
这种解决办法的确可以防⽌错误的出现，但是它却很影响性能：每次调⽤ getInstance ⽅法的时候都必须获得 Singleton 的锁，⽽实际上，
当单例实例被创建以后，其后的请求没有必要再使⽤互斥机制了
3.2 double-checked locking
曾经有⼈为了解决以上问题，提出了 double-checked locking 的解决⽅案
public static Singleton getInstance(){
if (instance == null)
synchronized(instance){
if(instance == null)
instance = new Singleton();
}
return instance;
}
让我们来看⼀下这个代码是如何⼯作的：⾸先当⼀个线程发出请求后，会先检查 instance 是否为null，
如果不是则直接返回其内容，这样避免了进⼊ synchronized 块所需要花费的资源。其次，即使第2节提到的情况发⽣了，两个线程同时进⼊了第⼀个 if 判断，那么他们也必须按照顺序执⾏ synchronized 块中的代码，第⼀个进⼊代码块的线程会创建⼀个新的Singleton实例，⽽后续的线程则因为⽆法通过if判断，⽽不会创建多余的实例。
上述描述似乎已经解决了我们⾯临的所有问题，但实际上，从 JVM 的⾓度讲，这些代码仍然可能发⽣错误。
对于 JVM ⽽⾔，它执⾏的是⼀个个 Java 指令。在 Java 指令中创建对象和赋值操作是分开进⾏的，也就是说instance = new Singleton()；语句是分两步执⾏的。但是 JVM 并不保证这两个操作的先后顺序，也就是说有可能 JVM 会为新的 Singleton 实例分配空间，然后直接赋值给instance 成员，然后再去初始化这个 Singleton 实例。这样就使出错成为了可能，我们仍然以A、B两个线程为例：
A、B线程同时进⼊了第⼀个if判断
A⾸先进⼊synchronized块，由于instance为null，所以它执⾏instance = new Singleton();
由于JVM内部的优化机制，JVM先画出了⼀些分配给Singleton实例的空⽩内存，并赋值给instance成员（注意此时JVM没有开始初始化这个实例），然后A离开了synchronized块。
B进⼊synchronized块，由于instance此时不是null，因此它马上离开了synchronized块并将结果返回给调⽤该⽅法的程序。
此时B线程打算使⽤Singleton实例，却发现它没有被初始化，于是错误发⽣了。
4. 通过内部类实现多线程环境中的单例模式
为了实现慢加载，并且不希望每次调⽤ getInstance 时都必须互斥执⾏，最好并且最⽅便的解决办法如下：
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的内存初始化完毕，这样我们就不⽤担⼼3.2中的问题。此外该⽅法也只会在第⼀次调⽤的时候使⽤互斥机制，这样就解决了3.1中的低效问题。
最后 instance 是在第⼀次加载 SingletonContainer 类时被创建的，⽽ SingletonContainer 类则在调⽤ getInstance ⽅法的时候才会被加载，因此也实现了惰性加载。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。