Java teljesítmény - Java performance

Ez a cikk a Java platform teljesítményének általános bemutatása . A Java teljesítményével és általánosabban a Java nyelvvel kapcsolatos kritikákért lásd : Java kritika .

A szoftverfejlesztés során a Java programozási nyelvet történelmileg lassabban tekintették, mint a leggyorsabb 3. generációs gépelt nyelveket, mint például a C és a C ++ . Ennek fő oka, hogy egy másik nyelvet design, ahol fordítása után, a Java programok futnak a Java virtuális gép (JVM), nem pedig közvetlenül a számítógép processzora , mint a natív kód , akárcsak a C és C ++ programokat. A teljesítmény aggasztó volt, mert sok üzleti szoftver íródott Java-ban, miután a nyelv gyorsan népszerűvé vált az 1990-es évek végén és a 2000-es évek elején.

Az 1990-es évek vége óta a Java programok futtatási sebessége jelentősen javult a just-in-time fordítás (JIT) bevezetésével (1997-ben a Java 1.1 esetében ), a jobb kódelemzést támogató nyelvi funkciók hozzáadásával és a JVM optimalizálásával (például mint a HotSpot lesz a Sun JVM alapértelmezettje 2000 - ben). A Java bytecode hardveres futtatását - például az ARM Jazelle által kínált - futtatását is feltárták, hogy jelentős teljesítménybeli fejlesztéseket kínáljon.

A teljesítmény egy Java bytecode lefordított Java program függ, hogyan optimálisan a megadott feladatokat kezeli a fogadó Java virtuális gép (JVM), és hogy mennyire jól a JVM kihasználja a funkciók a számítógépes hardver és operációs rendszer (OS) ezzel. Így minden Java teljesítménytesztnek vagy összehasonlításnak mindig jelentenie kell a használt JVM verzióját, szállítóját, operációs rendszerét és hardverarchitektúráját. Hasonló módon az ekvivalens natív fordítású program teljesítménye a létrehozott gépi kód minőségétől függ, így a tesztnek vagy az összehasonlításnak jelentenie kell a használt fordító nevét, verzióját és szállítóját, valamint az aktivált fordító optimalizálási irányelveit. .

Virtuális gépoptimalizálási módszerek

Számos optimalizálás idővel javította a JVM teljesítményét. Bár a Java gyakran volt az első virtuális gép, amely sikeresen implementálta őket, más hasonló platformokon is gyakran használták őket.

Pont időben történő összeállítás

További információk: Pontos időben történő fordítás és HotSpot (virtuális gép)

A korai JVM-ek mindig értelmezték a Java bájtkódokat . Ennek nagy teljesítménybüntetése 10 és 20 közötti volt a Java esetében, szemben az átlagos alkalmazások C-jével. Ennek leküzdésére a just-in-time (JIT) fordítót vezették be a Java 1.1-be. Az összeállítás magas költségei miatt a HotSpot nevű hozzáadott rendszert vezették be a Java 1.2-ben, és alapértelmezetté tették a Java 1.3-ban. Ezen keretrendszer használatával a Java virtuális gép folyamatosan elemzi a program teljesítményét a gyakran vagy ismételten végrehajtott forró pontok szempontjából. Ezeket aztán optimalizálásra szánják , ami nagy teljesítményű végrehajtást eredményez, minimális rezsivel a kevésbé teljesítménykritikus kódhoz. Egyes referenciaértékek tízszeres sebességnövekedést mutatnak ezzel az eszközzel. Az időbeli korlátok miatt azonban a fordító nem tudja teljes mértékben optimalizálni a programot, így az így kapott program lassabb, mint a natív kód alternatívái.

Adaptív optimalizálás

További információk: Adaptív optimalizálás

Az adaptív optimalizálás a számítástechnika egyik olyan módszere, amely a program egyes részeinek dinamikus újrafordítását hajtja végre az aktuális végrehajtási profil alapján. Egyszerű megvalósítással az adaptív optimalizáló egyszerűen kompromisszumot hozhat az éppen időben elkészülő és értelmező utasítások között. Egy másik szinten az adaptív optimalizálás kihasználhatja a helyi adatkörülményeket az elágazások optimalizálása és a belső bővítés érdekében.

A Java virtuális gép , mint a HotSpot is deoptimize kódot korábban JITed. Ez lehetővé teszi az agresszív (és potenciálisan nem biztonságos) optimalizálás végrehajtását, miközben továbbra is képes lesz a kód későbbi optimalizálására és a biztonságos útra való visszalépésre.

Szemétgyüjtés

További információ: Szemétgyűjtés (informatika)

Az 1.0 és 1.1 Java virtuális gépek (JVM) mark-sweep gyűjtőt használtak , amely egy szemétszedés után felaprózhatja a kupacot . A Java 1.2-től kezdődően a JVM-ek generációs gyűjtővé váltak , amelynek sokkal jobb a töredezettségmentesítési viselkedése. A modern JVM-ek különféle módszereket alkalmaznak, amelyek tovább javítják a szemétszállítás teljesítményét.

Egyéb optimalizálási módszerek

Tömörített hopp

A tömörített opciók lehetővé teszik, hogy a Java 5.0+ 32 bites referenciákkal akár 32 GB halmot tudjon címezni. A Java nem támogatja az egyes bájtokhoz való hozzáférést, csak az alapértelmezés szerint 8 bájtos igazított objektumokat. Emiatt a kupac referencia legalacsonyabb 3 bitje mindig 0. Ha a 32 bites referenciák felbontását 8 bájtos blokkokra csökkentjük, a címezhető terület 32 ​​GB-ra növelhető. Ez jelentősen csökkenti a memóriahasználatot a 64 bites referenciákhoz képest, mivel a Java sokkal többet használ referenciákat, mint néhány nyelv, például a C ++. A Java 8 nagyobb igazításokat, például 16 bájtos igazítást támogat, akár 64 GB-os támogatáshoz 32 bites referenciákkal.

Split bytecode ellenőrzés

Osztály végrehajtása előtt a Sun JVM ellenőrzi Java bájtkódjait (lásd a bájtkód-ellenőrzőt ). Ezt az ellenőrzést lustán hajtják végre: az osztályok bájtkódjait csak akkor töltik be és ellenőrzik, amikor az adott osztály betöltődik és felhasználásra fel van készítve, és nem a program elején. Mivel azonban a Java osztálykönyvtárak szintén rendes Java osztályok, használatukkor ezeket is be kell tölteni, ami azt jelenti, hogy a Java program indítási ideje gyakran hosszabb, mint például a C ++ programok esetében.

A split-time verifikáció nevű módszert, amelyet először a Java platformon vezettek be, a Micro Edition (J2ME), a JVM a Java 6-os verziója óta használ . Két szakaszban osztja fel a Java bájtkódjának ellenőrzését :

  • Tervezési idő - amikor osztályt állítanak össze forrásból bájtkódig
  • Futásidejű - osztály betöltésekor.

A gyakorlatban ez a módszer úgy működik, hogy rögzíti azokat az ismereteket, amelyek a Java fordítóban vannak osztályfolyamatokkal, és a lefordított módszer bájtkódjait annotálja az osztályfolyamat-információk összefoglalásával. Ez nem teszi lényegesen kevésbé bonyolultvá a futásidejű ellenőrzést , de lehetővé teszi néhány parancsikont.

Meneküléselemzés és zárzúzódás

További információ: Lock (informatika) és Escape elemzés

A Java képes kezelni a többszálas nyelvet. A többszálas szálak egy olyan módszer, amely lehetővé teszi a programok számára, hogy egyszerre több folyamatot hajtsanak végre, így gyorsabb programokat állítsanak elő több processzorral vagy maggal rendelkező számítógépes rendszereken . Ezenkívül egy többszálú alkalmazás képes reagálni a bemenetre, még akkor is, ha hosszú futó feladatokat hajt végre.

A többszálas szálat használó programoknak azonban különös gondot kell fordítaniuk a szálak között megosztott objektumokra , zárolva a hozzáférést a megosztott módszerekhez vagy blokkokhoz, ha az egyik szál használja őket. A blokk vagy az objektum zárolása időigényes művelet az alapul szolgáló operációs rendszer szintű művelet jellege miatt (lásd az egyidejűség vezérlését és a zár részletességét ).

Mivel a Java könyvtár nem tudja, mely módszereket használja egynél több szál, a standard könyvtár mindig blokkolja a blokkokat, ha szükséges, többszálas környezetben.

A Java 6 előtt a virtuális gép mindig lezárta az objektumokat és blokkolja a program kérését, még akkor is, ha nem áll fenn annak a veszélye, hogy egy objektumot egyszerre két különböző szál módosít. Például ebben az esetben egy vector lokálist az egyes hozzáadási műveletek előtt lezártak annak biztosítására, hogy más szálak ne módosítsák (a vektor szinkronizálva van), de mivel szigorúan lokális a módszerhez, ez felesleges: 

public String getNames() {
     Vector<String> v = new Vector<>();
     v.add("Me");
     v.add("You");
     v.add("Her");
     return v.toString();
}

A Java 6-tól kezdve a kódblokkok és az objektumok csak szükség esetén zárolódnak, így a fenti esetben a virtuális gép egyáltalán nem zárná le a Vector objektumot.

A 6u23 verzió óta a Java támogatja a meneküléselemzést.

Regisztrációkiosztási fejlesztések

Mielőtt Java 6 , elosztása regiszterek nagyon kezdetleges a kliens virtuális gép (nem éltek át blokkok ), amely a probléma CPU tervez , amely kevesebb volt a processzor regiszterek elérhető, mint a x86s . Ha egy művelethez már nincs elérhető regiszter, akkor a fordítónak regiszterről memóriára (vagy memóriáról regisztrációra) kell másolnia , ami időbe telik (a regiszterekhez lényegesen gyorsabban lehet hozzáférni). A kiszolgáló virtuális gépe azonban színgráf - elosztót használt, és nem volt ilyen problémája.

A regisztráció kiosztásának optimalizálását a Sun JDK 6-ban vezették be; akkor lehetőség nyílt ugyanazon regiszterek használatára a blokkok között (ha van ilyen), csökkentve a memória hozzáférését. Ennek eredményeként egyes referenciaértékeknél a jelentett teljesítménynövekedés körülbelül 60% volt.

Osztályadatok megosztása

Az osztályadatok megosztása (a Sun által CDS-nek hívják) egy olyan mechanizmus, amely csökkenti a Java-alkalmazások indítási idejét, és csökkenti a memória lábnyomát is . A JRE telepítése után a telepítő egy osztálykészletet tölt be a rendszer JAR fájljából (az összes Java osztálykönyvtárat tartalmazó JAR fájl, az úgynevezett rt.jar) egy belső belső reprezentációba, és ezt az ábrázolást egy fájlba nevezi, amelyet msgstr "megosztott archívum". A későbbi JVM-meghívások során ez a megosztott archívum memóriában van feltérképezve , ezzel megtakarítva az osztályok betöltésének költségeit, és lehetővé téve ezen osztályok számára a JVM metaadatainak nagy részének megosztását több JVM-folyamat között.

Az indítási idő ennek megfelelő javulása nyilvánvalóbb a kis programok esetében.

A teljesítmény-fejlesztések története

További információk: Java verziótörténet

Az itt felsorolt ​​fejlesztéseken kívül a Java egyes kiadásai számos teljesítménybeli fejlesztést vezettek be a JVM és a Java alkalmazás programozási felületén (API).

JDK 1.1.6: Első just-in-time fordítás ( Symantec JIT-fordítója)

J2SE 1.2: Generációs gyűjtő használata .

J2SE 1.3: Pontos időben történő összeállítás a HotSpot részéről .

J2SE 1.4: Lásd itt , a Sun áttekintését teljesítménybeli fejlesztéseket 1,3 és 1,4 között változatban.

Java SE 5.0: Osztályadatok megosztása

Java SE 6:

Egyéb fejlesztések:

  • Java OpenGL Java 2D csővezeték sebességének fejlesztése
  • A Java 2D teljesítménye a Java 6-ban is jelentősen javult

Lásd még: A Sun áttekintése a Java 5 és Java 6 közötti teljesítményfejlesztésekről.

Java SE 6 10. frissítés

  • A Java Quick Starter csökkenti az alkalmazás indítási idejét azáltal, hogy az operációs rendszer indításakor a JRE-adatok egy részét a lemez gyorsítótárába tölti be .
  • A platform azon részei, amelyek szükségesek az internetről hozzáférhető alkalmazások futtatásához, amikor a JRE nincs telepítve, most először letöltésre kerülnek. A teljes JRE 12 MB, egy tipikus Swing alkalmazásnak csak 4 MB-ot kell letöltenie az induláshoz. A fennmaradó részeket ezután letölti a háttérben.
  • A grafikus teljesítmény javult a Windows rendszeren azáltal, hogy alapértelmezés szerint széleskörűen használta a Direct3D- t, és a grafikus processzor (GPU) árnyékolóival gyorsította a bonyolult Java 2D műveleteket.

Java 7

Számos teljesítményjavítás jelent meg a Java 7 esetében: A jövőben a teljesítmény javítását tervezik a Java 6 vagy a Java 7 frissítéséhez:

  • JVM támogatás biztosítása a dinamikus programozási nyelvekhez , a Da Vinci gépen ( többnyelvű virtuális gép) jelenleg végzett prototípus-munka nyomán ,
  • Fokozzák a meglévő konkurencia könyvtár kezelésével párhuzamos számítási on többmagos processzorok,
  • Engedje meg a JVM-nek, hogy az ügyfél és a kiszolgáló JIT fordítóit ugyanazon munkamenetben használja a többszintű fordításnak nevezett módszerrel:
    • Az ügyfelet indításkor használnák (mert indításkor és kis alkalmazások esetén is jó),
    • A kiszolgálót az alkalmazás hosszú távú futtatására használják (mert ez felülmúlja az ügyfél fordítóját).
  • Cserélje ki a meglévő egyidejűleg alacsony szüneteltetésű szemétgyűjtőt (más néven egyidejű jelölés-söpörés (CMS) gyűjtőt) egy új gyűjtővel, amelyet Garbage First (G1) néven biztosítanak az állandó szünetek biztosítása érdekében.

Összehasonlítás más nyelvekkel

Objektív módon összehasonlítva a Java program teljesítményét és egy ezzel egyenértékű, egy másik nyelven írt nyelvet, például a C ++ -ot, gondosan és átgondoltan összeállított referenciaértékre van szükség, amely összehasonlítja az azonos feladatokat végrehajtó programokat. A cél platform a Java bytecode fordító a Java platform és a bájtkód sem értelmezhető vagy lefordított gépi kódra a JVM. Más fordítók szinte mindig egy adott hardver és szoftver platformot céloznak meg, olyan gépi kódot állítva elő, amely gyakorlatilag változatlan marad a végrehajtás során. Nagyon eltérő és nehezen összehasonlítható forgatókönyvek adódnak ebből a két különböző megközelítésből: statikus és dinamikus összeállítások és újrafordítások , a futási környezetre vonatkozó pontos információk rendelkezésre állása és mások.

A Java-t gyakran éppen időben , futás közben állítja össze a Java virtuális gép , de idő előtt is összeállítható , akárcsak a C ++. Pontos időben történő összeállításakor a The Computer Language Benchmarks Game mikro-benchmarkjai a következőket jelzik teljesítményéről:

  • lassabban, mint az összeállított nyelvek, például a C vagy a C ++ ,
  • hasonló a többi, éppen időben összeállított nyelvhez, mint például a C # ,
  • sokkal gyorsabb, mint a hatékony natív kód-fordító ( JIT vagy AOT ) nélküli nyelvek , mint például a Perl , a Ruby , a PHP és a Python .

Program sebessége

A referenciaértékek gyakran mérik a kicsi, számszerűen intenzív programok teljesítményét. Néhány ritka valós programban a Java teljesíti a C-t. Az egyik példa a Jake2 (a Quake II klónja Java-ban írva, az eredeti GPL C kód fordításával) viszonyítási alapja . A Java 5.0 verzió egyes hardverkonfigurációkban jobban teljesít, mint C megfelelője. Bár nincs meghatározva, hogy miként mérték az adatokat (például ha az eredeti, 1997-ben összeállított Quake II futtatható fájlt használták, ami rossznak tekinthető, mivel a jelenlegi C fordítók jobb optimalizálást érhetnek el a Quake számára), megjegyzi, hogy ugyanaz a Java forráskód hatalmas sebességnövelést végezhet csak a virtuális gép frissítésével, amit 100% -os statikus megközelítéssel lehetetlen elérni.

Más programok esetében a C ++ megfelelő képes lényegesen gyorsabban futtatni, mint a Java megfelelő. A Google által 2011-ben végzett benchmark 10-es tényezőt mutatott a C ++ és a Java között. A másik véglet, egy 2012-ben 3D-s modellezési algoritmussal elvégzett tudományos teljesítménymutató azt mutatta, hogy a Java 6 JVM 1,09–1,91-szer lassabb, mint Windows alatt a C ++.

Néhány optimalizálás, amely Java és hasonló nyelveken lehetséges, bizonyos körülmények között nem lehetséges a C ++ nyelven:

  • A C stílusú mutató használata akadályozhatja az optimalizálást a mutatókat támogató nyelveken,
  • A menekülési elemzési módszerek használata korlátozott például a C ++ - ban, mivel egy C ++ fordító nem mindig tudja, hogy egy objektum módosul-e egy adott kódblokkban a mutatók miatt ,
  • A Java gyorsabban érheti el a származtatott példány metódusokat, mint a C ++, a C ++ extra virtuális táblázata miatt a származtatott virtuális módszerekhez. A C ++ nem virtuális módszerei azonban nem szenvednek v-tábla teljesítmény szűk keresztmetszeteitől, így a Java-hoz hasonló teljesítményt mutatnak.

A JVM processzorspecifikus optimalizálást vagy inline bővítést is képes végrehajtani . És a már összeállított vagy beillesztett kódok optimalizálásának képessége időnként agresszívabb optimalizálást tesz lehetővé, mint azok, amelyeket statikusan tipizált nyelvek végeznek külső könyvtári funkciók esetén.

A Java és a C ++ közötti mikrobarka- eredmények eredményei nagymértékben függenek attól, hogy mely műveleteket hasonlítják össze. Például a Java 5.0-val való összehasonlításkor:

Megjegyzések

Többmagos teljesítmény

A Java alkalmazások skálázhatóságát és teljesítményét többmagos rendszereken az objektum kiosztási sebessége korlátozza. Ezt a hatást néha "allokációs falnak" nevezik. A gyakorlatban azonban a modern szemétgyűjtő algoritmusok több magot használnak a szemétszállításhoz, ami bizonyos mértékben enyhíti ezt a problémát. Egyes szemétgyűjtőkről beszámolók szerint másodpercenként meghaladja a gigabájt kiosztási arányt, és léteznek olyan Java-alapú rendszerek, amelyeknek nem okoz gondot több száz CPU-mag és több száz GB méretű kupacok méretezése.

Az automatikus memóriakezelés a Java-ban lehetővé teszi a zár nélküli és megváltoztathatatlan adatstruktúrák hatékony felhasználását, amelyeket rendkívül nehéz vagy néha lehetetlen megvalósítani valamilyen szemétgyűjtés nélkül. A Java számos ilyen magas szintű struktúrát kínál a java.util.concurrent csomagban található szokásos könyvtárában, míg sok olyan nagy teljesítményű rendszerhez használt nyelv, mint a C vagy a C ++, még mindig hiányoznak.

Indítási idő

A Java indítási ideje gyakran jóval lassabb, mint sok nyelvnél, ideértve a C , C ++ , Perl vagy Python nyelveket is , mert sok osztályt (és mindenekelőtt a Platform Class könyvtárak osztályait ) be kell tölteni használatuk előtt.

Hasonló népszerű futásidőkhöz képest a Windows gépen futó kis programok esetében az indítási idő hasonlónak tűnik a Mono-hoz és kissé lassabb, mint a .NET-é .

Úgy tűnik, hogy az indítási idő nagy része az input-output (IO) kötött műveleteknek köszönhető, nem pedig a JVM inicializálásának vagy az osztályterhelésnek (az rt.jar osztály adatfájlja önmagában 40 MB, és a JVM-nek sok adatot kell keresnie ebben a nagy fájlban) . Egyes tesztek azt mutatták, hogy bár az új osztott bájtkódú ellenőrzési módszer nagyjából 40% -kal javította az osztályterhelést, a nagy programok csak körülbelül 5% -os javítását érte el az indításkor.

Apró javulás ugyan, de jobban látható azoknál a kicsi programoknál, amelyek egyszerű műveletet hajtanak végre, majd kilépnek, mert a Java platform adatbetöltése a program tényleges működésének többszörösét jelentheti.

A Java SE 6 10. frissítésével kezdve a Sun JRE egy Gyorsindítóval érkezik, amely az operációs rendszer indításakor előre betölti az osztály adatait, hogy az adatokat a lemez gyorsítótárából, nem pedig a lemezről szerezze be .

Az Excelsior JET a másik oldalról közelíti meg a problémát. A Startup Optimizer csökkenti az alkalmazás indításakor a lemezről beolvasandó adatok mennyiségét, és szekvenciálisabbá teszi az olvasásokat.

2004 novemberében nyilvánosan megjelent a Nailgun , egy "kliens, protokoll és szerver Java programok futtatásához a parancssorból, anélkül, hogy ez a JVM indítási költségeit okozná". A szkriptek első alkalommal bemutatják a JVM démonként történő használatának lehetőségét egy vagy több Java alkalmazás futtatásához JVM indítási költség nélkül. A Nailgun démon nem biztonságos: "az összes program ugyanazokkal a jogosultságokkal fut, mint a szerver". Ahol többfelhasználós biztonságra van szükség, a Nailgun különleges óvintézkedések nélkül nem megfelelő. Azok a szkriptek, amelyekben az alkalmazásonkénti JVM indítás dominálja az erőforrás-felhasználást, lásd egy-két nagyságrendű futásidejű teljesítményjavítást.

Memóriahasználat

A Java memóriahasználata sokkal magasabb, mint a C ++ memóriahasználata, mert:

  • Minden Java objektumhoz 8 bájt és minden tömbhöz 12 bájt tartozik. Ha egy objektum mérete nem 8 bájt többszöröse, akkor felfelé kerekítik a 8-as következő többszörösére. Ez azt jelenti, hogy az egy bájtos mezőt tartó objektum 16 bájtot foglal el, és 4 bájtos referenciára van szüksége. A C ++ egy mutatót (általában 4 vagy 8 bájt) is kioszt minden objektumhoz, amely osztály közvetlenül vagy közvetve deklarálja a virtuális függvényeket .
  • A cím-aritmetika hiánya jelenleg lehetetlenné teszi a memória-hatékony tárolók, például a szorosan elhelyezett struktúrák és az XOR-hoz kapcsolódó listák létrehozását ( az OpenJDK Valhalla projekt célja ezeknek a problémáknak a mérséklése, bár nem célja a mutató-aritmetika bevezetése; ez nem végezhető el szemétgyűjtő környezet).
  • A malloc-szal és az újval ellentétben a szemétgyűjtés átlagos teljesítményének általános költségei aszimptotikusan a nullához (pontosabban egy CPU-ciklushoz) közelítenek, ahogy a kupac mérete növekszik.
  • A Java osztálykönyvtár egyes részeit a program végrehajtása előtt be kell tölteni (legalábbis a programon belül használt osztályokat). Ez jelentős memóriaterheléshez vezet a kis alkalmazások számára.
  • Mind a Java bináris, mind a natív újrafordítások általában a memóriában lesznek.
  • A virtuális gép jelentős memóriát használ.
  • A Java-ban egy összetett objektumot (A osztály, amely a B és C példányokat használja) a B és C allokált példányokra történő hivatkozások alapján hozzák létre. A C ++ - ban elkerülhető az ilyen típusú hivatkozások memória- és teljesítményköltsége, amikor a B és C példányok / vagy C létezik A-n belül.

A legtöbb esetben a C ++ alkalmazás kevesebb memóriát fogyaszt, mint egy egyenértékű Java alkalmazás, a Java virtuális gépének nagy költségei, az osztályterhelés és az automatikus memória átméretezése miatt. Azoknál a programoknál, amelyekben a memória kritikus tényező a nyelvek és a futási környezetek közötti választáshoz, költség-haszon elemzésre van szükség.

Trigonometrikus függvények

A trigonometrikus függvények teljesítménye rossz a C-hez képest, mert a Java szigorú előírásokkal rendelkezik a matematikai műveletek eredményeire vonatkozóan, amelyek nem feltétlenül felelnek meg az alapul szolgáló hardveres megvalósításnak. Az x87 lebegőpontos részhalmazon a Java az 1.4 óta argumentumcsökkentést hajt végre a szoftverben a sin és cos miatt, ami nagy teljesítménybeli ütést eredményez a tartományon kívüli értékeknél. A JDK (11 és újabb) jelentős előrelépést mutat a trigonometrikus függvények értékelésének sebességében a JDK 8-hoz képest.

Java natív interfész

A Java Native Interface magas rezsit igényel, ami költségessé teszi a JVM-en futó kód és a natív kód közötti határ átlépését. A Java Native Access (JNA) a Java programoknak egyszerű hozzáférést biztosít a natív megosztott könyvtárakhoz ( Windows-on a dinamikus linkű könyvtár (DLL-ek)), csak Java-kódon keresztül, JNI vagy natív kód nélkül. Ez a funkcionalitás összehasonlítható a Windows Platform / Invoke és a Python cypjeivel. A hozzáférés futás közben dinamikus, kódgenerálás nélkül. Ennek azonban költsége van, és a JNA általában lassabb, mint a JNI.

Felhasználói felület

A swinget lassabban észlelték, mint a natív widget eszközkészleteket , mert a widgetek renderelését a tiszta Java 2D API-ra ruházza át . A Swing és a Standard Widget Toolkit teljesítményét összehasonlító referenciaértékek , amelyek a renderelést az operációs rendszer natív GUI könyvtárainak adják át, nem mutatnak egyértelmű nyertest, és az eredmények nagymértékben függenek a kontextustól és a környezettől. Ezenkívül a Swing helyettesítésére szánt újabb JavaFX keretrendszer a Swing számos velejáró problémájával foglalkozik.

Használja nagy teljesítményű számítástechnikához

Vannak, akik úgy vélik, hogy a nagy teljesítményű számítástechnika (HPC) Java-teljesítménye hasonló a Fortran-hoz a számításigényes referenciaértékeknél, de a JVM-eknek még mindig vannak skálázhatósági problémái az intenzív kommunikáció hálózat-számítási hálózaton történő végrehajtása során.

A Java-ban írt nagy teljesítményű számítástechnikai alkalmazások azonban nyertek benchmark versenyeket. 2008-ban és 2009-ben egy Apache Hadoop (Java-ban írt, nyílt forráskódú, nagy teljesítményű számítástechnikai projekt) alapú fürt képes a leggyorsabban terabájtos és petabájtos egész számok rendezésére. A versengő rendszerek hardverbeállítása azonban nem volt rögzítve.

Programozási versenyeken

A Java-ban lévő programok lassabban indulnak el, mint a többi fordított nyelven. Így egyes online bírói rendszerek, nevezetesen a kínai egyetemek házigazdája, hosszabb időbeli korlátokat alkalmaznak arra, hogy a Java programok igazságosak legyenek a Java-t használó versenyzőkkel szemben.

Lásd még

Hivatkozások

Külső linkek