Java SE 22 પ્લેટફોર્મ અને OpenJDK 22 ઓપન રેફરન્સ અમલીકરણનું પ્રકાશન

છ મહિનાના વિકાસ પછી, ઓરેકલે Java SE 22 (જાવા પ્લેટફોર્મ, સ્ટાન્ડર્ડ એડિશન 22) પ્લેટફોર્મ બહાર પાડ્યું છે, જે ઓપનજેડીકે ઓપન સોર્સ પ્રોજેક્ટનો સંદર્ભ અમલીકરણ તરીકે ઉપયોગ કરે છે. કેટલીક અવમૂલ્યન સુવિધાઓને દૂર કરવાના અપવાદ સાથે, Java SE 22 જાવા પ્લેટફોર્મના અગાઉના પ્રકાશનો સાથે પછાત સુસંગતતા જાળવી રાખે છે - મોટા ભાગના અગાઉ લખાયેલા જાવા પ્રોજેક્ટ્સ જ્યારે નવા સંસ્કરણ હેઠળ ચલાવવામાં આવે ત્યારે ફેરફાર કર્યા વિના કામ કરશે. Java SE 22 (JDK, JRE, અને Server JRE) ના ઇન્સ્ટોલ-ટુ-ઇન્સ્ટોલ બિલ્ડ્સ Linux (x86_64, AArch64), Windows (x86_64), અને macOS (x86_64, AArch64) માટે તૈયાર છે. ઓપનજેડીકે પ્રોજેક્ટ દ્વારા વિકસાવવામાં આવેલ, જાવા 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 ગાર્બેજ કલેક્ટરમાં રિજન પિનિંગ માટે સપોર્ટનો સમાવેશ થાય છે, જે તમને કચરો કલેક્ટર દ્વારા ખસેડવામાં ન આવે તે માટે મેમરીમાં જાવા ઑબ્જેક્ટના સ્થાનને અસ્થાયી રૂપે ઠીક કરવાની મંજૂરી આપે છે અને આ ઑબ્જેક્ટ્સના સંદર્ભોને Java અને મૂળ કોડ વચ્ચે સુરક્ષિત રીતે પસાર કરવાની મંજૂરી આપે છે. પિનિંગ તમને લેટન્સી ઘટાડવા અને જેએનઆઈ (જાવા નેટિવ ઈન્ટરફેસ) ના નિર્ણાયક પ્રદેશોને નેટીવ કોડ સાથે એક્ઝિક્યુટ કરતી વખતે કચરાના સંગ્રહને અક્ષમ કરવાનું ટાળવા દે છે (આ વિભાગોને એક્ઝિક્યુટ કરતી વખતે, JVM એ રેસની પરિસ્થિતિઓને ટાળવા માટે તેમની સાથે સંકળાયેલ જટિલ વસ્તુઓને ખસેડવી જોઈએ નહીં). પિનિંગ કચરો કલેક્ટરના દૃષ્ટિકોણથી જટિલ વસ્તુઓને દૂર કરે છે, જે અનપિન કરેલા વિસ્તારોને સાફ કરવાનું ચાલુ રાખી શકે છે.
• સુપર(...) કૉલ કરતાં પહેલાં કન્સ્ટ્રક્ટરમાં એક્સપ્રેશન્સનો ઉલ્લેખ કરવાની મંજૂરી આપવા માટે પ્રારંભિક સુવિધા ઉમેરવામાં આવી છે, જો તે એક્સપ્રેશન્સ કન્સ્ટ્રક્ટર દ્વારા બનાવેલા ઉદાહરણનો સંદર્ભ ન આપે તો વારસાગત ક્લાસ કન્સ્ટ્રક્ટરમાંથી પેરેન્ટ ક્લાસ કન્સ્ટ્રક્ટરને સ્પષ્ટપણે કૉલ કરવા માટે વપરાય છે. વર્ગ આઉટર { રદબાતલ હેલો() { System.out.println("હેલો"); } વર્ગ આંતરિક { આંતરિક () { હેલો(); સુપર(); } } }
• FFM (ફોરેન ફંક્શન એન્ડ મેમરી) API ને સ્થિર કરવામાં આવ્યું છે, જે JNI (જાવા નેટિવ ઈન્ટરફેસ) નો ઉપયોગ કર્યા વિના, બાહ્ય લાઈબ્રેરીઓમાંથી ફંક્શન્સને કૉલ કરીને અને JVM બહાર મેમરી એક્સેસ કરીને બાહ્ય કોડ અને ડેટા સાથે જાવા પ્રોગ્રામ્સની ક્રિયાપ્રતિક્રિયાને મંજૂરી આપે છે.
• અનામી ચલો અને પેટર્ન મેચિંગ માટે સપોર્ટ સક્ષમ કરવામાં આવ્યો છે - જ્યારે કૉલ કરતી વખતે બિનઉપયોગી પરંતુ જરૂરી ચલો અને પેટર્નને બદલે, તમે હવે "_" અક્ષરનો ઉલ્લેખ કરી શકો છો. // હતી સ્ટ્રિંગ પૃષ્ઠનામ = સ્વિચ (પૃષ્ઠ) { કેસ GitHubIssuePage(var url, var સામગ્રી, var લિંક્સ, int issueNumber) -> “ISSUE #” + issueNumber; ... }; // હવે તમે String pageName = સ્વિચ (પાનું) { કેસ GitHubIssuePage(_, _, _, int issueNumber) -> “ISSUE #” + issueNumber; };
• ક્લાસ-ફાઇલ API નું પ્રારંભિક અમલીકરણ જાવા ક્લાસ ફાઇલોને પાર્સિંગ, જનરેટ અને કન્વર્ટ કરવા માટે પ્રસ્તાવિત છે. ClassFile cf = ClassFile.of(); ClassModel classModel = cf.parse(bytes); byte[] newBytes = cf.build(classModel.thisClass().asSymbol(), classBuilder -> { (ClassElement ce : classModel) { if (!(ce instance of MethodModel mm && mm.methodName().stringValue(). startsWith("ડિબગ"))) { classBuilder.with(ce);
• જાવા યુટિલિટી જાવા પ્રોગ્રામ્સને ચલાવવાની ક્ષમતા પૂરી પાડે છે, જે આ ફાઇલોને અલગથી કમ્પાઇલ કર્યા વિના અને બિલ્ડ સિસ્ટમને રૂપરેખાંકિત કર્યા વિના, ઘણી કોડ ફાઇલો અથવા પ્રી-કમ્પાઇલ ક્લાસ લાઇબ્રેરીઓના સ્વરૂપમાં પૂરા પાડવામાં આવે છે. નવી સુવિધા એવા પ્રોગ્રામ્સ ચલાવવાનું સરળ બનાવે છે જેમાં વિવિધ વર્ગોના કોડને અલગ-અલગ ફાઇલોમાં વિભાજિત કરવામાં આવે છે. Prog.java: વર્ગ પ્રોગ { પબ્લિક સ્ટેટિક વોઈડ મેઈન(સ્ટ્રિંગ[] આર્ગ્સ) { Helper.run(); } } Helper.java: વર્ગ હેલ્પર { static void run() { System.out.println("હેલો!"); } }

  ઉદાહરણ તરીકે, બે ફાઈલો "Prog.java" અને "Helper.java" ધરાવતા પ્રોગ્રામને ચલાવવા માટે હવે "java Prog.java" ચલાવવા માટે પૂરતું છે, જે પ્રોગ ક્લાસને કમ્પાઈલ કરશે, હેલ્પર ક્લાસનો સંદર્ભ વ્યાખ્યાયિત કરશે, હેલ્પર ફાઇલ શોધો અને કમ્પાઇલ કરો અને મુખ્ય પદ્ધતિને કૉલ કરો.

• સ્ટ્રિંગ ટેમ્પ્લેટ્સનું બીજું પ્રારંભિક અમલીકરણ ઉમેર્યું, સ્ટ્રિંગ લિટરલ્સ અને ટેક્સ્ટ બ્લોક્સ ઉપરાંત અમલમાં મૂકવામાં આવ્યું. શબ્દમાળા નમૂનાઓ તમને + ઓપરેટરનો ઉપયોગ કર્યા વિના ગણતરી કરેલ અભિવ્યક્તિઓ અને ચલો સાથે ટેક્સ્ટને જોડવાની મંજૂરી આપે છે. અભિવ્યક્તિઓનું અવેજીકરણ અવેજી \{..} નો ઉપયોગ કરીને હાથ ધરવામાં આવે છે, અને અવેજી મૂલ્યોની શુદ્ધતા ચકાસવા માટે વિશિષ્ટ હેન્ડલર્સ કનેક્ટ કરી શકાય છે. ઉદાહરણ તરીકે, SQL એન્જીન એસક્યુએલ કોડમાં બદલાઈ રહેલા મૂલ્યોને તપાસે છે અને આઉટપુટ તરીકે java.sql.Statement ઑબ્જેક્ટ પરત કરે છે, જ્યારે JSON પ્રોસેસર JSON અવેજીની શુદ્ધતા પર નજર રાખે છે અને JsonNode પરત કરે છે. સ્ટ્રિંગ ક્વેરી = "વ્યક્તિમાંથી પસંદ કરો * જ્યાં p." + મિલકત + " = '" + મૂલ્ય + "'"; // સ્ટેટમેન્ટ ક્વેરી = SQL હતી."""Person માંથી પસંદ કરો p WHERE p.\{property} = '\{value}'"""; // બન્યા
• વેક્ટર API નું સાતમું પૂર્વાવલોકન ઉમેરવામાં આવ્યું છે, જે x86_64 અને AArch64 પ્રોસેસર્સ પર વેક્ટર સૂચનાઓનો ઉપયોગ કરીને કરવામાં આવતી વેક્ટર ગણતરીઓ માટેના કાર્યો પૂરા પાડે છે અને ઑપરેશન્સને એકસાથે બહુવિધ મૂલ્યો (SIMD) પર લાગુ કરવાની મંજૂરી આપે છે. સ્કેલર ઑપરેશન્સના ઑટો-વેક્ટરાઇઝેશન માટે હોટસ્પોટ JIT કમ્પાઇલરમાં પૂરી પાડવામાં આવેલી ક્ષમતાઓથી વિપરીત, નવું API સમાંતર ડેટા પ્રોસેસિંગ માટે વેક્ટરાઇઝેશનને સ્પષ્ટપણે નિયંત્રિત કરવાનું શક્ય બનાવે છે.
• વિસ્તૃત સ્ટ્રીમ API નું પ્રારંભિક અમલીકરણ ઉમેરવામાં આવ્યું છે જે તમારી પોતાની મધ્યવર્તી કામગીરીને વ્યાખ્યાયિત કરવાને સમર્થન આપે છે, જે એવા કિસ્સાઓમાં ઉપયોગી થઈ શકે છે કે જ્યાં વર્તમાન બિલ્ટ-ઇન મધ્યવર્તી કામગીરી ઇચ્છિત ડેટા ટ્રાન્સફોર્મેશન માટે પર્યાપ્ત નથી. મૂળ હેન્ડલર્સ નવા મધ્યવર્તી ઓપરેશન સ્ટ્રીમ::ગેધર(ગેધરર) નો ઉપયોગ કરીને જોડાયેલા છે, જે સ્ટ્રીમ તત્વોને તેમના પર વપરાશકર્તા-નિર્દિષ્ટ હેન્ડલર લાગુ કરીને પ્રક્રિયા કરે છે. jshell> Stream.of(1,2,3,4,5,6,7,8,9).ગેધર(નવી વિન્ડોફિક્સ્ડ(3)).toList() $1 ==> [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
• સ્ટ્રક્ચર્ડ કન્કરન્સી માટે પ્રાયોગિક APIનું બીજું સંસ્કરણ પરીક્ષણ માટે પ્રસ્તાવિત કરવામાં આવ્યું છે, જે એક જ બ્લોક તરીકે વિવિધ થ્રેડોમાં એક્ઝિક્યુટ કરાયેલા બહુવિધ કાર્યોની પ્રક્રિયા કરીને મલ્ટિ-થ્રેડેડ એપ્લિકેશનના વિકાસને સરળ બનાવે છે.
• અસ્પષ્ટ રીતે ઘોષિત વર્ગો અને "મુખ્ય" પદ્ધતિના અનામી ઉદાહરણોનું બીજું પ્રારંભિક અમલીકરણ ઉમેર્યું, જે જાહેર/સ્થિર ઘોષણાઓ, દલીલોની શ્રેણી પસાર કરીને, અને વર્ગ ઘોષણા સાથે સંકળાયેલ અન્ય એકમોને વિતરિત કરી શકે છે. // પબ્લિક ક્લાસ હેલોવર્લ્ડ { પબ્લિક સ્ટેટિક વોઈડ મેઈન(સ્ટ્રિંગ[] એર્ગ્સ) { System.out.println("હેલો વર્લ્ડ!"); } } // હવે તમે main() { System.out.println("હેલો, વર્લ્ડ!") રદબાતલ કરી શકો છો; }
• સ્કોપેડ વેલ્યુઝનું બીજું પૂર્વાવલોકન અમલીકરણ ઉમેર્યું, જે પરિવર્તનક્ષમ ડેટાને સમગ્ર થ્રેડોમાં શેર કરવાની મંજૂરી આપે છે અને ચાઇલ્ડ થ્રેડો (મૂલ્યો વારસાગત છે) વચ્ચે અસરકારક રીતે વિનિમય કરવામાં આવે છે. થ્રેડ-લોકલ વેરિયેબલ મિકેનિઝમને બદલવા માટે સ્કોપેડ વેલ્યુ વિકસાવવામાં આવી રહી છે અને જ્યારે ખૂબ મોટી સંખ્યામાં વર્ચ્યુઅલ થ્રેડો (હજારો અથવા લાખો થ્રેડો)નો ઉપયોગ કરવામાં આવે ત્યારે તે વધુ કાર્યક્ષમ છે. સ્કોપેડ વેલ્યુ અને થ્રેડ-લોકલ વેરિએબલ વચ્ચેનો મુખ્ય તફાવત એ છે કે પહેલાના એક વાર લખવામાં આવે છે, ભવિષ્યમાં બદલી શકાતા નથી અને માત્ર થ્રેડના અમલના સમયગાળા માટે જ ઉપલબ્ધ રહે છે.
• સમાંતર ગાર્બેજ કલેક્ટરે ઑબ્જેક્ટના મોટા એરે સાથે કામ કરતી વખતે કામગીરીમાં સુધારો કર્યો છે. ઑપ્ટિમાઇઝેશનને કારણે ઑબ્જેક્ટની મોટી એરે સાથેના કેટલાક પરીક્ષણોમાં ઑબ્જેક્ટ શોધવાનું શરૂ કરતાં પહેલાં વિલંબને 20% ઘટાડવાનું શક્ય બન્યું.

વધુમાં, તમે ગ્રાફિકલ ઈન્ટરફેસ JavaFX 22 સાથે એપ્લિકેશન બનાવવા માટે પ્લેટફોર્મ પર અપડેટના પ્રકાશનની નોંધ લઈ શકો છો.

સોર્સ: opennet.ru