建站
咨詢
售后
建站咨詢
新聞中心
?譯者 | 李睿
審校 | 孫淑娟
人們需要了解如何在Java程序中使用懶惰實例化和急切實例化。那么，哪種方法更好？這取決于場景。
當(dāng)實例化在資源使用方面開銷很大的Java對象時，用戶不希望每次使用它們時都必須進行實例化。對于提高性能來說，擁有一個可以在整個系統(tǒng)中共享的現(xiàn)成對象實例要好得多。在這種情況下，懶惰實例化策略非常有效。
懶惰實例化也有一些缺點，而在某些系統(tǒng)中，采用急切實例化方法更好。在急切實例化中，通常在應(yīng)用程序啟動后立即實例化對象一次。這兩種方法是不同的。而在某些情況下，某種方法最有效。
本文將介紹這兩種實例化Java對象的方法。首先看到代碼示例，然后用Java代碼挑戰(zhàn)測試所學(xué)到的內(nèi)容。此外，還將討論懶惰實例化與急切實例化的優(yōu)缺點。
1.懶惰實例化的簡單方法
首先，了解創(chuàng)建單個實例并在系統(tǒng)中共享它的簡單方法：
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 { }
}
下面是代碼中發(fā)生的情況：
開始(#A)，聲明一個靜態(tài)內(nèi)部類HeroesDB。將變量聲明為靜態(tài)的變量，它可以在應(yīng)用程序中共享。
下一步(#B)，創(chuàng)建一個私有構(gòu)造函數(shù)，以避免從類外部直接實例化。因此，必須使用getHeroes()方法來獲取一個實例。
在下一行(#C)，看到了有效地從HeroesDB返回實例的方法。
接下來(#D)，檢查heroesDB實例是否為空。如果是空，將創(chuàng)建一個新實例。否則什么也不做。
最后(#F)，返回heroesDB對象實例。
這種方法適用于小型應(yīng)用程序。然而，在有許多用戶的大型多線程應(yīng)用程序中，很可能會出現(xiàn)數(shù)據(jù)沖突。在這種情況下，對象可能會被多次實例化，即使檢查是否為空。以下進一步探討為什么會發(fā)生這種情況的原因。
2.理解競態(tài)條件
競態(tài)條件是指兩個或多個線程并發(fā)競爭同一個變量的情況，這可能會導(dǎo)致意外的結(jié)果。
在大型多線程應(yīng)用程序中，許多進程并行并發(fā)地運行。在這種類型的應(yīng)用程序中，有可能在另一個線程實例化一個空對象的同時，一個線程正在詢問一個對象是否為空。在這種情況下，有一個競態(tài)條件，這可能導(dǎo)致重復(fù)的實例。
可以通過使用synchronized關(guān)鍵字來修復(fù)這個問題：
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.優(yōu)化的多線程懶惰實例化
要同步getHeroesDB（）方法中的策略點，需要在該方法中創(chuàng)建同步塊。以下是一個例子：
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 { }
}左右滑動查看完整代碼
在這段代碼中，只在實例為空時同步對象的創(chuàng)建。否則，將返回對象實例。
還要注意的是，同步了ThreadSafeSynchronized類，因為使用的是靜態(tài)方法。然后再次檢查，以確保heroesDB實例仍然為空，因為可能有另一個線程已將其實例化。如果不進行雙重檢查，可能會得到多個實例。
另一個重要的問題是，變量heroesDB是不穩(wěn)定的。這意味著不會緩存變量的值。當(dāng)線程更改這一變量時，它將始終具有最新更新的值。
4.何時使用急切實例化
對于可能從未使用過的開銷大的對象，最好使用懶惰實例化。然而，如果所處理的對象知道在應(yīng)用程序每次啟動時都將被使用，并且就使用的系統(tǒng)資源來說，如果創(chuàng)建對象開銷很大，那么最好使用急切實例化。
假設(shè)必須創(chuàng)建一個開銷非常大的對象，例如人們總是需要的數(shù)據(jù)庫連接。等待該對象被使用可能會降低應(yīng)用程序的運行速度。在這種情況下，急切實例化更有意義。
5.實現(xiàn)急切實例化的簡單方法
實現(xiàn)急切實例化的簡單方法如下：
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
注意，在本例中沒有進行是為空的檢查。當(dāng)HeroesDB被聲明為HeroesDatabaseSimpleEager中的實例變量時，它就被實例化了。因此，每次訪問HeroesDatabaseSimpleEager類時，都會從HeroesDB獲得一個實例。還重寫了toString()方法，以簡化HeroesDB實例的輸出。
現(xiàn)在看看使用枚舉實現(xiàn)急切實例化的更健壯的方法。
6.使用枚舉創(chuàng)建急切實例化
使用枚舉是創(chuàng)建急切實例化對象的一種更健壯的方法。盡管實例只會在枚舉被訪問時被創(chuàng)建，但要注意在下面的代碼中，沒有對對象創(chuàng)建進行是否為空的檢查：
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
這段代碼是線程安全的。它保證只創(chuàng)建一個實例，并且序列化對象，這意味著可以更容易地傳輸它。另一個細節(jié)是，對于枚舉有一個隱式的私有構(gòu)造函數(shù)，這保證了不會不必要地創(chuàng)建多個實例。枚舉被認(rèn)為是使用急切實例化的最佳方法之一，因為它簡單而有效。
7.懶惰實例化vs.急切實例化
當(dāng)不總是需要實例化一個對象時，采用懶惰實例化更好。當(dāng)知道總是需要實例化對象時，急切實例化更好。以下是每種方法的優(yōu)缺點：
（1）懶惰實例化
優(yōu)點：對象只會在需要的時候被實例化。
缺點：
- 需要同步才能在多線程環(huán)境中工作。
- 由于if檢查和同步，性能會變慢。
- 當(dāng)需要該對象時，應(yīng)用程序可能會有明顯的懶惰。
（2）急切實例化
優(yōu)點：
- 在大多數(shù)情況下，對象將在應(yīng)用程序啟動時被實例化。
- 使用對象時沒有延遲，因為它已經(jīng)被實例化了。
- 它在多線程環(huán)境中工作良好。
缺點：使用這種方法可能會不必要地實例化對象。
8.Lazy Homer beer創(chuàng)作挑戰(zhàn)
在下面的Java代碼挑戰(zhàn)中，將看到多線程環(huán)境中發(fā)生的懶惰實例化。
要注意的是，正在使用ThreadPool可以直接使用Thread類，但最好使用Java并發(fā)API。
根據(jù)在本文中學(xué)到的知識，人們會認(rèn)為在運行以下代碼時最可能發(fā)生什么情況?
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 {}
}
以下是應(yīng)對這一挑戰(zhàn)的選項。仔細查看代碼并選擇其中一個：
1.A) 1
2.B) 0
3.C) 2
4.D)拋出InterruptedException
9.發(fā)生了什么?懶惰實例化解釋
這個代碼挑戰(zhàn)的關(guān)鍵概念是，當(dāng)兩個線程訪問同一個進程時，會出現(xiàn)并行性。因此，既然有一個線程。在實例化beer之前休眠，很可能會創(chuàng)建兩個beer實例。
線程不并發(fā)運行的可能性非常小，這取決于JVM實現(xiàn)。但是由于線程的原因，很有可能最終得到兩個Thread.sleep的方法。
現(xiàn)在再次查看代碼，注意正在使用線程池創(chuàng)建兩個線程，然后對這些線程運行createBear方法。
因此，這個代碼挑戰(zhàn)的正確答案是：C，或2的值。
10.結(jié)論
對于使用開銷大的對象優(yōu)化性能來說，懶惰實例化和急切實例化是很重要的概念。以下是關(guān)于這些設(shè)計策略需要記住的要點：
- 懶惰實例化需要在實例化之前進行是否為空的檢查。
- 在多線程環(huán)境中同步對象以實現(xiàn)懶惰實例化。
- 急切實例化不需要對對象進行是否為空的檢查。
- 使用枚舉是一種有效且簡單的緊急實例化方法。
原文鏈接：https://www.infoworld.com/article/3675954/lazy-vs-eager-instantiation-in-java-which-is-better.htm
當(dāng)前名稱：Java中的懶惰實例化與急切實例化：哪個更好？
文章路徑：http://fisionsoft.com.cn/article/dpeejoc.html
