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

JEP 531 - Lazy Constants, ճանապարհորդությունը շարունակվում է

Հայացք Java 27-ի JEP 531-ի Lazy Constants հնարավորությանը՝ API-ի փոփոխություններ, սխալների մշակում, lazy կոլեկցիաներ և հայտնի սահմանափակումներ։

5 րոպե
JavauncoverjavaJava 26JEP526

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