JEP 502 - Stable Values. Java 25-ի նոր հնարավորության բացատրություն
Այս հոդվածը դիտարկում է JEP 502 - Stable Values-ը՝ Java 25-ի հետ գալիք նոր հնարավորությունը։ Java 25-ը մեր հաջորդ LTS-ն է, որի թողարկումը նախատեսված է սեպտեմբերին։ Այն կգա որպես առաջին preview հնարավորություն, ուստի դրա մասին ամեն ինչ դեռ կարող է փոխվել։
Այս հոդվածը դիտարկում է JEP 502 - Stable Values-ը՝ Java 25-ի հետ գալիք նոր հնարավորությունը։ Java 25-ը մեր հաջորդ LTS-ն է, որի թողարկումը նախատեսված է սեպտեմբերին։ Այն կգա որպես առաջին preview հնարավորություն, ուստի դրա մասին ամեն ինչ դեռ կարող է փոխվել։
Ի՞նչ է Stable Value-ն
StableValue <T>-ը կոնտեյներ է, որը պահում է T տիպի ճիշտ մեկ արժեք։ Վերագրվելուց հետո արժեքն այլևս չի կարող փոխվել։ Պատկերացրեք այն որպես eventually final (ի վերջո վերջնական) արժեք։
Հիշեք, որ անփոփոխ է դառնում օբյեկտի հղումը։ Հենց հիմքում ընկած օբյեկտը դեռ կարելի է փոփոխել։
Մինչև Stable Values
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-ով։
Եկեք օգտագործենք Stable Values
Նախորդ օրինակը տեղափոխենք նոր Java։
class PetClinicController {
private final StableValue<EmailSender> sender = StableValue.of();
EmailSender getSender() {
return sender.orElseSet(() -> new EmailSender());
}
void adoptPet(User user, Pet pet) {
// some logic here
getSender().sendEmailTo(user, "You are great person!");
}
}
Կոդը գրեթե նույնն է թվում, բայց այժմ StableValue-ն հոգ է տանում EmailSender-ի nullability-ի մասին։ Դրա պատճառով EmailSender-ը չի կարող կանչվել՝ առանց նախ արժեքը ստացող մեթոդ կանչելու։
StableValue-ի ներսում արժեքի սահմանումը երաշխավորված thread-safe է։
Stable functions
Stable Values-ը ծառայում են որպես ավելի բարձր մակարդակի ֆունկցիոնալ աբստրակցիաների հիմք։ Այս պահին կան երեք տեսակի stable ֆունկցիաներ։
Supplier:
Սա ֆունկցիա է, որը հաշվարկվում է ընդամենը մեկ անգամ. դրա արդյունքը հետո պահվում և վերադարձվում է։ Այն կարող ենք օգտագործել, օրինակ, մեր Controller-ում։
class PetClinicController {
private Supplier<EmailSender> sender = StableValue.supplier(()-> new EmailSender());
void adoptPet(User user, Pet pet) {
// some logic here
sender.get().sendEmailTo(user, "You are great person!");
}
}
intFunction:
Ֆունկցիա, որն ընդունում է int պարամետր և դրանից հաշվում է արդյունք, որը հետո backing stable value պահեստը քեշավորում է այդ պարամետրի արժեքի համար։ Այն կարող է օգտակար լինել մաթեմատիկայում։
Օրինակ՝
private final int SIZE = 3;
private final IntFunction<Integer> INT_FUNCTION = v -> {
// Simulate expensive computation
log("Computing value for: " + v);
return 42;
};
private void runIntFunction() {
var integerIntFunction = StableValue.intFunction(SIZE, INT_FUNCTION);
log(integerIntFunction.apply(1));
log(integerIntFunction.apply(1));
log(integerIntFunction.apply(1));
log(integerIntFunction.apply(2));
}
runIntFunction-ը կանչելը տալիս է հետևյալ պատասխանը.
Computing value for: 1
Value: 42
Value: 42
Value: 42
Computing value for: 2
Value: 42
Հիմնական թերությունը size պարամետրն է. պետք է նախապես նշել մուտքային պարամետրի տիրույթը։
Ֆունկցիայի չափը (օրինակ՝ 3) գերազանցելը հանգեցնում է runtime բացառության «Input not allowed: 3»
Function:
Սա intFunction-ի ավելի ընդհանուր տարբերակն է, որը թույլ է տալիս ձեր ֆունկցիան կանչել ցանկացած մուտքով։
Ահա օրինակ.
private Set<Color> KEYS = Set.of(Color.GRAY, Color.GOLDEN);
private Function<Color, HowCute> CUTE_FUNCTION = color -> {
System.out.println("Computing cuteness for: " + color);
return switch (color) {
case RED -> HowCute.CUTE;
case GRAY -> HowCute.VERY_CUTE;
case GOLDEN -> HowCute.SUPER_CUTE;
};
};
private void runCuteFunction() {
var cuteFunction = StableValue.function(KEYS, CUTE_FUNCTION);
log(cuteFunction.apply(Color.GOLDEN));
log(cuteFunction.apply(Color.GOLDEN));
log(cuteFunction.apply(Color.GOLDEN));
log(cuteFunction.apply(Color.GRAY));
log(cuteFunction.apply(Color.RED));
}
runCuteFunction-ը կանչելը տալիս է հետևյալ պատասխանը.
Computing cuteness for: GOLDEN
Value: SUPER_CUTE
Value: SUPER_CUTE
Value: SUPER_CUTE
Computing cuteness for: GRAY
Value: VERY_CUTE
Exception in thread "main" java.lang.IllegalArgumentException: Input not allowed: RED
Ինչպես հավանաբար նկատեցիք, նույնիսկ երբ ձեր ֆունկցիան կարող է տվյալ մուտքը մշակել, կստանաք «Input not allowed» բացառություն, եթե այդ մուտքը նշված չէ inputs պարամետրում։
Stable collections
Անփոփոխ կոլեկցիաները նույնպես կարելի է համադրել stable values-ի հետ։ Ներկայումս հասանելի են միայն List և Map։
List<Integer> list = StableValue.list(SIZE, INT_FUNCTION);
Map<Color, HowCute> map = StableValue.map(KEYS, CUTE_FUNCTION);
Տիպը չի բացահայտում, որ ներքևում օգտագործվում են StableFunctions։ Սա հարմար է թվում բարդ հաշվարկների համար։ Սակայն սահմանափակ է, քանի որ list-ը կարող է աշխատել միայն intFunction-ի հետ։ Հուսով ենք՝ ապագայում ավելին կլինի։
Հնարավոր խնդիրներ
Stable Values-ը պարզ և գործնական կառուցներ են։ Այդուհանդերձ, լավ է իմանալ դրանց հետ կապված հնարավոր թակարդները։
Serializable:
Նկատեք, որ Stable Values-ը չեն աջակցում Serializable-ին։ JEP-ը դա չի ասում, բայց StableValue API-ի փաստաթղթերն ասում են։
Ուստի եթե ապավինում եք serializable-ին և մտադիր եք յուրաքանչյուր final-ը փոխարինել Stable Values-ով, այստեղ կարող եք խնդիրների հանդիպել։
Final չօգտագործելը.
StableValue օգտագործելիս պետք է հիշել, որ փոփոխականին դեռ կարելի է այլ արժեք վերագրել։ Ոչինչ մեզ չի խանգարում գրել մի այսպիսի բան (բացի առողջ դատողությունից, բնականաբար).
private StableValue<EmailSender> sender = StableValue.of();
void adoptPet(User user, Pet pet) {
sender = null;
// some logic here
sender.orElseSet(...) //Null pointer exception
}
Ձեր յուրաքանչյուր StableValue պետք է նշված լինի final, բայց ոչինչ ձեզ դա անելու չի ստիպում։ Սա կրկին Optional<>-ի պատմությունն է։
Ուրեմն ինչո՞ւ նոր հիմնաբառ չավելացվեց՝ նման «Lazy»-ին, որը հայտնի է այլ լեզուներից։ Դիտարկենք դրա հիմքում ընկած տրամաբանությունը։
Ի՞նչ նպատակ ունի այս JEP-ը
Այս JEP-ը մեզ ասում է, որ հեղինակը նպատակ ուներ արագացնել Java հավելվածների գործարկումը՝ stable values-ի ստեղծումը առանձնացնելով դրանց նախաստորագրումից, միաժամանակ ապահովելով, որ այն աշխատի բազմաթրեդ միջավայրում և թույլ տա JVM օպտիմալացում, ինչպիսին constant-folding-ն է։
Այն, ինչ նրանք նպատակ չունեն անել.
- Java ծրագրավորման լեզուն ընդլայնել stable values հայտարարելու եղանակով,
- փոխել final դաշտերի սեմանտիկան։
Ուստի թեև անձամբ ես սիրով կտեսնեի «Lazy»-ն, ուրախ եմ, որ ավելացրել են մի բան, որը օգնում է մեզ օպտիմալացնել մեր կոդը։ Անհամբեր սպասում եմ հաջորդ թարմացումներին։