Java SE 22 പ്ലാറ്റ്‌ഫോമിൻ്റെയും OpenJDK 22 ഓപ്പൺ റഫറൻസ് നടപ്പിലാക്കലിൻ്റെയും റിലീസ്

ആറ് മാസത്തെ വികസനത്തിന് ശേഷം, Oracle Java SE 22 (Java Platform, Standard Edition 22) പ്ലാറ്റ്‌ഫോം പുറത്തിറക്കി, അത് OpenJDK ഓപ്പൺ സോഴ്‌സ് പ്രോജക്‌റ്റ് ഒരു റഫറൻസ് നടപ്പിലാക്കലായി ഉപയോഗിക്കുന്നു. ഒഴിവാക്കിയ ചില സവിശേഷതകൾ നീക്കം ചെയ്തതൊഴിച്ചാൽ, Java SE 22 ജാവ പ്ലാറ്റ്‌ഫോമിന്റെ മുൻ പതിപ്പുകളുമായി പിന്നോക്ക അനുയോജ്യത നിലനിർത്തുന്നു-മുമ്പ് എഴുതിയ മിക്ക ജാവ പ്രോജക്റ്റുകളും പുതിയ പതിപ്പിന് കീഴിൽ പ്രവർത്തിക്കുമ്പോൾ മാറ്റമില്ലാതെ പ്രവർത്തിക്കും. ഇൻസ്റ്റാൾ ചെയ്യാവുന്ന Java SE 22 ബിൽഡുകൾ (JDK, JRE, സെർവർ JRE) Linux (x86_64, AArch64), Windows (x86_64), macOS (x86_64, AArch64) എന്നിവയ്ക്കായി തയ്യാറാക്കിയിട്ടുണ്ട്. OpenJDK പ്രോജക്റ്റ് വികസിപ്പിച്ചെടുത്ത, ജാവ 22 റഫറൻസ് നടപ്പിലാക്കൽ GPLv2 ലൈസൻസിന് കീഴിൽ GNU ClassPath ഒഴിവാക്കലുകളോടെ വാണിജ്യ ഉൽപ്പന്നങ്ങളിലേക്ക് ഡൈനാമിക് ലിങ്കിംഗ് അനുവദിക്കുന്നതിന് പൂർണ്ണമായും തുറന്നിരിക്കുന്നു.

Java SE 22 ഒരു റെഗുലർ സപ്പോർട്ട് റിലീസായി തരംതിരിച്ചിട്ടുണ്ട്, അടുത്ത പതിപ്പ് വരെ അപ്ഡേറ്റുകൾ ലഭിക്കുന്നത് തുടരും. ലോംഗ് ടേം സപ്പോർട്ട് (LTS) ബ്രാഞ്ച് Java SE 21 അല്ലെങ്കിൽ Java SE 17 ആയിരിക്കണം, അത് യഥാക്രമം 2031, 2029 വരെ അപ്‌ഡേറ്റുകൾ സ്വീകരിക്കും (സാധാരണയായി 2028, 2026 വരെ ലഭ്യമാണ്). Java SE 11-ൻ്റെ LTS ബ്രാഞ്ചിനുള്ള പൊതു പിന്തുണ കഴിഞ്ഞ സെപ്റ്റംബറിൽ അവസാനിച്ചു, എന്നാൽ വിപുലമായ പിന്തുണ 2032 വരെ തുടരും. Java SE 8-ൻ്റെ LTS ബ്രാഞ്ചിനുള്ള വിപുലമായ പിന്തുണ 2030 വരെ തുടരും.

ജാവ 10-ൻ്റെ റിലീസ് മുതൽ, പ്രോജക്റ്റ് ഒരു പുതിയ വികസന പ്രക്രിയയിലേക്ക് മാറി, പുതിയ റിലീസുകളുടെ രൂപീകരണത്തിന് ഒരു ചെറിയ ചക്രം സൂചിപ്പിക്കുന്നുവെന്ന് ഞങ്ങൾ നിങ്ങളെ ഓർമ്മിപ്പിക്കാം. സ്ഥിരമായി അപ്‌ഡേറ്റ് ചെയ്യുന്ന ഒരു മാസ്റ്റർ ബ്രാഞ്ചിൽ പുതിയ പ്രവർത്തനം ഇപ്പോൾ വികസിപ്പിച്ചെടുത്തിട്ടുണ്ട്, അതിൽ റെഡിമെയ്ഡ് മാറ്റങ്ങൾ ഉൾപ്പെടുന്നു, കൂടാതെ പുതിയ റിലീസുകൾ സ്ഥിരപ്പെടുത്തുന്നതിന് ഓരോ ആറ് മാസത്തിലും ശാഖകൾ ബ്രാഞ്ച് ചെയ്യുന്നു.

Java 22-ലെ പുതിയ സവിശേഷതകൾ ഉൾപ്പെടുന്നു:

• G1 ഗാർബേജ് കളക്ടറിൽ റീജിയൻ പിൻ ചെയ്യുന്നതിനുള്ള പിന്തുണ ഉൾപ്പെടുന്നു, ഇത് ജാവ ഒബ്‌ജക്‌റ്റുകൾ മെമ്മറിയിലെ സ്ഥാനം താൽക്കാലികമായി ശരിയാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അവ മാലിന്യ ശേഖരണത്തിലൂടെ നീക്കുന്നത് ഒഴിവാക്കാനും ഈ ഒബ്‌ജക്റ്റുകളെ കുറിച്ചുള്ള റഫറൻസുകൾ ജാവയ്ക്കും നേറ്റീവ് കോഡിനും ഇടയിൽ സുരക്ഷിതമായി കൈമാറാനും അനുവദിക്കുന്നു. ജെഎൻഐയുടെ (ജാവ നേറ്റീവ് ഇൻ്റർഫേസ്) നിർണ്ണായക മേഖലകൾ നേറ്റീവ് കോഡ് ഉപയോഗിച്ച് നിർവ്വഹിക്കുമ്പോൾ കാലതാമസം കുറയ്ക്കാനും മാലിന്യ ശേഖരണം പ്രവർത്തനരഹിതമാക്കുന്നത് ഒഴിവാക്കാനും പിൻ ചെയ്യൽ നിങ്ങളെ അനുവദിക്കുന്നു (ഈ വിഭാഗങ്ങൾ എക്‌സിക്യൂട്ട് ചെയ്യുമ്പോൾ, റേസ് സാഹചര്യങ്ങൾ ഒഴിവാക്കുന്നതിനായി അവയുമായി ബന്ധപ്പെട്ട നിർണായക വസ്തുക്കൾ JVM നീക്കരുത്). പിൻ ചെയ്യൽ മാലിന്യ ശേഖരണത്തിൻ്റെ കാഴ്ചയിൽ നിന്ന് നിർണായകമായ വസ്തുക്കളെ നീക്കംചെയ്യുന്നു, അത് പിൻ ചെയ്യാത്ത പ്രദേശങ്ങൾ വൃത്തിയാക്കുന്നത് തുടരാം.
• സൂപ്പർ(...) എന്ന് വിളിക്കുന്നതിന് മുമ്പ് കൺസ്‌ട്രക്‌റ്ററുകളിൽ എക്‌സ്‌പ്രഷനുകൾ വ്യക്തമാക്കുന്നതിന് ഒരു പ്രാഥമിക ഫീച്ചർ ചേർത്തിട്ടുണ്ട്, ആ എക്‌സ്‌പ്രഷനുകൾ കൺസ്‌ട്രക്‌ടർ സൃഷ്‌ടിച്ച ഒരു സംഭവത്തെ പരാമർശിക്കുന്നില്ലെങ്കിൽ, പാരമ്പര്യമായി ലഭിച്ച ക്ലാസ് കൺസ്‌ട്രക്‌ടറിൽ നിന്ന് ഒരു പാരൻ്റ് ക്ലാസ് കൺസ്‌ട്രക്‌ടറെ വ്യക്തമായി വിളിക്കാൻ ഉപയോഗിക്കുന്നു. ക്ലാസ് ഔട്ടർ { void hello() { System.out.println("Hello"); } ക്ലാസ് ഇന്നർ { അകത്തെ () { ഹലോ (); സൂപ്പർ(); } } }
• JNI (ജാവ നേറ്റീവ് ഇൻ്റർഫേസ്) ഉപയോഗിക്കാതെ, ബാഹ്യ ലൈബ്രറികളിൽ നിന്ന് ഫംഗ്‌ഷനുകൾ വിളിച്ച് JVM-ന് പുറത്തുള്ള മെമ്മറി ആക്‌സസ് ചെയ്‌ത് ബാഹ്യ കോഡും ഡാറ്റയുമായി ജാവ പ്രോഗ്രാമുകളുടെ ഇടപെടൽ അനുവദിക്കുന്ന FFM (ഫോറിൻ ഫംഗ്‌ഷൻ & മെമ്മറി) API സുസ്ഥിരമാക്കി.
• പേരിടാത്ത വേരിയബിളുകൾക്കും പാറ്റേൺ പൊരുത്തപ്പെടുത്തലുകൾക്കുമുള്ള പിന്തുണ പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുന്നു - ഉപയോഗിക്കാത്തതും എന്നാൽ ആവശ്യമുള്ളതുമായ വേരിയബിളുകൾക്കും പാറ്റേണുകൾക്കും പകരം, നിങ്ങൾക്ക് ഇപ്പോൾ “_” പ്രതീകം വ്യക്തമാക്കാൻ കഴിയും. // was String pageName = മാറുക (പേജ്) { case GitHubIssuePage(var url, var content, var links, int issueNumber) -> “ISSUE #” + issueNumber; ...}; // ഇപ്പോൾ നിങ്ങൾക്ക് String pageName = മാറാൻ കഴിയും (പേജ്) { case GitHubIssuePage(_, _, _, int issueNumber) -> “ISSUE #” + issueNumber; };
• ജാവ ക്ലാസ് ഫയലുകൾ പാഴ്‌സ് ചെയ്യുന്നതിനും സൃഷ്ടിക്കുന്നതിനും പരിവർത്തനം ചെയ്യുന്നതിനും ക്ലാസ്-ഫയൽ API യുടെ പ്രാഥമിക നിർവ്വഹണം നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു. 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(). ആരംഭിക്കുന്നു("ഡീബഗ്"))) { classBuilder.with(ce);}} });
• ഈ ഫയലുകൾ പ്രത്യേകം കംപൈൽ ചെയ്യാതെയും ബിൽഡ് സിസ്റ്റം കോൺഫിഗർ ചെയ്യാതെയും ജാവ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാനുള്ള കഴിവ് ജാവ യൂട്ടിലിറ്റി നൽകുന്നു. വിവിധ ക്ലാസുകളുടെ കോഡ് പ്രത്യേക ഫയലുകളായി വേർതിരിക്കുന്ന പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നത് പുതിയ സവിശേഷത എളുപ്പമാക്കുന്നു. Prog.java: class Prog { public static void main(String[] args) {Helper.run(); } } Helper.java: class Helper {static void run() { System.out.println("Hello!"); } }

  ഉദാഹരണത്തിന്, "Prog.java", "Helper.java" എന്നീ രണ്ട് ഫയലുകൾ അടങ്ങുന്ന ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന്, ഇപ്പോൾ "java Prog.java" പ്രവർത്തിപ്പിച്ചാൽ മതിയാകും, അത് പ്രോഗ് ക്ലാസ് കംപൈൽ ചെയ്യും, ഹെൽപ്പർ ക്ലാസിലേക്കുള്ള ഒരു റഫറൻസ് നിർവ്വചിക്കും, ഹെൽപ്പർ ഫയൽ കണ്ടെത്തി കംപൈൽ ചെയ്യുക.

• സ്ട്രിംഗ് ടെംപ്ലേറ്റുകളുടെ രണ്ടാമത്തെ പ്രാഥമിക നിർവ്വഹണം ചേർത്തു, സ്ട്രിംഗ് ലിറ്ററലുകൾക്കും ടെക്സ്റ്റ് ബ്ലോക്കുകൾക്കും പുറമേ നടപ്പിലാക്കി. + ഓപ്പറേറ്റർ ഉപയോഗിക്കാതെ കണക്കുകൂട്ടിയ എക്സ്പ്രഷനുകളും വേരിയബിളുകളും ഉപയോഗിച്ച് ടെക്സ്റ്റ് സംയോജിപ്പിക്കാൻ സ്ട്രിംഗ് ടെംപ്ലേറ്റുകൾ നിങ്ങളെ അനുവദിക്കുന്നു. എക്സ്‌പ്രഷനുകളുടെ സബ്സ്റ്റിറ്റ്യൂഷൻ \{..} സബ്സ്റ്റിറ്റ്യൂഷനുകൾ ഉപയോഗിച്ചാണ് നടത്തുന്നത്, പകരം വയ്ക്കുന്ന മൂല്യങ്ങളുടെ കൃത്യത പരിശോധിക്കാൻ പ്രത്യേക ഹാൻഡ്ലറുകൾ കണക്ട് ചെയ്യാം. ഉദാഹരണത്തിന്, SQL എഞ്ചിൻ SQL കോഡിലേക്ക് പകരമുള്ള മൂല്യങ്ങൾ പരിശോധിച്ച് ഒരു java.sql. Statement ഒബ്‌ജക്റ്റ് ഔട്ട്‌പുട്ടായി നൽകുന്നു, അതേസമയം JSON പ്രോസസർ JSON സബ്‌സ്റ്റിറ്റ്യൂഷനുകളുടെ കൃത്യത നിരീക്ഷിക്കുകയും ഒരു JsonNode തിരികെ നൽകുകയും ചെയ്യുന്നു. സ്ട്രിംഗ് അന്വേഷണം = "തിരഞ്ഞെടുക്കുക * വ്യക്തിയിൽ നിന്ന് p എവിടെ p." + പ്രോപ്പർട്ടി + " = '" + മൂല്യം + "'"; // ആയിരുന്നു പ്രസ്താവന ചോദ്യം = SQL."""തിരഞ്ഞെടുക്കുക * വ്യക്തിയിൽ നിന്ന് p എവിടെ p.\{property} = '\{value}'"""; // ആയി
• x86_64, AArch64 പ്രോസസറുകളിൽ വെക്റ്റർ നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച് നടപ്പിലാക്കുന്ന വെക്റ്റർ കണക്കുകൂട്ടലുകൾക്ക് ഫംഗ്ഷനുകൾ നൽകിക്കൊണ്ട് വെക്റ്റർ API-യുടെ ഏഴാമത്തെ പ്രിവ്യൂ ചേർത്തു, കൂടാതെ ഒന്നിലധികം മൂല്യങ്ങളിലേക്ക് (SIMD) ഒരേസമയം പ്രവർത്തനങ്ങൾ പ്രയോഗിക്കാൻ അനുവദിക്കുന്നു. സ്കെയിലർ പ്രവർത്തനങ്ങളുടെ യാന്ത്രിക-വെക്‌ടറൈസേഷനായി ഹോട്ട്‌സ്‌പോട്ട് JIT കംപൈലറിൽ നൽകിയിരിക്കുന്ന കഴിവുകളിൽ നിന്ന് വ്യത്യസ്തമായി, സമാന്തര ഡാറ്റ പ്രോസസ്സിംഗിനായി വെക്‌ടറൈസേഷൻ വ്യക്തമായി നിയന്ത്രിക്കുന്നത് പുതിയ API സാധ്യമാക്കുന്നു.
• നിങ്ങളുടെ സ്വന്തം ഇൻ്റർമീഡിയറ്റ് പ്രവർത്തനങ്ങൾ നിർവചിക്കുന്നതിനെ പിന്തുണയ്ക്കുന്ന വിപുലീകൃത സ്ട്രീം API യുടെ പ്രാഥമിക നിർവ്വഹണം ചേർത്തിട്ടുണ്ട്, ആവശ്യമുള്ള ഡാറ്റാ പരിവർത്തനത്തിന് നിലവിലുള്ള ബിൽറ്റ്-ഇൻ ഇൻ്റർമീഡിയറ്റ് ഓപ്പറേഷനുകൾ പര്യാപ്തമല്ലാത്ത സന്ദർഭങ്ങളിൽ ഇത് ഉപയോഗപ്രദമാകും. പുതിയ ഇൻ്റർമീഡിയറ്റ് ഓപ്പറേഷൻ സ്ട്രീം::gather(Gatherer) ഉപയോഗിച്ച് നേറ്റീവ് ഹാൻഡ്‌ലറുകൾ ബന്ധിപ്പിച്ചിരിക്കുന്നു, ഇത് ഒരു ഉപയോക്താവ് വ്യക്തമാക്കിയ ഹാൻഡ്‌ലർ പ്രയോഗിച്ച് സ്ട്രീം ഘടകങ്ങളെ പ്രോസസ്സ് ചെയ്യുന്നു. 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]]
• സ്ട്രക്ചേർഡ് കൺകറൻസിക്കായുള്ള പരീക്ഷണാത്മക API-യുടെ രണ്ടാമത്തെ പതിപ്പ് പരീക്ഷണത്തിനായി നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു, ഇത് വിവിധ ത്രെഡുകളിൽ നടപ്പിലാക്കുന്ന ഒന്നിലധികം ടാസ്‌ക്കുകൾ ഒരൊറ്റ ബ്ലോക്കായി പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ മൾട്ടി-ത്രെഡഡ് ആപ്ലിക്കേഷനുകളുടെ വികസനം ലളിതമാക്കുന്നു.
• പബ്ലിക്/സ്റ്റാറ്റിക് ഡിക്ലറേഷനുകൾ ഒഴിവാക്കാനും ഒരു ക്ലാസ് ഡിക്ലറേഷനുമായി ബന്ധപ്പെട്ട മറ്റ് എൻ്റിറ്റികൾ പാസാക്കാനും കഴിയുന്ന "പ്രധാന" രീതിയുടെ പരോക്ഷമായി പ്രഖ്യാപിച്ച ക്ലാസുകളുടെയും പേരിടാത്ത സംഭവങ്ങളുടെയും രണ്ടാമത്തെ പ്രാഥമിക നിർവ്വഹണവും ചേർത്തു. // പബ്ലിക് ക്ലാസ്സ് ആയിരുന്നു HelloWorld { public static void main(String[] args) { System.out.println("Hello world!"); } } // ഇപ്പോൾ നിങ്ങൾക്ക് main() { System.out.println("ഹലോ, വേൾഡ്!") അസാധുവാക്കാം; }
• ത്രെഡുകളിലുടനീളം മാറ്റമില്ലാത്ത ഡാറ്റ പങ്കിടാനും ചൈൽഡ് ത്രെഡുകൾക്കിടയിൽ ഡാറ്റ കാര്യക്ഷമമായി കൈമാറ്റം ചെയ്യാനും അനുവദിക്കുന്ന സ്കോപ്പ്ഡ് മൂല്യങ്ങളുടെ രണ്ടാമത്തെ പ്രിവ്യൂ നടപ്പിലാക്കൽ ചേർത്തു (മൂല്യങ്ങൾ പാരമ്പര്യമായി ലഭിക്കുന്നു). ത്രെഡ്-ലോക്കൽ വേരിയബിളുകൾ മെക്കാനിസം മാറ്റിസ്ഥാപിക്കുന്നതിനായി സ്കോപ്പ്ഡ് മൂല്യങ്ങൾ വികസിപ്പിച്ചെടുക്കുന്നു, കൂടാതെ വളരെ വലിയ വെർച്വൽ ത്രെഡുകൾ (ആയിരക്കണക്കിന് അല്ലെങ്കിൽ ദശലക്ഷക്കണക്കിന് ത്രെഡുകൾ) ഉപയോഗിക്കുമ്പോൾ കൂടുതൽ കാര്യക്ഷമവുമാണ്. സ്കോപ്പ്ഡ് മൂല്യങ്ങളും ത്രെഡ്-ലോക്കൽ വേരിയബിളുകളും തമ്മിലുള്ള പ്രധാന വ്യത്യാസം, ആദ്യത്തേത് ഒരിക്കൽ എഴുതിയതാണ്, ഭാവിയിൽ മാറ്റാൻ കഴിയില്ല, ത്രെഡിൻ്റെ നിർവ്വഹണ കാലയളവ് വരെ മാത്രമേ ലഭ്യമാകൂ എന്നതാണ്.
• വലിയ നിരകളുള്ള വസ്തുക്കളുമായി പ്രവർത്തിക്കുമ്പോൾ പാരലൽ ഗാർബേജ് കളക്ടർ പ്രകടനം മെച്ചപ്പെടുത്തി. ഒപ്‌റ്റിമൈസേഷൻ ഒരു ഒബ്‌ജക്‌റ്റിനായി തിരയാൻ തുടങ്ങുന്നതിനു മുമ്പുള്ള കാലതാമസം 20% കുറയ്ക്കാൻ ഒബ്‌ജക്‌റ്റുകളുടെ വലിയ നിരകളുള്ള ചില പരിശോധനകളിൽ സാധ്യമാക്കി.

കൂടാതെ, ഒരു ഗ്രാഫിക്കൽ ഇൻ്റർഫേസ് JavaFX 22 ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള പ്ലാറ്റ്‌ഫോമിലേക്കുള്ള ഒരു അപ്‌ഡേറ്റിൻ്റെ പ്രസിദ്ധീകരണം നിങ്ങൾക്ക് ശ്രദ്ധിക്കാവുന്നതാണ്.

അവലംബം: opennet.ru