Գնահատել նախագիծը
← Բոլոր հրապարակումները

JEP 502 - Stable Values. Java 25-ի նոր հնարավորության բացատրություն

Այս հոդվածը դիտարկում է JEP 502 - Stable Values-ը՝ Java 25-ի հետ գալիք նոր հնարավորությունը։ Java 25-ը մեր հաջորդ LTS-ն է, որի թողարկումը նախատեսված է սեպտեմբերին։ Այն կգա որպես առաջին preview հնարավորություն, ուստի դրա մասին ամեն ինչ դեռ կարող է փոխվել։

5 րոպե
Javauncoverjavajava 25JEP502

Այս հոդվածը դիտարկում է 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»-ն, ուրախ եմ, որ ավելացրել են մի բան, որը օգնում է մեզ օպտիմալացնել մեր կոդը։ Անհամբեր սպասում եմ հաջորդ թարմացումներին։