Հայացք JDK 24-ի ներսը. ինչպես է աշխատում Ahead-of-Time Class Loading & Linking-ը
Ahead-of-Time Class Loading & Linking-ը JDK 24-ում հայտնվող JEP-երից է։ Դրա հիմնական նպատակը JVM հավելվածների գործարկման արագացումն է։
Ahead-of-Time Class Loading & Linking-ը JDK 24-ում հայտնվող JEP-երից է։ Դրա հիմնական նպատակը JVM հավելվածների գործարկման արագացումն է հնարավորինս թափանցիկ ձևով։ Այս հնարավորության օգտագործումը չի պահանջում կոդի փոփոխություններ կամ լրացուցիչ գործիքներ – պարզապես միացնում եք՝ հավելվածը գործարկելիս մեկ տարբերակ տալով։ Իր հիմքում այն հենվում է Class Data Sharing-ի դրած հիմքի վրա և շարունակում է այդ հնարավորությունը։
Ինչպես է JVM-ը գործարկվում
Որպեսզի ավելի լավ տեսնենք, թե ինչպես է աշխատում AOT (Ahead-Of-Time) Class Loading & Linking-ը, նախ պետք է հասկանանք, թե ինչ է տեղի ունենում JVM (Java Virtual Machine) հավելվածի գործարկման ժամանակ՝

Երբ կանչվում է JNI_CreateJavaVM ֆունկցիան (ինչը տեղի է ունենում ավտոմատ, երբ գործարկում եք պարզ հրաման, ինչպիսին java -jar myapp.jar-ն է), JVM-ը սկսում է հիշողություն հատկացնելով մի շարք ներքին կառուցվածքների համար, ինչպիսիք են heap-ը, method area-ն և այլն։ Դրանից հետո այն կարգավորում է այնպիսի բաղադրիչներ, ինչպիսիք են Garbage Collector-ը և JIT (Just-In-Time) compiler-ը։
Ապա JVM-ը սկսում է class-երի բեռնումը Bootstrap Class Loader-ով։ Այս loader-ը զբաղվում է Java միջավայրի համար էական class-երով, ինչպիսիք են՝
- Object,
- String,
- ClassLoader (Bootstrap Class Loader-ը հատուկ տեսակի class loader է, ներկառուցված JVM-ի միջուկում և իրականացված native կոդով),
- Thread,
- և շատ ուրիշներ։
Բեռնվելուց հետո այս class-երը JVM-ի կողմից ստուգվում և պատրաստվում են։ Կախված իր ռազմավարությունից (lazy կամ eager)՝ JVM-ը կարող է այս փուլում նաև լուծել սիմվոլիկ հղումները։ Ստուգումից և պատրաստումից հետո class-երը ինիցիալիզացվում են և կարող են օգտագործվել։
Ahead-of-Time Class Loading & Linking-ը գործողության մեջ
Ընդհանուր առմամբ, մինչև կատարումը հասնի մեր main մեթոդին, շատ բան պետք է տեղի ունենա։ Ահա թե ինչու JVM-ի հավելվածները սովորաբար գործարկվում են զգալիորեն ավելի դանդաղ, քան C++ կամ Rust-ի նման լեզուներով գրվածները։ Այս խնդրի մի մասը մեղմելու համար որոշ ժամանակ առաջ ներմուծվեց Class Data Sharing-ը (CDS)։ CDS-ը, որը լռելյայն միացված է JDK 12-ից ի վեր, զբաղվում է հետագա class-երի բեռնման համար անհրաժեշտ քայլերով։ Այն հենվում է արխիվային ֆայլի վրա, որը ծառայում է որպես parse արված class bytecode-ի քեշ, ուստի հետագա գործարկումների ժամանակ JVM-ը կարող է օգտագործել այս արխիվի class-երը՝ դրանք նորից չ-parse անելով։ Քեշը կիսվում է տարբեր հավելվածների միջև և պարունակում է միայն JDK-ի հիմնական class-երը։ Գոյություն ունի նաև Application Class Data Sharing կոչվող տարբերակը, որը ընդլայնում է արխիվը՝ քեշավորելով հավելվածին հատուկ class-երը։
Սակայն class-երի բեռնումը JVM գործարկման միայն մեկ մասն է։ JEP 483-ը ավելի հեռու է գնում՝ AOT Class Loading & Linking-ով։ CDS-ը իսկապես լուծում է class-երի բեռնման որոշ խնդիրներ, բայց այլ կերպ. այն պահում է class-երը parse արված ձևով իր քեշում, որպեսզի դրանք կարողանան արագ բեռնվել հիշողություն մեկ առ մեկ, բայց linking քայլը դեռ պետք է տեղի ունենա հետո։
Նոր բարելավումը, ի տարբերություն դրա, հավաքում է բոլոր class-երը training run-ի ժամանակ (բացատրվում է ստորև) և համոզվում է, որ դրանք ստուգված են, պատրաստված և նրանց սիմվոլիկ հղումները լուծված են։ Մի խոսքով, այս class-երը արդեն linked են և օգտագործման համար պատրաստ։ Արդյունքում AOT քեշը պարունակում է զգալիորեն ավելի շատ տվյալներ, որոնք բոլորը հիշողություն են բեռնվում միանգամից։ Դա այն պատճառով է, որ ցանկացած class-ի ինիցիալիզացիան պահանջում է լուծել նրա ամբողջ class ենթագրաֆը՝ յուրաքանչյուր superclass և interface պետք է linked լինի, մինչև տվյալ class-ը օգտագործվի։
Training run-ը
Հիմքում ընկած ենթադրությունն այն է, որ AOT քեշում պահվող տվյալները մնում են նույնը training run-ի և production run-ի միջև։ Այսպիսով, ի՞նչ է «training run»-ը, և ի՞նչ ձև կարող է այն ունենալ։ Դա կախված է նրանից, թե ինչ է մեզ պետք։ Production run-ն ինքը կարող է լավ training run լինել, բայց integration թեստերը կարող են նույնիսկ ավելի լավ ընտրություն լինել։ Այս կերպ AOT քեշը կարելի է կառուցել որպես ձեր նախագծի build-ի մաս։ Սակայն պետք է զգույշ լինել չբեռնել class-եր, որոնք production-ը չի օգտագործի. ակնհայտ օրինակ են զուտ թեստավորման համար բեռնված class-երը։ JEP փաստաթղթում նշվում է, որ հետագա թարմացումները կարող են ավելացնել լրացուցիչ ֆիլտրման տարբերակներ՝ սրանում օգնելու համար։
Հիմնական բանը հասկանալն է, որ որքան training run-ը մոտ է production run-ին, այնքան մեծ է օգուտը։ Այդուհանդերծ, խնդիր չէ, եթե որոշ class-եր չեն հայտնվում AOT քեշում – JVM-ը դրանք պարզապես կբեռնի սովորական եղանակով։ Իմ կարծիքով՝ այս ճկունությունը հնարավորության ամենամեծ առավելություններից է. այն կարող է զգալի օգուտ տալ՝ պահպանելով JVM-ի դինամիկ բնույթը։ Այն նաև պարզ է օգտագործման համար, քանի որ գործընթացը չի պահանջում լրացուցիչ գործիքներ։ Այս JEP-ի տրամադրածից օգտվելու համար անցնում եք հետևյալ երեք քայլերով՝
Քայլ 1. Training run
java -XX:AOTMode=record -XX:AOTConfiguration=app.aotconf -jar my-app.jar
Քայլ 2. Քեշի ստեղծում
java -XX:AOTMode=create -XX:AOTConfiguration=app.aotconf -XX:AOTCache=app.aot -jar my-app.jar
Քայլ 3. Հավելվածի գործարկումը քեշով
java -XX:AOTCache=app.aot -jar my-app.jar
Ես չեմ ցույց տա այս JEP-ի տված շահույթի կոնկրետ չափումներ, բայց ավելի շատ մանրամասներ հասանելի են JEP 483-ի պաշտոնական էջում։ Հիշեք, որ այս նոր հնարավորությունից ստացվող օգուտը մեծապես կախված է ձեր հավելվածի կոնկրետ առանձնահատկություններից։
Թեև այս JEP-ը ունի Closed/Delivered կարգավիճակ, ապագայի համար մնում են որոշ հնարավոր բարելավումներ՝
- AOT քեշ չհայտնվելու class-երը բացառելու եղանակ,
- օգտատիրոջ սահմանած class loader-ների աջակցություն, քանի որ այժմ AOT քեշում կարող են ընդգրկվել միայն ներկառուցված class loader-ների բեռնած class-երը։
Եզրակացություն
JEP 483-ը JVM-ի դանդաղ գործարկման խնդրի լուծման ուղղությամբ ևս մեկ քայլ է։ Նախկինում չէի նշել, բայց այս ջանքը մտնում է ավելի լայն Project Leyden-ի մեջ, և դա նրա JEP-երից առաջինն է, որ ավարտվել է։ Սպասվում են ևս երկու JEP՝
Ավելին, ինչպես նշված է JEP վեբ էջում, class-երի բեռնումը և linking-ը հետագայում դեռ կարող են բարելավումներ տեսնել։