JEP 531 - Lazy Constants, ճանապարհորդությունը շարունակվում է
Հայացք Java 27-ի JEP 531-ի Lazy Constants հնարավորությանը՝ API-ի փոփոխություններ, սխալների մշակում, lazy կոլեկցիաներ և հայտնի սահմանափակումներ։
Java 25-ը բերեց Stable Values անունով նոր հնարավորություն։ Այս գրառման մեջ կուսումնասիրենք JEP-531-ը՝ այդ հնարավորության երրորդ preview-ն, որը գալիս է Java 27-ի հետ։ Այն շարունակում է մնալ preview հնարավորություն, ուստի ամեն ինչ դեռ կարող է փոխվել։
JEP-526-ով Stable Values-ը վերածվեցին Lazy Constants-ի։ Իմ կարծիքով՝ այդ անունը շատ ավելի լավ է համապատասխանում ֆունկցիոնալությանը։
Այս հոդվածը վերանայվել է 2026 թվականի սեպտեմբերի 15-ին։
Ի՞նչ են Lazy Constants-ը
LazyConstant <T>-ը կոնտեյներ է, որը պահում է T տիպի մեկ արժեք։ Վերագրվելուց հետո այդ արժեքն այլևս չի կարող փոխվել։ Պատկերացրեք այն որպես eventually final (ի վերջո վերջնական) արժեք։ Կարևոր է նշել, որ անփոփոխ է դառնում օբյեկտի հղումը. հենց հիմքում ընկած օբյեկտը դեռ կարելի է փոփոխել։
Մինչև Lazy Constants
Java 25-ից առաջ անփոփոխ տվյալները պահանջում էին final հիմնաբառը։
class Controller {
private final EmailSender sender = new EmailSender();
}
Այդ մոտեցումը մի քանի խնդիր ուներ։
Մեր կոդի ցանկացած final դաշտ պետք է սահմանվի անհապաղ (eagerly)՝ կամ կոնստրուկտորում նախաստորագրվի, կամ հայտարարվի որպես static դաշտ։ Սա կարող է դանդաղեցնել հավելվածի գործարկումը։ Ի վերջո, ամեն դաշտ միանգամից պետք չէ, չէ՞։
Ուրեմն գուցե կարող ենք հանել final հիմնաբառը և գրել մոտավորապես այսպիսի բան.
class PetClinicController {
private EmailSender sender = null;
EmailSender getSender() {
if (sender == null) {
sender = new EmailSender();
}
return sender;
}
void adoptPet(User user, Pet pet) {
// some logic here
getSender().sendEmailTo(user, "You are great person!");
}
}
Սա կաշխատի, չէ՞։ Գործարկումը կդառնա ավելի արագ։ Եվ իսկապես, սա Java 25-ից առաջ խնդրին մոտենալու եղանակներից մեկն էր։ Ցավոք, դա գին ունի։
- Sender-ը մնում է փոփոխելի. փոփոխականին կարելի է այլ արժեք վերագրել։ Դա կանխելը կպահանջի արտաքին գործիքներ կամ շատ ուշադիր code review-ներ։
- Null pointer exception կարող է առաջանալ, եթե դաշտին դիմեն ոչ թե getter-ի միջոցով, այլ որևէ այլ եղանակով։
- Իդեալականում «getSender»-ը պետք է thread-safe լինի։
- Բայց նույնիսկ եթե այն դարձնենք այդպիսին, մենք JVM-ին թույլ չենք տալիս օպտիմալացնել այս դաշտին մուտքը՝ օրինակ, constant-folding-ով։
Եկեք օգտագործենք մի քանի Lazy Constants
Վերցնենք նախորդ օրինակը և տեղափոխենք նոր Java։
class PetClinicController {
private final LazyConstant<EmailSender> sender = LazyConstant.of(() -> new EmailSender());
EmailSender getSender() {
return sender.get();
}
void adoptPet(User user, Pet pet) {
// some logic here
getSender().sendEmailTo(user, "You are great person!");
}
}
Կոդը գրեթե նույնն է թվում, բայց այժմ LazyConstant-ը հոգ է տանում EmailSender-ի nullability-ի մասին։ Արդյունքում EmailSender-ը չի կարող կանչվել՝ առանց նախ արժեքը ստացող մեթոդ կանչելու։
LazyConstant-ի ներսում արժեքի սահմանումը երաշխավորված thread-safe է։
Ի՞նչ է փոխվել Java 27-ում
Java 26-ն արդեն LazyConstant-ը դարձրել էր զգալիորեն փոքր, քան Stable Values-ն էին նախկինում։ Java 27-ը շարունակում է API-ի կատարելագործումը։
Սխալների մշակում
Java 27-ում LazyConstant-ը այլ կերպ է վարվում, երբ հաշվարկող ֆունկցիան ձախողվում է։
Java 26-ում supplier-ի նետած բացառությունը փոխանցվում էր կանչողին, և LazyConstant-ը մնում էր չնախաստորագրված։ Հետևաբար get()-ի հետագա կանչը կարող էր նորից փորձել հաշվել արժեքը։
var count = new AtomicInteger();
var value = LazyConstant.of(() -> {
if (count.getAndIncrement() == 0) {
throw new RuntimeException("Boom!");
}
return "Hello!";
});
Java 26
value.get(); // throws NoSuchElementException
value.get(); // "HELLO!" - computation is retried
Java 27
value.get(); // throws NoSuchElementException
value.get(); // throws NoSuchElementException, supplier is not called again
Ցածր մակարդակի isInitialized և orElse մեթոդները հանվել են
Java 27-ը հեռացնում է և՛ orElse-ը, և՛ isInitialized-ը, քանի որ դրանք կարող էին օգտագործվել դիզայնի նպատակներին հակառակ եղանակներով։ Java 26-ում, եթե չէիք կանչում get() մեթոդը, ոչ մի երաշխիք չկար, որ արժեքը կլինի այն կարդալու պահին։
Գործնականում փոփոխությունը պարզեցնում է մտային մոդելը. դուք միշտ կանչում եք get() և միշտ ստանում եք արժեքը, եթե սխալ չի նետվում, ինչպես նկարագրված է վերևում։
LazyConstant<String> example = LazyConstant.of(() -> "Hello");
var result = example.get();
System.out.println(result);
Այստեղ արդյունքը "Hello" է՝ առանց ”else” մշակման կարիքի։
Ծույլ հավաքածուներ (Lazy Collections)
Անփոփոխ կոլեկցիաները նույնպես կարելի է համադրել stable values-ի հետ։
Ահա թե ինչպես են տարբերվում տարբերակները։
Java 25
List<Integer> list = StableValue.list(SIZE, INT_FUNCTION);
Map<Color, HowCute> map = StableValue.map(KEYS, CUTE_FUNCTION);
Java 26
List<Integer> list = List.ofLazy(SIZE,INT_FUNCTION);
Map<Color, HowCute> map = Map.ofLazy(KEYS, CUTE_FUNCTION);
Java 27
List<Integer> list = List.ofLazy(SIZE,INT_FUNCTION);
Map<Color, HowCute> map = Map.ofLazy(KEYS, CUTE_FUNCTION);
Set<Dog> set = Set.ofLazy(ALL_DOGS, IS_ADOPTED_FUNCTION);
Սա հարմար է թվում բարդ հաշվարկների համար։ Սակայն սահմանափակ է, քանի որ list-ը որպես մուտք կարող է վերցնել միայն intFunction։ Հուսով եմ՝ ապագայում ավելին կտեսնենք։
Հնարավոր խնդիրներ
LazyConstants-ը պարզ և օգտակար կառուցներ են։ Այդուհանդերձ, արժե տեղյակ լինել դրանց հետ կապված թակարդներին։
Serializable
Նկատեք, որ Lazy Constants-ը չեն աջակցում Serializable-ին։ JEP-ը դա չի ասում, բայց դա կարող եք գտնել այստեղ։
Ուստի եթե ապավինում եք serializable-ին և մտադիր եք բոլոր final-ները փոխարինել Stable Values-ով, կարող եք խնդիրների հանդիպել։
Final չօգտագործելը
Ամեն անգամ LazyConstant օգտագործելիս պետք է հիշել, որ փոփոխականին կարող է այլ արժեք վերագրվել։ Ոչինչ մեզ չի խանգարում գրել մի այսպիսի բան (բացի առողջ դատողությունից, բնականաբար).
private LazyConstant<EmailSender> sender = LazyConstant.of(() -> new EmailSender());
void adoptPet(User user, Pet pet) {
sender = null;
// some logic here
sender.get() //Null pointer exception
}
Ձեր բոլոր LazyConstant դաշտերը պետք է լինեն final, բայց ոչինչ ձեզ դա անելու չի ստիպում։ Սա կրկին Optional<>-ի պատմությունն է։
Ուրեմն ինչո՞ւ նոր հիմնաբառ չավելացրին՝ նման lazy-ին, ինչպես այլ լեզուներում է։ Դիտարկենք դրա հիմքում ընկած տրամաբանությունը։
Ո՞րն է այս JEP-ի նպատակը
JEP-ը մեզ ասում է, որ հեղինակը նպատակ ուներ արագացնել Java հավելվածների գործարկումը՝ lazy constants-ի ստեղծումը առանձնացնելով դրանց նախաստորագրումից, միաժամանակ ապահովելով ճիշտ վարքագիծ բազմաթրեդ միջավայրում և հնարավոր դարձնելով JVM օպտիմալացումներ, ինչպիսին constant-folding-ն է։
Ինչին նրանք նպատակ չունեն.
- Java ծրագրավորման լեզուն lazy դաշտեր հայտարարելու եղանակով ընդլայնելը նպատակ չէ։
- final դաշտերի սեմանտիկայի փոփոխումը նպատակ չէ։
Ուստի թեև անձամբ ես սիրով կտեսնեի lazy հիմնաբառը, ուրախ եմ, որ ավելացրել են մի բան, որը օգնում է մեզ օպտիմալացնել կոդը։ Անհամբեր սպասում եմ հաջորդ թարմացումներին։