ProHoster > Blog > balita sa internet > Paglabas ng Java SE 22 platform at OpenJDK 22 open reference na pagpapatupad

Paglabas ng Java SE 22 platform at OpenJDK 22 open reference na pagpapatupad

Pagkatapos ng anim na buwan ng pag-unlad, inilabas ng Oracle ang platform ng Java SE 22 (Java Platform, Standard Edition 22), na gumagamit ng OpenJDK open source na proyekto bilang isang reference na pagpapatupad. Maliban sa pag-alis ng ilang mga hindi na ginagamit na feature, ang Java SE 22 ay nagpapanatili ng backward compatibility sa mga nakaraang release ng Java platformβ€”ang karamihan sa mga naunang naisulat na mga proyekto sa Java ay gagana pa rin nang walang pagbabago kapag pinapatakbo sa ilalim ng bagong bersyon. Ang mga mai-install na build ng Java SE 22 (JDK, JRE, at Server JRE) ay inihanda para sa Linux (x86_64, AArch64), Windows (x86_64), at macOS (x86_64, AArch64). Binuo ng proyekto ng OpenJDK, ang pagpapatupad ng Java 22 reference ay ganap na open source sa ilalim ng lisensya ng GPLv2 na may mga pagbubukod sa GNU ClassPath upang payagan ang dynamic na pag-link sa mga komersyal na produkto.

Ang Java SE 22 ay inuri bilang isang regular na release ng suporta at patuloy na makakatanggap ng mga update hanggang sa susunod na release. Ang sangay ng Long Term Support (LTS) ay dapat na Java SE 21 o Java SE 17, na makakatanggap ng mga update hanggang 2031 at 2029, ayon sa pagkakabanggit (karaniwang available hanggang 2028 at 2026). Ang pampublikong suporta para sa LTS branch ng Java SE 11 ay natapos noong Setyembre, ngunit ang pinalawig na suporta ay magpapatuloy hanggang 2032. Ang pinalawig na suporta para sa LTS branch ng Java SE 8 ay magpapatuloy hanggang 2030.

Paalalahanan ka namin na simula sa paglabas ng Java 10, lumipat ang proyekto sa isang bagong proseso ng pag-unlad, na nagpapahiwatig ng mas maikling cycle para sa pagbuo ng mga bagong release. Ang bagong functionality ay binuo na ngayon sa isang patuloy na ina-update na master branch, na kinabibilangan ng mga handa nang pagbabago at kung saan ang mga branch ay sinasanga bawat anim na buwan upang patatagin ang mga bagong release.

Kasama sa mga bagong feature sa Java 22 ang:

  • Ang G1 garbage collector ay may kasamang suporta para sa region pinning, na nagbibigay-daan sa iyong pansamantalang ayusin ang lokasyon ng Java objects sa memorya upang maiwasang ilipat ang mga ito ng garbage collector at upang payagan ang mga reference sa mga bagay na ito na ligtas na maipasa sa pagitan ng Java at native code. Nagbibigay-daan sa iyo ang pag-pin na bawasan ang latency at iwasang i-disable ang pangongolekta ng basura kapag nagpapatupad ng mga kritikal na rehiyon ng JNI (Java Native Interface) gamit ang native code (habang isinasakatuparan ang mga seksyong ito, hindi dapat ilipat ng JVM ang mga kritikal na bagay na nauugnay sa mga ito para maiwasan ang mga kundisyon ng lahi). Ang pag-pin ay nag-aalis ng mga kritikal na bagay mula sa view ng basurero, na maaaring magpatuloy sa paglilinis ng mga hindi naka-pin na lugar.
  • Ang isang paunang tampok ay idinagdag upang payagan ang mga expression na matukoy sa mga konstruktor bago tumawag ng super(...), na ginagamit upang tahasang tumawag sa isang parent class constructor mula sa isang minanang class constructor kung ang mga expression na iyon ay hindi tumutukoy sa isang instance na ginawa ng constructor. class Outer { void hello() { System.out.println("Hello"); } class Inner { Inner() { hello(); sobrang(); } } }
  • Ang FFM (Foreign Function & Memory) API ay na-stabilize, na nagpapahintulot sa pakikipag-ugnayan ng mga Java program na may panlabas na code at data sa pamamagitan ng pagtawag sa mga function mula sa mga panlabas na library at pag-access ng memorya sa labas ng JVM, nang hindi gumagamit ng JNI (Java Native Interface).
  • Na-enable ang suporta para sa mga hindi pinangalanang variable at pagtutugma ng pattern - sa halip na hindi ginagamit ngunit kinakailangang mga variable at pattern kapag tumatawag, maaari mo na ngayong tukuyin ang karakter na "_". // was String pageName = switch (page) { case GitHubIssuePage(var url, var content, var links, int issueNumber) -> β€œISSUE #” + issueNumber; ... }; // now you can String pageName = switch (page) { case GitHubIssuePage(_, _, _, int issueNumber) -> β€œISSUE #” + issueNumber; };
  • Ang isang paunang pagpapatupad ng Class-File API ay iminungkahi para sa pag-parse, pagbuo, at pag-convert ng mga file ng klase ng Java. ClassFile cf = ClassFile.of(); ClassModel classModel = cf.parse(bytes); byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { for (ClassElement ce : classModel) { if (!(ce instanceof MethodModel mm && mm.methodName().stringValue(). startsWith("debug"))) { classBuilder.with(ce); } } });
  • Ang java utility ay nagbibigay ng kakayahang magpatakbo ng mga Java program, na ibinibigay sa anyo ng ilang code file o precompiled class library, nang hindi hiwalay na kino-compile ang mga file na ito at hindi kino-configure ang build system. Pinapadali ng bagong feature ang pagpapatakbo ng mga programa kung saan ang code ng iba't ibang klase ay pinaghihiwalay sa magkakahiwalay na mga file. Prog.java: class Prog { public static void main(String[] args) { Helper.run(); } } Helper.java: class Helper { static void run() { System.out.println("Hello!"); } }

    Halimbawa, upang magpatakbo ng isang program na binubuo ng dalawang file na "Prog.java" at "Helper.java" ito ay sapat na ngayon upang patakbuhin ang "java Prog.java", na mag-compile ng Prog class, tumukoy ng isang reference sa Helper class, hanapin at i-compile ang Helper file.java at pagtawag sa pangunahing paraan.

  • Nagdagdag ng pangalawang paunang pagpapatupad ng String Templates, na ipinatupad bilang karagdagan sa mga literal na string at mga bloke ng teksto. Binibigyang-daan ka ng mga template ng string na pagsamahin ang teksto sa mga kinakalkulang expression at variable nang hindi ginagamit ang + operator. Isinasagawa ang pagpapalit ng mga expression gamit ang mga pamalit na \{..}, at maaaring ikonekta ang mga espesyal na tagapangasiwa upang suriin ang kawastuhan ng mga pinalit na halaga. Halimbawa, sinusuri ng SQL engine ang mga value na pinapalitan sa SQL code at nagbabalik ng java.sql.Statement object bilang output, habang sinusubaybayan ng JSON processor ang kawastuhan ng mga pagpapalit ng JSON at nagbabalik ng JsonNode. String query = "PUMILI * MULA SA Tao p SAAN p." + property + " = '" + value + "'"; // was Statement query = SQL."""SELECT * FROM Person p WHERE p.\{property} = '\{value}'"""; // naging
  • Ang ikapitong preview ng Vector API ay idinagdag, na nagbibigay ng mga function para sa mga kalkulasyon ng vector na ginagawa gamit ang mga tagubilin ng vector sa x86_64 at AArch64 na mga processor at pinapayagan ang mga operasyon na mailapat nang sabay-sabay sa maramihang mga halaga (SIMD). Hindi tulad ng mga kakayahan na ibinigay sa HotSpot JIT compiler para sa auto-vectorization ng scalar operations, ginagawang posible ng bagong API na tahasang kontrolin ang vectorization para sa parallel na pagproseso ng data.
  • Ang isang paunang pagpapatupad ng pinalawig na Stream API ay idinagdag na sumusuporta sa pagtukoy sa iyong sariling mga intermediate na operasyon, na maaaring maging kapaki-pakinabang sa mga kaso kung saan ang mga umiiral na built-in na intermediate na operasyon ay hindi sapat para sa nais na pagbabago ng data. Nakakonekta ang mga katutubong humahawak gamit ang bagong intermediate na operasyon na Stream::gather(Gatherer), na nagpoproseso ng mga elemento ng stream sa pamamagitan ng paglalapat ng handler na tinukoy ng user sa kanila. jshell> Stream.of(1,2,3,4,5,6,7,8,9).gather(new WindowFixed(3)).toList() $1 ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
  • Ang pangalawang bersyon ng pang-eksperimentong API para sa Structured Concurrency ay iminungkahi para sa pagsubok, na pinapasimple ang pagbuo ng mga multi-threaded na application sa pamamagitan ng pagproseso ng maraming gawain na isinasagawa sa iba't ibang mga thread bilang isang bloke.
  • Nagdagdag ng pangalawang paunang pagpapatupad ng mga implicitly na idineklara na mga klase at hindi pinangalanang mga instance ng "pangunahing" na pamamaraan, na maaaring magbigay ng pampubliko/static na mga deklarasyon, pagpasa ng hanay ng mga argumento, at iba pang entity na nauugnay sa isang deklarasyon ng klase. // was public class HelloWorld { public static void main(String[] args) { System.out.println("Hello world!"); } } // ngayon ay maaari mong alisin ang main() { System.out.println("Hello, World!"); }
  • Nagdagdag ng pangalawang preview na pagpapatupad ng Scoped Values, na nagpapahintulot sa hindi nababagong data na maibahagi sa mga thread at mahusay na pagpapalitan ng data sa pagitan ng mga child thread (namana ang mga value). Ang Mga Saklaw na Halaga ay binuo upang palitan ang mekanismo ng thread-local na mga variable at mas mahusay kapag gumagamit ng napakaraming virtual na mga thread (libo o milyon-milyong mga thread). Ang pangunahing pagkakaiba sa pagitan ng Mga Saklaw na Halaga at thread-local na mga variable ay ang dating ay nakasulat nang isang beses, hindi mababago sa hinaharap, at mananatiling available lamang sa tagal ng pagpapatupad ng thread.
  • Ang Parallel garbage collector ay napabuti ang pagganap kapag nagtatrabaho sa malalaking hanay ng mga bagay. Ginawang posible ng pag-optimize sa ilang pagsubok na may malalaking hanay ng mga bagay na bawasan ang pagkaantala bago magsimulang maghanap ng isang bagay ng 20%.

Bilang karagdagan, maaari mong tandaan ang paglalathala ng isang update sa platform para sa paglikha ng mga application na may isang graphical na interface na JavaFX 22.

Pinagmulan: opennet.ru

Magdagdag ng komento