人们需要了解如何在
Java程序中使用懒惰实例化和急切实例化。那么，哪种方法更好？这取决于场景。
当实例化在资源使用方面开销很大的Java对象时，用户不希望每次使用它们时都必须进行实例化。对于提高性能来说，拥有一个可以在整个系统中共享的现成对象实例要好得多。在这种情况下，懒惰实例化策略非常有效。
懒惰实例化也有一些缺点，而在某些系统中，采用急切实例化方法更好。在急切实例化中，通常在应用程序启动后立即实例化对象一次。这两种方法是不同的。而在某些情况下，某种方法最有效。
本文将介绍这两种实例化Java对象的方法。首先看到代码示例，然后用Java代码挑战
测试所学到的内容。此外，还将讨论懒惰实例化与急切实例化的优缺点。
1.懒惰实例化的简单方法
首先，了解创建单个实例并在系统中共享它的简单方法：
public static HeroesDB heroesDB; // #A
private SingletonNaiveApproach() {} // #B
public HeroesDB getHeroesDB() { // #C
if (heroesDB == null) { // #D
heroesDB = new HeroesDB(); // #E
}
return heroesDB; // #F
}
static class HeroesDB { }
}
下面是代码中发生的情况：
开始(#A)，声明一个静态内部类HeroesDB。将变量声明为静态的变量，它可以在应用程序中共享。
下一步(#B)，创建一个私有构造函数，以避免从类外部直接实例化。因此，必须使用getHeroes()方法来获取一个实例。
在下一行(#C)，看到了有效地从HeroesDB返回实例的方法。
接下来(#D)，检查heroesDB实例是否为空。如果是空，将创建一个新实例。否则什么也不做。
最后(#F)，返回heroesDB对象实例。
这种方法适用于小型应用程序。然而，在有许多用户的大型多线程应用程序中，很可能会出现数据冲突。在这种情况下，对象可能会被多次实例化，即使检查是否为空。以下进一步探讨为什么会发生这种情况的原因。
2.理解竞态条件
竞态条件是指两个或多个线程并发竞争同一个变量的情况，这可能会导致意外的结果。
在大型多线程应用程序中，许多进程并行并发地运行。在这种类型的应用程序中，有可能在另一个线程实例化一个空对象的同时，一个线程正在询问一个对象是否为空。在这种情况下，有一个竞态条件，这可能导致重复的实例。
可以通过使用synchronized关键字来修复这个问题：
public class SingletonSynchronizedApproach {
public static HeroesDB heroesDB;
private SingletonSynchronizedApproach() {}
public synchronized HeroesDB getHeroesDB() {
if (heroesDB == null) {
heroesDB = new HeroesDB();
}
return heroesDB;
}
static class HeroesDB { }
}
这段代码解决了线程在getHeroesDB（）中存在冲突的问题。然而正在同步整个方法。这可能会影响性能，因为每次只有一个线程能够访问整个方法。
以下看看如何解决这个问题。
3.优化的多线程懒惰实例化
要同步getHeroesDB（）方法中的策略点，需要在该方法中创建同步块。以下是一个例子：
public class ThreadSafeSynchronized {
public static volatile HeroesDB heroesDB;
public static HeroesDB getHeroesDB() {
if(heroesDB == null) {
synchronized (ThreadSafeSynchronized.class) {
if(heroesDB == null) {
heroesDB = new HeroesDB();
}
}
}
return heroesDB;
}
static class HeroesDB { }
}
在这段代码中，只在实例为空时同步对象的创建。否则，将返回对象实例。
还要注意的是，同步了ThreadSafeSynchronized类，因为使用的是静态方法。然后再次检查，以确保heroesDB实例仍然为空，因为可能有另一个线程已将其实例化。如果不进行双重检查，可能会得到多个实例。
另一个重要的问题是，变量heroesDB是不稳定的。这意味着不会缓存变量的值。当线程更改这一变量时，它将始终具有最新更新的值。
4.何时使用急切实例化
对于可能从未使用过的开销大的对象，最好使用懒惰实例化。然而，如果所处理的对象知道在应用程序每次启动时都将被使用，并且就使用的系统资源来说，如果创建对象开销很大，那么最好使用急切实例化。
假设必须创建一个开销非常大的对象，例如人们总是需要的
数据库连接。等待该对象被使用可能会降低应用程序的运行速度。在这种情况下，急切实例化更有意义。
5.实现急切实例化的简单方法
实现急切实例化的简单方法如下：
public class HeroesDatabaseSimpleEager {
public static final HeroesDB heroesDB = new HeroesDB();
static HeroesDB getHeroesDB() {
return heroesDB;
}
static class HeroesDB {
private HeroesDB() {
System.out.println("Instantiating heroesDB eagerly...");
}
@Override
public String toString() {
return "HeroesDB instance";
}
}
public static void main(String[] args) {
System.out.println(HeroesDatabaseSimpleEager.getHeroesDB());
}
}
The output from this code would be:
Instantiating heroesDB eagerly...
HeroesDB instance
这段代码的输出是：
Instantiating heroesDB eagerly...
HeroesDB instance
注意，在本例中没有进行是为空的检查。当HeroesDB被声明为HeroesDatabaseSimpleEager中的实例变量时，它就被实例化了。因此，每次访问HeroesDatabaseSimpleEager类时，都会从HeroesDB获得一个实例。还重写了toString()方法，以简化HeroesDB实例的输出。
现在看看使用枚举实现急切实例化的更健壮的方法。
6.使用枚举创建急切实例化
使用枚举是创建急切实例化对象的一种更健壮的方法。尽管实例只会在枚举被访问时被创建，但要注意在下面的代码中，没有对对象创建进行是否为空的检查：
public enum HeroesDatabaseEnum {
INSTANCE;
int value;
public int getValue() {
return value;
}
public void setValue(int value) {
this.value = value;
}
public static void main(String[] args) {
System.out.println(HeroesDatabaseEnum.INSTANCE);
}
这段代码的输出将是:
Creating instance...
INSTANCE
这段代码是线程安全的。它保证只创建一个实例，并且序列化对象，这意味着可以更容易地传输它。另一个细节是，对于枚举有一个隐式的私有构造函数，这保证了不会不必要地创建多个实例。枚举被认为是使用急切实例化的最佳方法之一，因为它简单而有效。
7.懒惰实例化vs.急切实例化
当不总是需要实例化一个对象时，采用懒惰实例化更好。当知道总是需要实例化对象时，急切实例化更好。以下是每种方法的优缺点：
（1）懒惰实例化
优点：对象只会在需要的时候被实例化。
缺点：
需要同步才能在多线程环境中工作。
由于if检查和同步，性能会变慢。
当需要该对象时，应用程序可能会有明显的懒惰。
（2）急切实例化
优点：
在大多数情况下，对象将在应用程序启动时被实例化。
使用对象时没有延迟，因为它已经被实例化了。
它在多线程环境中工作良好。
缺点：使用这种方法可能会不必要地实例化对象。
8.Lazy Homer beer创作挑战
在下面的Java代码挑战中，将看到多线程环境中发生的懒惰实例化。
要注意的是，正在使用ThreadPool可以直接使用Thread类，但最好使用Java并发API。
根据在本文中学到的知识，人们会认为在运行以下代码时最可能发生什么情况?
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
public class LazyHomerBeerCreationChallenge {
public static int i = 0;
public static Beer beer;
static void createBeer() {
if (beer == null) {
try {
Thread.sleep(200);
beer = new Beer();
i++;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) throws InterruptedException {
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.submit(LazyHomerChallenge::createBeer);
executor.submit(LazyHomerChallenge::createBeer);
executor.awaitTermination(2, TimeUnit.SECONDS);
executor.shutdown();
System.out.println(i);
}
public static class Beer {}
}
以下是应对这一挑战的选项。仔细查看代码并选择其中一个：
1.A) 1
2.B) 0
3.C) 2
4.D)抛出InterruptedException
9.发生了什么?懒惰实例化解释
这个代码挑战的关键概念是，当两个线程访问同一个进程时，会出现并行性。因此，既然有一个线程。在实例化beer之前休眠，很可能会创建两个beer实例。
线程不并发运行的可能性非常小，这取决于JVM实现。但是由于线程的原因，很有可能最终得到两个Thread.sleep的方法。
现在再次查看代码，注意正在使用线程池创建两个线程，然后对这些线程运行createBear方法。
因此，这个代码挑战的正确答案是：C，或2的值。
10.结论
对于使用开销大的对象优化性能来说，懒惰实例化和急切实例化是很重要的概念。以下是关于这些设计策略需要记住的要点：
懒惰实例化需要在实例化之前进行是否为空的检查。
在多线程环境中同步对象以实现懒惰实例化。
急切实例化不需要对对象进行是否为空的检查。
使用枚举是一种有效且简单的紧急实例化方法。
