Canonical vydal (email, blog, YouTube) Ubuntu 24.04 LTS Noble Numbat. Přehled novinek v poznámkách k vydání a také příspěvcích na blogu: novinky v desktopu a novinky v bezpečnosti. Vydány byly také oficiální deriváty Edubuntu, Kubuntu, Lubuntu, Ubuntu Budgie, Ubuntu Cinnamon, Ubuntu Kylin, Ubuntu MATE, Ubuntu Studio, Ubuntu Unity a Xubuntu. Jedná se o 10. LTS verzi.
Na YouTube je k dispozici videozáznam z včerejšího Czech Open Source Policy Forum 2024.
Fossil (Wikipedie) byl vydán ve verzi 2.24. Jedná se o distribuovaný systém správy verzí propojený se správou chyb, wiki stránek a blogů s integrovaným webovým rozhraním. Vše běží z jednoho jediného spustitelného souboru a uloženo je v SQLite databázi.
Byla vydána nová stabilní verze 6.7 webového prohlížeče Vivaldi (Wikipedie). Postavena je na Chromiu 124. Přehled novinek i s náhledy v příspěvku na blogu. Vypíchnout lze Spořič paměti (Memory Saver) automaticky hibernující karty, které nebyly nějakou dobu používány nebo vylepšené Odběry (Feed Reader).
OpenJS Foundation, oficiální projekt konsorcia Linux Foundation, oznámila vydání verze 22 otevřeného multiplatformního prostředí pro vývoj a běh síťových aplikací napsaných v JavaScriptu Node.js (Wikipedie). V říjnu se verze 22 stane novou aktivní LTS verzí. Podpora je plánována do dubna 2027.
Byla vydána verze 8.2 open source virtualizační platformy Proxmox VE (Proxmox Virtual Environment, Wikipedie) založené na Debianu. Přehled novinek v poznámkách k vydání a v informačním videu. Zdůrazněn je průvodce migrací hostů z VMware ESXi do Proxmoxu.
R (Wikipedie), programovací jazyk a prostředí určené pro statistickou analýzu dat a jejich grafické zobrazení, bylo vydáno ve verzi 4.4.0. Její kódové jméno je Puppy Cup.
IBM kupuje společnost HashiCorp (Terraform, Packer, Vault, Boundary, Consul, Nomad, Waypoint, Vagrant, …) za 6,4 miliardy dolarů, tj. 35 dolarů za akcii.
Byl vydán TrueNAS SCALE 24.04 “Dragonfish”. Přehled novinek této open source storage platformy postavené na Debianu v poznámkách k vydání.
Oznámeny byly nové Raspberry Pi Compute Module 4S. Vedle původní 1 GB varianty jsou nově k dispozici také varianty s 2 GB, 4 GB a 8 GB paměti. Compute Modules 4S mají na rozdíl od Compute Module 4 tvar a velikost Compute Module 3+ a předchozích. Lze tak provést snadný upgrade.
Protože javovský garbage collector (GC) nevidí do našeho nativího kódu, je dobré mu pomáhat se správou paměti. Do určité úrovně složitosti kódu ale není zapotřebí se správou referencí zabývat. Pokud vytváříme jen málo objektů a nechceme si je uchovávat "na později", můžeme se spokojit jen s tím, že GC naše objekty zruší po návratu z nativní funkce zpět do Javy. Jakmile objekty vytváříme cyklicky nebo je potřebujeme při dalších voláních, tématika referencí je pro nás důležitá.
Máme tři typy referencí:
null
, jakmile jsou zrušeny všechny lokální a obyčejné globální referencePrvní pravidlo je, že všechna volání JNI, se kterými získáváme nový objekt, vracejí lokální referenci. Opomenutí této skutečnosti má za následek pády nebo nelogické a náhodné chování programu. Toto je tedy zásadní chyba:
jstring g_myDanglingString = NULL; void Java_test_TestNative_pokus(JNIEnv* env, jclass myClass, jstring str) { g_myDanglingString = str; // ŠPATNĚ! }
Korektní způsob je vytvořit si vlastní referenci a nezapomenout ji ve správný moment zrušit.
jstring g_mySafeString = NULL; void Java_test_TestNative_copy(JNIEnv* env, jclass myClass, jstring str) { g_mySafeString = env->NewGlobalRef(str); } void Java_test_TestNative_destroy(JNIEnv* env, jclass myClass) { env->DeleteGlobalRef(g_mySafeString); g_mySafeString = NULL; }
Vidíme tedy dvě jednoduché funkce JNI – NewGlobalRef
, které nám vytvoří novou globální referenci podle libovolné jiné reference. Protikladem je pak DeleteGlobalRef
, kterým naopak reference rušíme (jen ty globální). Ekvivalentem pro lokální reference je dle očekávání NewLocalRef
a DeleteLocalRef
.
void Java_test_TestNative_cycle(JNIEnv* env, jclass myClass) { int count = INT_MAX; for (int i=0; i<count; i++) { jstring str = env->NewStringUTF("cycle"); // ...pracujeme s objektem // uděláme si druhou referenci jstring theSameStr = env->NewLocalRef(str); // a uklízíme po sobě env->DeleteLocalRef(str); env->DeleteLocalRef(theSameStr); // od tohoto momentu je String předmětem GC } }
Pokud by count bylo nějaké relativně malé číslo, program by fungoval dobře i bez používání DeleteLocalRef
. S velkým číslem (jako INT_MAX
) by ale jistě zhavaroval, protože javovský stack lokálních referencí by takové množství referencí nepojmul. Rovnou se podíváme na vytváření vlastních zásobníků referencí a alternativní způsob řešení takového cyklu. Co by se v čistém C++ kódu s lokálními objekty na stacku řešilo pomocí obalení do „{“ a „}“, to v JNI řeší následující pár funkcí:
jint PushLocalFrame(jint capacity)
Vytvoří nám nový scope („{“), neboli zásobník lokálních referencí. Kapacita zásobníku bude alespoň capacity
referencí. Pokud operace uspěje, funkce vrátí nulu. V opačném případě došla paměť a čeká na nás výjimka OutOfMemoryException, kterou bychom měli zpracovat. O výjimkách si povíme v některém z dalších dílů.
jobject PopLocalFrame(jobject result)
Zruší poslední vytvořený scope („}“). Všechny lokální reference vytvořené od příslušného volání PushLocalFrame
budou zrušeny garbage collectorem. Pokud rušíme zásobník po volání funkce, která vrací nějaký Object, předáme tento jako volitelný argument a z druhé strany nám vyleze lokální reference na tuto návratovou hodnotu s platností v tomto scope.
Naší funkci s cyklem tedy můžeme přepsat takto:
void Java_test_TestNative_cycle(JNIEnv* env, jclass myClass) { int count = INT_MAX; for (int i=0; i<count; i++) { env->PushLocalFrame(10); jstring str = env->NewStringUTF("cycle"); // ...pracujeme s objektem // uděláme si druhou referenci jstring theSameStr = env->NewLocalRef(str); env->PopLocalFrame(NULL); // lokální reference od předchozího PushLocalFrame se zruší } }
Předvedeme si volání funkce s použitím její návratové hodnoty:
void Java_test_TestNative_outer(JNIEnv* env, jclass myClass) { // děláme nějakou práci // ..... // a rozhodneme se zavolat jinou funkci env->PushLocalFrame(10); jobject retval = native_inner(); retval = env->PopLocalFrame(retval); // Nyní můžeme retval bezpečně používat // objekt bude zrušen, jakmile Java_test_TestNative_outer skončí svou práci }
Pokud bychom „neprohnali“ retval přes PopLocalFrame
, měli bychom pak v rukou neplatnou referenci.
Abych pravdu řekl, nikdy jsem slabé globální reference nepoužil, a to ani ze strany C/C++, tak ani ze strany Javy (java.lang.ref.WeakReference). Díky nim se můžeme dozvědět, kdy byl nějaký objekt zrušen, a dokud existuje, tak jej můžeme používat. Toto chování může najít využití například při cachování.
V moment, kdy budou všechny lokální a běžné globální reference zrušeny, naše slabá reference bude ekvivalentní k null. Toto se ale může stát naprosto kdykoliv (na pozadí), proto není spolehlivé předpokládat, že reference nebude nulová, když ještě o řádek výš nebyla. Proto, než začneme nad slabou referencí provádět nějaká volání javovských metod, je pro odolnost proti race conditions nezbytné vytvořit si lokální či globální referenci. V případě, že bude objekt zrušen ještě před voláním NewLocalRef
nebo NewGlobalRef
na slabou referenci, vrátí tyto funkce NULL.
Samotnou slabou referenci pak musíme sami také zrušit, a to pro uvolnění paměti spojené s touto referencí na straně JNI; kvůli opomenuté slabé referenci ale nikdy nehrozí únik paměti na straně odkazovaného javovského objektu.
jweak g_myWeakRef = NULL; void Java_test_TestNative_call1(JNIEnv* env, jclass myClass, jobject someObject) { // Vytvoříme si slabou globální referenci a objekt si mezitím bude žít // vlastním životem g_myWeakRef = env->NewWeakGlobalRef(env, someObject); } void Java_test_TestNative_call2(JNIEnv* env, jclass myClass) { // Podíváme se, jestli je reference nulová a objekt už tedy neexistuje if (env->IsSameObject(myWeakRef, NULL) == JNI_TRUE) { cout << "Objekt uz neexistuje\n"; } else { // Víme, že objekt existoval v době volání IsSameObject // Teď už tomu ale může být jinak // Pokud chceme s objektem pracovat, můžeme přeskočit // volání IsSameObject a rovnou si vytvořit referenci jobject thatObject = env->NewLocalRef(g_myWeakRef); if (thatObject) cout << "Objekt nahle prestal existovat\n"; else ; // Můžeme bez obav pracovat s referencí } // Zrušíme naší slabou referenci env->DeleteWeakGlobalRef(g_myWeakRef); }
Jazyk C++ má tu výhodu, že si v něm můžeme snadno ulehčit práci s referencemi. Můj vlastní přístup je takový, že mám obalující třídu JObject, která se o reference stará automaticky. U podobných wrapper tříd je vždy nutné používat globální reference: jednak proto, že objekty v C++ mohou putovat volně mimo aktuální scope (dynamicky alokované objekty) a druhak pak nemusíme řešit nějaké místo na zásobníku lokálních referencí. Vše za nás vyřeší konstruktor, destruktor a kopírovací operátor. Takto by mohla vypadat zjednodušená kostra naší třídy:
class JObject { public: JObject(jobject obj = NULL) : m_obj(0) { if (obj) m_obj = env->NewGlobalRef(obj); } JObject(const JObject& that) : m_obj(0) { if (that.m_obj) m_obj = env->NewGlobalRef(that.m_obj); } virtual ~JObject() { if (m_obj) env->DeleteGlobalRef(m_obj); } JObject& operator=(jobject obj) { if (m_obj) env->DeleteGlobalRef(m_obj); if (obj) m_obj = env->NewGlobalRef(obj); else m_obj = 0; return *this; } // a tak dále... private: jobject m_obj; };
V příštím díle se vrhneme na načítání javovských tříd z nativního kódu a vytváření jejich instancí.
Nástroje: Tisk bez diskuse
Tiskni Sdílej:
JObject obj(jobj); obj = obj; // tady může být problém, protože nejprve vezmeš referenci a pak ji přidáš
*this = m_obj
.
env->NewGlobalRef(that.m_obj);
env->NewGlobalRef(obj);?
if (m_obj != obj) { /* ... */}
, nebo ještě lépe jako argument dal const JObject&
(to tam možná dříve bylo, vysvětlilo by se tím to that
). Ale ono je to stejně jedno, protože java nemá neznaménkové typy a je tedy nepoužitelná