A Java 25-be való áttérés okai

A Java 25 egy hosszú távon támogatott (LTS) kiadás, ami természetes választássá teszi a jelenleg Java 8-at, 11-et, 17-et vagy 21-et használó csapatok számára. Minden LTS-kiadás több éves frissítéseket és biztonsági javításokat kap, így a Java 25-ös verzióra való áttérés támogatja, biztonságossá teszi az alkalmazásokat, és képes a legújabb teljesítmény- és nyelvi fejlesztések használatára.

A kérdés nem az , hogy át kell-e lépnie egy újabb LTS-kiadásra, hanem az, hogy mikor. Minél tovább vár, annál több változás halmozódik fel az aktuális verzió és a következő támogatott verzió között. A 25-ös Java való áttérésnek egyértelmű előnyei vannak, és az áthelyezés megtervezése a későbbiek helyett hamarabb csökkenti a kockázatot.

A 8. Java óta minden kiadás tartalmaz funkciókat és fejlesztéseket. Az API-ban észrevehető kiegészítések és módosítások érhetők el, valamint az indítási idő, az átviteli sebesség, a memóriahasználat, a méretezhetőség és a fejlesztői hatékonyság javítása. Ez a cikk a leghatásosabb változásokat emeli ki, és a Java 11 LTS-kiadás óta megjelent Java verziókra összpontosít: Java 17, Java 21 és Java 25.

Váltás Java 25-ös verzióra

Fokozatosan áttérhet a Java 25-re. A régebbi JDK-val fejlesztett és létrehozott kód általában Java 25-ös verzión futtatható újrafordítás nélkül. A nagyobb frissítésekhez hasonlóan figyelje az eltávolított API-kat, az elavult csomagokat, a belső API-k használatát és az alapértelmezett viselkedés változásait, különösen a szemétgyűjtés körül.

Ha Java 8-ról vagy 11-ről vált, kezdje a Java 8-ról Java 11-re való átállásról szóló útmutatóval, hogy kezelni tudja a legtöbb kompatibilitást megszakító változást, majd haladjon tovább a Java 17, 21 és 25 felé. Ha már Java 17-et vagy 21-et használ, a Java 25-re való áttérés általában kisebb lépés, mert a modulrendszeren és a legtöbb platformszintű változtatáson már túl van.

Tipp

A GitHub Copilot alkalmazás modernizálásával felmérheti az alkalmazást, megtervezheti a frissítést, és automatikusan alkalmazhatja a kódmódosításokat. Támogatja Java 8., 11., 17., 21. és 25. verzió közötti frissítést, minden módosítás után elkészíti és teszteli a projektet, és segít a jelen cikk későbbi részében ismertetett viselkedésváltozások elhárításában.

Tipp

A régebbi JDK-verziókhoz hangolt JVM-kapcsolók a Java 25-ben elavulttá válhatnak, eltávolíthatják őket, vagy kevésbé optimálisnak bizonyulhatnak. A régi, elavult beállítások továbbvitele helyett engedélyezheti, hogy a Javahoz készült Azure Command Launcher (jaz) automatikusan alkalmazza a JDK-verzióhoz, valamint a konténer vagy a virtuális gép erőforrásaihoz igazított JVM-jelzőket. Az előnyök kihasználásához cserélje le a(z) java parancsot a(z) jaz parancsra az indítási parancsfájlban vagy a(z) Dockerfile esetében.

Magas szintű változások Java 11 óta

Ez a szakasz nem sorolja fel a 8. Java óta végrehajtott összes módosítást. Kiemeli azokat a változásokat, amelyek a legnagyobb hatással vannak a teljesítményre, a méretezhetőségre, a diagnosztikára, a termelékenységre és a biztonságra. E funkciók többsége a Java 17, 21 és 25 kiadásaival jelent meg, és ma már a Java 25-tel elérhető LTS-alap része. Minden funkció megjegyzi a Java kiadást, amelyben integrálták.

Méretezhetőség virtuális szálakkal

A virtuális szálak [1] az operációs rendszer helyett a JVM által felügyelt könnyű szálak, amelyek jelentősen csökkentik a nagy átviteli sebességű alkalmazások írásának és futtatásának költségeit. A virtuális szálakkal egyszerű, kérelemenkénti stílusban írhat kódot, és nagy számú egyidejű műveletre méretezhető, ami ideális az I/O-kötött mikroszolgáltatásokhoz és a kérés-válasz számítási feladatokhoz.

A virtuális szálak véglegesítése Java 21-ben megtörtént. Java 24 eltávolított egy fő korlátozást, mivel lehetővé tette a virtuális szálak szinkronizálását anélkül, hogy rögzítenék a hordozószálaikat [2], ami javítja a blokkokat használó synchronized kód méretezhetőségét.

Strukturált egyidejűség és hatókörön belüli értékek

A hatókörrel rendelkező értékek [3] biztonságos és hatékony módot biztosítanak a nem módosítható adatok megosztására a szálakon belül és között, beleértve a virtuális szálakat is. Ezek a szálalapú változók modern alternatívái, amelyek jól működnek a szál/feladat modellel.

A strukturált egyidejűség [4] a kapcsolódó egyidejű feladatok csoportjait egyetlen munkaegységként kezeli, ami leegyszerűsíti a hibakezelést és a törlést. A Java 21-ben jelent meg először előzetesként, továbbra is fejlődik, és természetes módon együttműködik a virtuális szálakkal.

Nyelvi hatékonyság

A 14–Java 25 közötti Java nyelvi fejlesztések sorozata tömörebbé, biztonságosabbá és könnyebben olvashatóvá teszi a kódot:

  • Switch-kifejezések [5] (Java 14) lehetővé teszik, hogy a switch értéket adjanak vissza, és tisztább nyílszintaxist használjanak.
  • Mintailesztés a következőhöz: instanceof [6] (Java 16) kiküszöböli az explicit típuskonverzió szükségességét a típusellenőrzést követően.
  • Rekordok [7] (Java 16) a nem módosítható adatokat értékek rögzített halmazának transzparens hordozóiként modellezik, csökkentve a sablonkód mennyiségét.
  • A lezárt osztályok [8] (Java 17) segítségével szabályozhatja, hogy mely osztályok bővíthetik vagy implementálhatják a típusokat.
  • A szövegblokkok [9] (Java 15) leegyszerűsítik a többsoros sztringkonstansokat.
  • Mintaegyezés a következőhöz:switch [10] (Java 21) és rekordminták [11] (Java 21) lehetővé teszik az összetett feltételes logika és az adatok strukturálásának egyértelmű és biztonságos kifejezését.
  • A szekvenciált gyűjtemények [12] (Java 21) egységes API-t adnak hozzá egy meghatározott találkozási sorrendű gyűjteményekhez, beleértve az első és az utolsó elemekhez való hozzáférést.
  • A névtelen változók és minták [13] (Java 22) lehetővé teszik a fel nem használt változók és mintaösszetevők explicit megjelölését.
  • A modulimportálási deklarációk [14] (Java 25) lehetővé teszik egy teljes modul exportált csomagjainak importálását egyetlen deklarációval.
  • A kompakt forrásfájlok és a példány fő módszerei [15] (Java 25) csökkentik a kis programokhoz szükséges ceremóniát, ami megkönnyíti a Java tanulását és a prototípusok gyorsabb prototípusát.
  • A rugalmas konstruktortestek [16] (Java 25) lehetővé teszik az utasítások futtatását hívás super(...) előtt, vagy this(...)ami javítja az ellenőrzést és az inicializálást.

Teljesítmény és indítás

Számos futásidejű módosítás javítja az átviteli sebességet, a memóriaigényt és az indítási időt:

  • A kompakt objektumfejlécek [17] (Java 25) csökkentik az objektumfejlécek méretét a 64 bites platformokon. Ez a csökkentés csökkenti a halomhasználatot, és javíthatja a terheléselosztással járó számítási feladatok teljesítményét.
  • Az osztályadatok megosztása (CDS) futásidőben csökkenti az indítási időt memórialeképezéssel archivált osztályok alapján. Az alapértelmezett CDS-archívumok [18] (Java 12) és a dinamikus CDS-archívumok [19] (Java 13) megkönnyítik ezt a funkciót manuális betanítási futtatások nélkül.
  • Az idő előtti osztálybetöltés és összekapcsolás [20] (Java 24) és az idő előtti parancssori ergonómia [21] (Java 25) és az idő előtti módszerprofilozás [22] (Java 25) rövidíti az indítási és bemelegítési időt az alkalmazásarchívumban rögzített munka újrafelhasználásával. Ezek a funkciók Project Leyden azon törekvésének részét képezik, hogy Java gyorsabban induljanak el.

Ezek a fejlesztések különösen értékesek a natív felhőbeli és kiszolgáló nélküli számítási feladatok esetében, ahol a gyors indítás és a kis erőforrásigény közvetlenül jobb skálázást és alacsonyabb költségeket eredményez.

Szemétgyűjtés

A Java 25 kiforrott, rövid szünetidejű szemétgyűjtőket kínál, amelyek a különféle terhelések széles köréhez alkalmasak:

  • A ZGC [23] (Java 15) és a Shenandoah [24] (Java 15) a nagy halmokon alacsony szünetidőre tervezett, gyártásra kész gyűjtők.
  • A G1GC továbbra is az alapértelmezett gyűjtő, és továbbra is kap fejlesztéseket, beleértve a régió rögzítését [25] (Java 22) a natív kódokkal való zökkenőmentesebb interakció érdekében.
  • A generációs ZGC [26] (Java 21) a különálló generációk fenntartásával javítja a hatékonyságot. A Java 23-tól kezdődően a ZGC alapértelmezés szerint generációs módban fut [27], a nem generációs módot pedig a Java 24-ben eltávolították.
  • Generációs Shenandoah [28] (Java 25) egy generációs módot ad hozzá a Shenandoah gyűjtőhöz a nagyobb áteresztőképesség és a memórianyomás melletti jobb ellenálló képesség érdekében.

A JVM beállítja a GC alapértelmezett értékét az átlagos használati esethez. Ezeket az alapértelmezett beállításokat és egyéb GC-beállításokat az alkalmazás igényeinek megfelelően optimalizálhatja az átviteli sebesség vagy a késés optimalizálása érdekében.

Tipp

Az alapértelmezett szemétgyűjtő és a JVM számos alapértelmezett beállítása eltér a különböző Java-verziók között, így a Java 8-ra vagy 11-re hangolt beállítások Java 25-ön már nem feltétlenül optimálisak. A Java () jaz beolvassa a tároló cgroup memória- és CPU-korlátait, és automatikusan alkalmazza a JDK-verzióra és környezetre szabott JVM-jelzőket.

Diagnosztika és megfigyelhetőség

A diagnosztika minden kiadásban javult, mind a nyelv, mind a Java Flight Recorder (JFR):

  • A hasznos NullPointerExceptions [29] (Java 14) pontosan leírja, hogy melyik változó voltnull, ami felgyorsítja a hibakeresést.
  • JFR-eseményfolyam [30] (Java 14) lehetővé teszi, hogy az eszközök a profilalkotáshoz és diagnosztikához használt adatokat folyamatosan dolgozzák fel, ne pedig kiíratási fájlból.
  • JFR CPU-időalapú profilozás [31] (Java 25) bevezeti a kísérleti, CPU-időn alapuló metódusprofilozást Linuxon.
  • JFR kooperatív mintavételezés [32] (Java 25) javítja a veremmintavételezés stabilitását.
  • A JFR-metódus időzítése és nyomon követése [33] (Java 25) lehetővé teszi adott metódusok időzítését és nyomon követését az alkalmazáskód módosítása nélkül.

Biztonság és titkosítás

Java 25 megerősíti a platform biztonsági pozícióját, beleértve a kvantum utáni világra való felkészülést is:

  • Edwards-Curve digitális aláírási algoritmus (EdDSA) [34] (Java 15) modern, nagy teljesítményű aláírási sémát ad hozzá.
  • A Key Encapsulation Mechanism API [35] (Java 21) szabványos API-t biztosít a KEM-algoritmusokhoz.
  • A kvantumbiztos titkosítás a modul-rácsalapú kulcsbefoglaló mechanizmus (ML-KEM) [36] (Java 24) és a digitális aláírási algoritmus (ML-DSA) [37] (Java 24) standard implementációit adja hozzá.
  • A Key Derivation Function API [38] (Java 25) egy standard API-t biztosít a fő származtatott függvényekhez.

Natív együttműködés

A Foreign Function and Memory API [39] (Java 22) biztonságos, hatékony és tiszta Java módot biztosít a natív kódtárak meghívására és a natív memóriához való hozzáférésre. A Java natív interfész (JNI) modern alternatívája, amely csökkenti a sablonkód mennyiségét, és javítja a biztonságot.

Eszközök és kódtárak

Számos kiegészítés javítja a mindennapi fejlődést, és csökkenti a külső eszközök iránti igényt:

  • A csomagolóeszköz (jpackage) [40] (Java 16) natív telepítőket és csomagokat hoz létre Java alkalmazásokhoz.
  • Az egyszerű webkiszolgáló [41] (Java 18) minimális statikus fájl http-kiszolgálót biztosít a prototípus-készítéshez és teszteléshez.
  • A továbbfejlesztett álnevesítési számgenerátorok [42] (Java 17) új interfészeket és implementációkat adnak hozzá a véletlenszerű számgeneráláshoz.

A tervezéshez szükséges viselkedésváltozások

A 11-Java óta bekövetkezett egyes módosítások módosítják az alapértelmezett viselkedést, ezért a frissítés előtt tekintse át őket:

  • A JDK belső elemeinek erős enkapszulációja [43] (Java 17) alapértelmezés szerint letiltja a reflektív hozzáférést a legtöbb belső API-hoz. Azok a kódok vagy függvénytárak, amelyek a sun.* vagy más belső csomagok elemeit használják, frissítésre szorulhatnak.
  • Az UTF-8 alapértelmezés szerint [44] (Java 18) teszi az UTF-8-at a standard Java API-k alapértelmezett karakterkészleteként. A platformspecifikus alapértelmezett karakterkészletre támaszkodó alkalmazások eltérően viselkedhetnek.
  • A finalizálás eltávolítás céljából történő elavulttá nyilvánítása [45] (Java 18) azt jelzi, hogy a finalize() elemet végül el fogják távolítani. Váltson át a try-with-resources vagy a java.lang.ref.Cleaner használatára.
  • Az ügynökök dinamikus betöltésének letiltására való felkészülés [46] (Java 21) figyelmeztet, ha egy ügynök betöltődik egy futó JVM-be. Egyes monitorozási és rendszerállapot-eszközök konfigurációs módosításokat igényelhetnek.

Tipp

A GitHub Copilot alkalmazás modernizálása segíthet ezeknek a viselkedésváltozásoknak a frissítéskor történő automatikus felmérésében és elhárításában.

Tárolók és felhő

A Dockerhez és más tároló-futtatókörnyezetekhez bevezetett JVM-tárolótudatosság tovább javul. A JVM kiolvassa a konténerek vezérlőcsoportjai (cgroups) által beállított CPU- és memóriakorlátokat, és ennek megfelelően méretezi a heapet és más erőforrásokat. A gyorsabb indítással, kisebb erőforrásigénylel és virtuális szálakkal kombinálva a 25-ös Java kiválóan alkalmas tárolóalapú és kiszolgáló nélküli üzembe helyezésre Azure.

Ha Azure tárolókon vagy virtuális gépeken futtat Java számítási feladatokat, a Java () jaz felhőoptimalizált, verziónak megfelelő JVM-alapértelmezéseket alkalmazhat Önnek.

Következő lépések

References

[1] Oracle Corporation, "JEP 444: Virtual Threads." (Online). Elérhető: https://openjdk.org/jeps/444.

[2] Oracle Corporation, "JEP 491: Virtuális szálak szinkronizálása lekötés nélkül." (Online). Elérhető: https://openjdk.org/jeps/491.

[3] Oracle Corporation, "JEP 506: Hatókörhöz kötött értékek." (Online). Elérhető: https://openjdk.org/jeps/506.

[4] Oracle Corporation, "JEP 453: Strukturált konkurencia (előzetes)." (online). Elérhető: https://openjdk.org/jeps/453.

[5] Oracle Corporation, „JEP 361: Switch Expressions.” (Online). Elérhető: https://openjdk.org/jeps/361.

[6] Oracle Corporation, "JEP 394: Pattern Matching for instanceof". (Online). Elérhető: https://openjdk.org/jeps/394.

[7] Oracle Corporation, "JEP 395: Records." (Online). Elérhető: https://openjdk.org/jeps/395.

[8] Oracle Corporation, "JEP 409: Zárolt osztályok." (online). Elérhető: https://openjdk.org/jeps/409.

[9] Oracle Corporation, "JEP 378: Text Blocks." (online). Elérhető: https://openjdk.org/jeps/378.

[10] Oracle Corporation, „JEP 441: Mintázatillesztés a switch utasításhoz.” (online). Elérhető: https://openjdk.org/jeps/441.

[11] Oracle Corporation, „JEP 440: Record Patterns.” (Online elérhető). Elérhető: https://openjdk.org/jeps/440.

[12] Oracle Corporation, „JEP 431: Szekvenciális gyűjtemények.” (Online elérhető). Elérhető: https://openjdk.org/jeps/431.

[13] Oracle Corporation, "JEP 456: Névtelen változók & minták." (Online). Elérhető: https://openjdk.org/jeps/456.

[14] Oracle Corporation, "JEP 511: Module Import Deklarációk". (Online). Elérhető: https://openjdk.org/jeps/511.

[15] Oracle Corporation, "JEP 512: Kompakt forrásfájlok és példányszintű main metódusok." (Online). Elérhető: https://openjdk.org/jeps/512.

[16] Oracle Corporation, "JEP 513: Rugalmas konstruktor törzsek." (Online). Elérhető: https://openjdk.org/jeps/513.

[17] Oracle Corporation, "JEP 519: Compact Object Headers." (Online). Elérhető: https://openjdk.org/jeps/519.

[18] Oracle Corporation, "JEP 341: Alapértelmezett CDS-archívumok." (Online). Elérhető: https://openjdk.org/jeps/341.

[19] Oracle Corporation, "JEP 350: Dynamic CDS Archives." (Online). Elérhető: https://openjdk.org/jeps/350.

[20] Oracle Corporation, "JEP 483: Ahead-of-Time Class Loading & Linking." (Online). Elérhető: https://openjdk.org/jeps/483.

[21] Oracle Corporation, "JEP 514: Az előre történő parancssori ergonómiája." (Online). Elérhető: https://openjdk.org/jeps/514.

[22] Oracle Corporation, „JEP 515: Előzetes metódusprofilozás.” (online). Elérhető: https://openjdk.org/jeps/515.

[23] Oracle Corporation, "JEP 377: ZGC: Egy skálázható, alacsony késleltetésű szemétgyűjtő." (Online). Elérhető: https://openjdk.org/jeps/377.

[24] Oracle Corporation, „JEP 379: Shenandoah: alacsony szünetidejű szemétgyűjtő.” (online). Elérhető: https://openjdk.org/jeps/379.

[25] Oracle Corporation, „JEP 423: Régiórögzítés a G1-hez.” (Online elérhető). Elérhető: https://openjdk.org/jeps/423.

[26] Oracle Corporation, "JEP 439: Generational ZGC." (Online). Elérhető: https://openjdk.org/jeps/439.

[27] Oracle Corporation, "JEP 474: ZGC: Generációs mód alapértelmezés szerint." (Online). Elérhető: https://openjdk.org/jeps/474.

[28] Oracle Corporation, "JEP 521: Generational Shenandoah." (Online). Elérhető: https://openjdk.org/jeps/521.

[29] Oracle Corporation, "JEP 358: Hasznos nullmutató-kivételek." (online). Elérhető: https://openjdk.org/jeps/358.

[30] Oracle Corporation, "JEP 349: JFR Event Streaming." (Online). Elérhető: https://openjdk.org/jeps/349.

[31] Oracle Corporation, "JEP 509: JFR CPU-időprofilozás (Kísérleti)." (Online). Elérhető: https://openjdk.org/jeps/509.

[32] Oracle Corporation, "JEP 518: JFR kooperatív mintavételezés." (Online). Elérhető: https://openjdk.org/jeps/518.

[33] Oracle Corporation, "JEP 520: JFR Method Timing & Tracing." (Online). Elérhető: https://openjdk.org/jeps/520.

[34] Oracle Corporation, "JEP 339: Edwards-Curve Digital Signature Algorithm (EdDSA)." (Online). Elérhető: https://openjdk.org/jeps/339.

[35] Oracle Corporation, "JEP 452: Kulcsbetokozási mechanizmus API." (online). Elérhető: https://openjdk.org/jeps/452.

[36] Oracle Corporation, „JEP 496: Kvantumrezisztens, modulrács-alapú kulcsbekapszulázási mechanizmus.” (online). Elérhető: https://openjdk.org/jeps/496.

[37] Oracle Corporation, "JEP 497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm." (Online). Elérhető: https://openjdk.org/jeps/497.

[38] Oracle Corporation, "JEP 510: Kulcsszármaztatási függvény API." (online). Elérhető: https://openjdk.org/jeps/510.

[39] Oracle Corporation, "JEP 454: Foreign Function & Memory API." (Online). Elérhető: https://openjdk.org/jeps/454.

[40] Oracle Corporation, "JEP 392: Packaging Tool." (Online). Elérhető: https://openjdk.org/jeps/392.

[41] Oracle Corporation, "JEP 408: Simple Web Server." (Online). Elérhető: https://openjdk.org/jeps/408.

[42] Oracle Corporation, „JEP 356: Továbbfejlesztett álvéletlenszám-generátorok.” (online). Elérhető: https://openjdk.org/jeps/356.

[43] Oracle Corporation, "JEP 403: A JDK belső elemeinek erőteljes tokozása." (Online). Elérhető: https://openjdk.org/jeps/403.

[44] Oracle Corporation, "JEP 400: UTF-8 alapértelmezés szerint." (Online). Elérhető: https://openjdk.org/jeps/400.

[45] Oracle Corporation, „JEP 421: Az objektumok véglegesítésének eltávolítás céljából történő elavulttá nyilvánítása.” (online). Elérhető: https://openjdk.org/jeps/421.

[46] Oracle Corporation, "JEP 451: Felkészülés az ágensek dinamikus betöltésének letiltására." (online). Elérhető: https://openjdk.org/jeps/451.

  • Last updated on