Philip Withnall
philip.withnall@collabora.co.uk 2014 – 2015
Hlavní kontext GLib, vyvolání funkcí v jiných vláknech a smyčka událostí

# Hlavní kontexty GLib

#

        Shrnutí

          K vyvolání funkcí z jiných vláknech použijte funkci g_main_context_invoke_full(), která předpokládá, že každé vlákno má výchozí hlavní kontext, který běží po celou dobu existence vlákna ()
          Ke spuštění funkce na pozadí bez starostí o použití konkrétního vlákna použijte GTask ()
          Nešetřete používáním asercí ke kontrole, který kontext spouští kterou funkci, a přidávejte tyto aserce hned při prvním psaní kódu. ()
          Výslovně zdokumentujte, ve kterém kontextu funkce očekává, že bude volána, zpětné volání vyvoláno a signál vyslán ()
          Dávejte si pozor na g_idle_add() a podobné funkce, které implicitně používají globální výchozí hlavní kontext ()

# Co je to `GMainContext`?

`GMainContext` je zobecněná implementace smyčky událostí, která je vhodná pro implementaci skupinových V/V souborových operací nebo systému widgetů založeného na událostech (jako je GTK+). Je jádrem většiny aplikací GLib. Pochopení `GMainContext` vyžaduje pochopení poll() a skupinových V/V.

`GMainContext` má sadu objektů `GSource`, které jsou k němu „připojené“. O každém z nich můžeme přemýšlet jako o očekávané události s přiřazenou funkcí zpětného volání, která bude vyvolána, když je událost přijata, nebo obdobně, jako o sadě popisovačů souborů, které se mají kontrolovat. Událostí může být například doběhnutí časovače nebo přijetí dat na soketu. Každá jednotlivá iterace smyčky události:

Připraví zdroje, přičemž určí, jestli je některý z nich připraven okamžitě vysílat.

Seskupí zdroje a zablokuje aktuální vlákno, dokud není přijata událost pro jeden ze zdrojů.

Zkontroluje, který ze zdrojů přijal událost (může jich být několik).

Vyšle zpětná volání z těchto zdrojů.

Velmi dobře je to vysvětlené v dokumentaci k GLib.

V jádru je `GMainContext` vlastně jen smyčka `poll()` s přípravnou, kontrolní a vysílací fází smyčky odpovídající běžnému úvodu a závěru v typické implementaci smyčky `poll()`, jako je například naslouchání 1 v tomto článku. Typicky je zapotřebí jistá míra složitosti v aplikacích s netriviálním využitím `poll()` ke sledování seznamů popisovačů souborů, které nás zajímají. `GMainContext` navíc přidává spoustu užitečné funkcionality, kterou varianta `poll()` nepodporuje. Z toho nejdůležitější je bezpečné použití ve více vláknech.

`GMainContext` je z hlediska vláken zcela bezpečný, což znamená, že `GSource` může být vytvořen v jednom vlákně a napojen na `GMainContext` běžící v jiném vlákně. (Viz také ). Typickým využitím je umožnit pracovnímu vláknu řídit, kterým soketům `GMainContext` naslouchá v centrálním V/V vlákně. Každý `GMainContext` je „získán“ vláknem pro každou iteraci, kterou prochází. Ostatní vlákna nemohou přes `GMainContext` iterovat bez jeho získání, což zajistí, že `GSource` a jeho popisovače souborů budou seskupeny jen jedním vláknem v každý okamžik (protože každý `GSource` je napojen nejvýše na jeden kontext `GMainContext`). `GMAinContext` může být během iterací napříč vlákny přehazován, ale je to nákladná operace.

`GMainContext` se používá místo `poll()` hlavně kvůli pohodlí, protože transparentně obsluhuje dynamickou správu polí s popisovači souborů předávanými do `poll()`, hlavně když se pracuje napříč více vlákny. Provádí se to zapouzdřením popisovačů polí do objektů `GSource`, které rozhodují, jestli mají být tyto popisovače souborů předány do volání `poll()` v každé „přípravné“ fázi iterace hlavního kontextu.

# Co je to `GMainLoop`?

Když si odmyslíme počítání referencí a zamykání, je `GMainLoop` v podstatě jen pár následujících řádků kódu (z `g_main_loop_run()`):

loop->is_running = TRUE; while (loop->is_running) { g_main_context_iteration (context, TRUE); }

Plus čtyři řádky v `g_main_loop_quit()`, které nastaví `loop->is_running = FALSE` a které způsobí, že se smyčka ukončí, jakmile doběhne aktuální iterace hlavního kontextu.

Proto je `GMainLoop` vhodným, a z hlediska vláken bezpečným, způsobem, jak spustit `GMainContext`, aby zpracovával události, dokud není dosažena požadovaná výstupní podmínka. V tu chvíli by měla být zavolána funkce `g_main_loop_quit()`. V programech s uživatelským rozhraním je to typicky uživatelovo kliknutí na „Ukončit“. V programech obsluhujících sokety do může být závěrečné zavření soketu.

Je důležité neplést si hlavní kontext s hlavní smyčkou. Hlavní kontext dělá většinu práce: připravuje seznam zdrojů, čeká na události a obesílá zpětná volání. Hlavní smyčka prostě jen opakovaně cykluje kontextem.

# Výchozí kontexty

Jednou z důležitých vlastností `GMainContext` je, že podporuje „výchozí“ kontext. Existují dvě úrovně výchozího kontextu: výchozí pro vlákno a výchozí globální. Globální (přístupný přes `g_main_context_default()`) je spuštěn GTK+ ve chvíli, kdy je zavoláno `gtk_main()`. Používá se také pro časovače (`g_timeout_add()`) a zpětná volání při nečinnosti (`g_idle_add()`) — ty nechceme obesílat, když neběží výchozí kontext! (Viz .)

Výchozí kontexty vláken byly do GLib přidány později (od verze 2.22) a obecně se používají pro V/V operace, které potřebují spouštět a obesílat zpětná volání ve vlákně. Zavoláním `g_main_context_push_thread_default()` před spuštěním V/V operace se nastaví výchozí kontext vlákna a V/V operace může přidat své zdroje do tohoto kontextu. Kontext pak může být spuštěn v nové hlavní smyčce ve V/V vlákně, což způsobí, že zpětná volání budou obesílána v zásobníku tohoto vlákna namísto v zásobníku vlákna, ve kterém běží globální výchozí kontext. To umožňuje, aby V/V operace běžely celé v odděleném vlákně bez vyloženého předávání konkrétního ukazatele `GMainContext` všude kolem.

Naopak, spuštěním dlouho trvající operace s nastaveným konkrétním výchozím kontextem vlákna, může volající kód zaručit, že zpětná volání operace budou vyslána v tomto kontextu, i když operace samotná běží v pracovním vlákně. Jde o princip stojící za `GTask`: když je vytvořen nový objekt `GTask`, uloží si reference na výchozí kontext aktuálního vlákna a a vyšle jeho dokončovací zpětné volání v tomto kontextu, i když úloha samotná běží pomocí `g_task_run_in_thread()`.

Například následující kód spustí `GTask`, který provede z vlákna souběžně dva zápisy. Zpětná volání pro zápisy budou obeslána v pracovním vlákně, zatímco zpětné volání z úlohy jako celku bude obesláno v `interesting_context`.

typedef struct { GMainLoop *main_loop; guint n_remaining; } WriteData;

/* Toto je voláno vždy ve stejném vlákně jako thread_cb(), protože je to * vždy vysláno v kontextu @worker_context. */ static void write_cb (GObject *source_object, GAsyncResult *result, gpointer user_data) { WriteData *data = user_data; GOutputStream *stream = G_OUTPUT_STREAM (source_object); GError *error = NULL; gssize len;

/* Dokončí zápis */ len = g_output_stream_write_finish (stream, result, &error); if (error != NULL) { g_error ("Error: %s", error->message); g_error_free (error); }

/* Zkontroluje, jestli byly dokončeny všechny paralelní operace */ write_data->n_remaining--;

if (write_data->n_remaining == 0) { g_main_loop_quit (write_data->main_loop); } }

/* Toto je voláno v novém vlákně */ static void thread_cb (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { /* Tento datový proud přichází z jiného místa v programu: */ GOutputStream *output_stream1, *output_stream; GMainContext *worker_context; GBytes *data; const guint8 *buf; gsize len;

/* Nastaví pracovní kontext pro zpětná volání zápisu */ worker_context = g_main_context_new (); g_main_context_push_thread_default (worker_context);

/* Nastaví zápis */ write_data.n_remaining = 2; write_data.main_loop = g_main_loop_new (worker_context, FALSE);

data = g_task_get_task_data (task); buf = g_bytes_get_data (data, &len);

g_output_stream_write_async (output_stream1, buf, len, G_PRIORITY_DEFAULT, NULL, write_cb, &write_data); g_output_stream_write_async (output_stream2, buf, len, G_PRIORITY_DEFAULT, NULL, write_cb, &write_data);

/* Spustí hlavní smyčku, dokud nejsou dokončeny oba zápisy */ g_main_loop_run (write_data.main_loop); g_task_return_boolean (task, TRUE); /* ignore errors */

g_main_loop_unref (write_data.main_loop);

g_main_context_pop_thread_default (worker_context); g_main_context_unref (worker_context); }

/* Toto může být voláno z kteréhokoliv vlákna. Jeho funkce @callback bude * vždy vyslána ve vlákně, které aktuálně vlastní @interesting_context */ void parallel_writes_async (GBytes *data, GMainContext *interesting_context, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task;

g_main_context_push_thread_default (interesting_context);

task = g_task_new (NULL, cancellable, callback, user_data); g_task_set_task_data (task, data, (GDestroyNotify) g_bytes_unref); g_task_run_in_thread (task, thread_cb); g_object_unref (task);

g_main_context_pop_thread_default (interesting_context); }

## Výchozí použití globálního výchozího hlavního kontextu

Několik funkcí přidává zdroje do globálního výchozího hlavního kontextu implicitně. Ty nesmí být použity v kódu vláken. Místo toho použijte `g_source_attach()` s `GSource` vytvořeným nahrazením funkce z tabulky níže.

Implicitní použití globálního výchozího hlavního kontextu znamená, že jsou funkce zpětného volání vyvolány v hlavním vlákně, typicky jako výsledek práce práce přenesené zpět z pracovního vlákna do hlavního vlákna.

Nepoužívat | Místo toho použít
--- | ---
`g_timeout_add()` | `g_timeout_source_new()`
`g_idle_add()` | `g_idle_source_new()`
`g_child_watch_add()` | `g_child_watch_source_new()`

Takže prodlevu v nějakém výpočtu v pracovním vlákně uděláte pomocí následujícího kódu:

static guint schedule_computation (guint delay_seconds) { GSource *source = NULL; GMainContext *context; guint id;

/* Získat kontext volání. */ context = g_main_context_get_thread_default ();

source = g_timeout_source_new_seconds (delay_seconds); g_source_set_callback (source, do_computation, NULL, NULL); id = g_source_attach (source, context); g_source_unref (source);

/* Když je potřeba, může být ID použito se stejným * @context ke zrušení naplánovaného výpočtu. */ return id; }

static void do_computation (gpointer user_data) { /* … */ }

# Použití `GMainContext` v knihovně

Na nejvyšší úrovni kód knihovny nesmí provádět změny v hlavním kontextu, který by mohly ovlivnit provádění aplikace, která používá knihovnu. Například změnou, když je vyslán `GSource` patřící aplikaci. Existuje řada správných zvyklostí, kterých je dobré se držet, aby tomu tak bylo.

Nikdy neprovádějte iteraci kontextu vytvořeného mimo knihovnu. Týká se to i výchozího globálního kontextu a výchozího kontextu vlákna. V opačném případě může být `GSource` vytvořený v aplikaci vyslán, když to aplikace neočekává, což způsobí problém s opětovným vstupem (reentrance) v kódu aplikace.

Před zahozením poslední reference z knihovny na kontext vždy odstraňte z hlavního kontextu zdroje `GSource`, především když mohou být vystaveny aplikaci (například jako výchozí vlákno). V opačném případě může aplikace zachovat referenci na hlavní kontext a pokračovat s jeho iteracemi po návratu z knihovny, což případně může způsobit nechtěné vysílání zdroje v knihovně. Je to to stejné, jako když nepředpokládáte, že zahození poslední reference z knihovny na hlavní kontext tento kontext finalizuje.

Pokud je knihovna navržena pro použití z více vláken nebo ve stylu kontextů, zdokumentujte vždy, ve kterém kontextu budou jednotlivá zpětná volání vysílána. Například „callbacks will always be dispatched in the context which is the thread-default at the time of the object’s construction“ (zpětná volání budou v době vytváření objektu vždy vyslána v kontextu, který je pro vlákno výchozí). Vývojáři používající API knihovny tuto informaci potřebují.

Používejte `g_main_context_invoke()`, abyste zajistili, že zpětné volání bude vysláno ve správném kontextu. Je to mnohem jednodušší, než ruční použití `g_idle_source_new()` k přenosu práce mezi kontexty. (Viz .)

Knihovny by nikdy neměly použít `g_main_context_default()` (nebo udělat to stejné předáním `NULL` do parametru typu `GMainContext`). Vždy uložte a výslovně použijte konkrétní `GMainContext`, i když často ukazuje na nějaký výchozí kontext. V případě potřeby to v budoucnu usnadní rozdělení kódu do vláken, aniž by to způsobilo těžko laditelné probléme vznikající zpětnými voláními vyvolanými v nesprávném kontextu.

Věci interně pište jako asynchronní (kde je to vhodné, tak pomocí `GTask`) a na nejvyšší úrovni API pak udržujte synchronní obalující funkci, kterou můžete implementovat pomocí volání `g_main_context_iteration()` na příslušný `GMainContext`. Pro zopakování: umožní to v budoucnu snadnější přepracování kódu. Ukázáno je to na příkladu výše: vlákno používá raději `g_output_stream_write_async()` namísto `g_output_stream_write()`. Místo toho může být použito pracovní vlákno a tím se může zjednodušit řetěz zpětných volání pro dlouhé posloupnosti asynchronních volání, ale za cenu nárustu složitosti ověřování kódu vůči souběhu podmínek.

Vždy si musí odpovídat počet vložení a vyjmutí výchozího hlavního kontextu vlákna: `g_main_context_push_thread_default()` a `g_main_context_pop_thread_default()`.

# Zajištění, aby funkce byly volány ve správném kontextu

„Ten pravý kontext“ je výchozí hlavní kontext vlákna pro vlákno, ve kterém má být funkce spuštěna. Předpokládá to typický případ, kdy každé vlákno má jeden hlavní kontext, ve kterém běží hlavní smyčka. Hlavní kontext v podstatě poskytuje práci nebo frontu zpráv pro vlákno – něco, v čem vlákno může pravidelně kontrolovat, jestli byla dokončena práce v jiném vlákně. Vložením zprávy do fronty – vyvoláním funkce v jiném hlavním kontextu – způsobí její případné vyslání v onom vlákně.

Například, když aplikace provádí nějaké dlouhé a na výkon procesoru náročné výpočty, měla by je naplánovat ve vlákně na pozadí, aby se neblokovaly aktualizace uživatelského rozhraní v hlavním vlákně. Může ale být zapotřebí výsledky výpočtu zobrazit v uživatelském rozhraní, takže funkce, která to bude mít na starosti, musí být po dokončení výpočtu zavolána v hlavním vlákně.

Mimo to může být výpočetní funkce omezena jen na jedno vlákno, aby se usnadnilo zamezení potřeby zamykat příliš dat při přístupu k nim. To předpokládá, že ostatní vlákna jsou implementována podobně a tudíž je k většině dat přistupováno jen z jediného vlákna a mezi vlákny se komunikuje pomocí předávání zpráv. Umožní to jednotlivým vláknům aktualizovat svá data, kdy se jim to hodí, což významně zjednodušuje zamykání.

U některých funkcí nemusí být žádný důvod se starat o to, ve kterém kontextu jsou spuštěné, protože jsou asynchronní a tudíž kontext neblokují. I přesto je rozumné vědět o tom, který kontext je použit, protože tyto funkce mohou vysílat signály nebo vyvolávat zpětná volání a z důvodu bezpečnosti vlákna je nutné vědět, která vlákna hodlají tyto obsluhy signálů nebo zpětná volání vyvolat.

Například pro průběh volání v `g_file_copy_async()` je zdokumentováno, že se volá ve výchozím vlákně hlavního kontextu v době volání inicializace.

## Principy vyvolání

Klíčový princip vyvolání funkce v konkrétním kontextu je jednoduchý a je probrán níže ve vysvětlení konceptu. V praxi by se místo toho měla použít vhodná metoda `g_main_context_invoke_full()`.

Do cílového `GMainContext`, který vyvolá funkci, když je obeslán, musí být přidán `GSource`. Tento `GSource` by většinou měl být zdroj pro nečinnost vytvořený pomocí `g_idle_source_new()`, ale nemusí tomu tak být nutně. Může jít například i o zdroj časovače, takže ona funkce bude spuštěna po nějaké prodlevě.

`GSource` bude vyslán hned, jak bude připraven, zavoláním funkce na zásobníku vlákna. V případě nečinnosti zdroje to bude hned, jak budou vyslány zdroje s vyšší prioritou – to lze vyladit pomocí parametru s prioritou zdroje v `g_source_set_priority()`. Typicky je zdroj následně zlikvidován, takže funkce se spustí jen jednou (a když znovu, tak to nemusí být ta samá situace).

Data mezi vlákny mohou být předávána jako `user_data` předaná do zpětného volání patřícího `GSource`. Nastaví se to na zdroji pomocí `g_source_set_callback()` společně s funkcí zpětného volání, která má být vyvolána. K dispozici je jen jeden ukazatel, takže když potřebujete předat více polí, musíte je zabalit do nějaké struktury, kterou si naalokujete.

Následující příklad demonstruje základní principy, ale existují vhodné metody probrané dále, které vše zjednodušují.

/* Hlavní funkce pro vlákno na pozadí thread1 */ static gpointer thread1_main (gpointer user_data) { GMainContext *thread1_main_context = user_data; GMainLoop *main_loop;

/* Nastaví kontext vlákna a navždy jej spustí */ g_main_context_push_thread_default (thread1_main_context);

main_loop = g_main_loop_new (thread1_main_context, FALSE); g_main_loop_run (main_loop); g_main_loop_unref (main_loop);

g_main_context_pop_thread_default (thread1_main_context); g_main_context_unref (thread1_main_context);

return NULL; }

/* Zapouzdření dat pro obsluhu více proměnných mezi vlákny */ typedef struct { gchar *some_string; /* owned */ guint some_int; GObject *some_object; /* owned */ } MyFuncData;

static void my_func_data_free (MyFuncData *data) { g_free (data->some_string); g_clear_object (&data->some_object); g_free (data); }

static void my_func (const gchar *some_string, guint some_int, GObject *some_object) { /* Zde se dělá něco náročného na čas a procesor! */ }

/* Převede zpětné volání nečinnosti na volání my_func() */ static gboolean my_func_idle (gpointer user_data) { MyFuncData *data = user_data;

my_func (data->some_string, data->some_int, data->some_object);

return G_SOURCE_REMOVE; }

/* Funkce, která má být volána v hlavním vlákně, aby plánovala volání * my_func() ve vlákně thread1 a přitom předala zadané parametry */ static void invoke_my_func (GMainContext *thread1_main_context, const gchar *some_string, guint some_int, GObject *some_object) { GSource *idle_source; MyFuncData *data;

/* Vytvoří zapouzdření dat pro předání všech požadovaných proměnných * mezi vlákny */ data = g_new0 (MyFuncData, 1); data->some_string = g_strdup (some_string); data->some_int = some_int; data->some_object = g_object_ref (some_object);

/* Vytvoří nový zdroj nečinnosti, nastaví my_func() jako zpětné volání * s nějakými daty, která budou předána mezi vlákny, zvýší prioritu a * a naplánuje ji napojením na kontext vlákna thread1 */ idle_source = g_idle_source_new (); g_source_set_callback (idle_source, my_func_idle, data, (GDestroyNotify) my_func_data_free); g_source_set_priority (idle_source, G_PRIORITY_DEFAULT); g_source_attach (idle_source, thread1_main_context); g_source_unref (idle_source); }

/* Hlavní funkce pro hlavní vlákno */ static void main (void) { GThread *thread1; GMainContext *thread1_main_context;

/* Spawn a background thread and pass it a reference to its * GMainContext. Retain a reference for use in this thread * too. */ thread1_main_context = g_main_context_new (); g_thread_new ("thread1", thread1_main, g_main_context_ref (thread1_main_context));

/* Zde je možné například nastavit uživatelské rozhraní */

/* Vyvolá my_func() v jiném vlákně */ invoke_my_func (thread1_main_context, "some data which needs passing between threads", 123456, some_object);

/* Zde se pokračuje v jiné práci */ }

Toto vyvolání je jednosměrné: zavolá se `my_func()` v `thread1`, ale neexistuje žádný způsob, jak vrátit hodnotu do hlavního vlákna. Když to potřebujete udělat, je potřeba znovu použít ten samý princip, tj. vyvolat funkci zpětného volání v hlavním vlákně. Jedná se o přímočaré rozšíření, které zde není potřeba rozebírat.

Aby byla zachována bezpečnost vlákna, musí být přístup k datům, ke kterým je potenciálně možné přistupovat z více vláken, vzájemně vyloučen pomocí mutexu. Data s potenciálním přístupem z více vláken: `thread1_main_context`, předaný při rozvětvení do `thread1_main`, a `some_object`, reference, do které jsou předána zapouzdřená data. Podstatné je, že GLib zaručuje, že `GMainContext` je z hlediska vláken bezpečný, takže sdílení `thread1_main_context` mezi vlákny je bezpečné. Příklad předpokládá, že ostatní kód přistupující k `some_object` je z hlediska vláken bezpečný.

Všimněte si, že k proměnným `some_string` a `some_int` nelze přistupovat z obou vláken, protože do vlákna `thread1` jsou místo originálů předávány jejich `kopie`. Jedná se o standardní techniku používanou z důvodu, aby křížové volání vláken bylo z hlediska vícevláknového zpracování bezpečné, aniž by bylo nutné zamykání. Také se tím předejte problémům se synchronizací při uvolňování `some_string`.

A obdobně, reference na `some_object` je přenášena do vlákna `thread1`, které řeší problém se synchronizací při likvidaci objektu (viz ).

Namísto jednodušší `g_idle_add()` je požita raději funkce `g_idle_source_new()`, takže lze určit připojený `GMainContext`.

## Užitečná metoda: `g_main_context_invoke_full()`

To vše se dá úžasně zjednodušit správnou metodou `g_main_context_invoke_full()`. Ta vyvolá zpětné volání tak, že `GMainContext` je během něj vlastněn. Vlastnění hlavního kontextu je téměř vždy to stejné, jako jej spustit, a tím pádem je funkce vyvolána ve vlákně, pro které je určený kontext výchozí.

V případě, že uživatelská data není nutné po návratu z volání uvolňovat pomocí zpětného volání `GDestroyNotify`, dá se místo toho použít funkce `g_main_context_invoke()`.

Upravený předchozí příklad – funkce `invoke_my_func()` může být nahrazena následovně:

static void invoke_my_func (GMainContext *thread1_main_context, const gchar *some_string, guint some_int, GObject *some_object) { MyFuncData *data;

/* Vytvoří zapouzdření dat pro předávání všech požadovaných proměnných * mezi vlákny */ data = g_new0 (MyFuncData, 1); data->some_string = g_strdup (some_string); data->some_int = some_int; data->some_object = g_object_ref (some_object);

/* Vyvolá funkci */ g_main_context_invoke_full (thread1_main_context, G_PRIORITY_DEFAULT, my_func_idle, data, (GDestroyNotify) my_func_data_free); }

Zamysleme se, co se stane, kdy je `invoke_my_func()` zavolána z `thread1`, místo z hlavního vlákna. V původní implementaci by byl nečinný zdroj přidán do kontextu vlákna `thread1` a vyslán v následující iteraci kontextu (předpokládáme, že nečeká vyslání s vyšší prioritou). Ve vylepšené implementaci si `g_main_context_invoke_full()` všimne, že uvedený kontext je již vlastněn vláknem (nebo jeho vlastnictví může získat), a zavolá přímo `my_func_idle()`, namísto aby zdroj připojovala ke kontextu a čekala na vyvolání následující iterace.

Na tomto jemném rozdílu v chování většinou nesejde, ale je dobré na něj pamatovat, protože může ovlivnit chování při blokování (`invoke_my_func()` by zabrala nezanedbatelné množství času, které by odpovídalo stejnému množství času jako u `my_func()` před návratem).

# Kontrola vláken

Je vhodné zdokumentovat, která funkce je volána ve kterém vlákně, a to formou aserce:

g_assert (g_main_context_is_owner (expected_main_context));

Když tohle vložíte na začátek každé funkce, selhání aserce zviditelní ty případy, kdy je funkce volána z nesprávného vlákna. Je mnohem jednodušší napsat tyto aserce v rané fázi vývoje kódu, než pak ladit souběh podmínek, který může při volání funkce z nesprávného vlákna snadno nastat.

Tuto techniku lze použít i u vysílání signálů a zpětných volání, díky čemuž se zvýší typová bezpečnost i kontrola, jestli je použit správný kontext. Upozorňujeme, že vyslání signálu přes `g_signal_emit()` je asynchronní a vůbec se netýká hlavního kontextu.

Například místo použití následujícího kódu při vyslání signálu:

guint param1; /* příklad libovolného parametru */ gchar *param2; guint retval = 0;

g_signal_emit_by_name (my_object, "some-signal", param1, param2, &retval);

Může být použito následující:

static guint emit_some_signal (GObject *my_object, guint param1, const gchar *param2) { guint retval = 0;

g_assert (g_main_context_is_owner (expected_main_context));

g_signal_emit_by_name (my_object, "some-signal", param1, param2, &retval);

return retval; }

# `GTask`

`GTask` poskytuje k vyvolání funkcí v jiných vláknech trochu odlišný přístup, který je zaměřen více na případy, kdy by funkce měla být spuštěna v nějakém vlákně na pozadí, ale není určeno, v kterém konkrétním.

`GTask` přebírá zapouzdřená data a funkci ke spuštění a poskytuje způsob, jak vrátit výsledky z této funkce. Postará se o vše potřebné ke spuštění funkce v libovolném vlákně náležejícímu do stejného svazku vláken sdílených interně v GLib.

Zkombinováním `g_main_context_invoke_full()` a `GTask` je možné spustit úlohu v konkrétním kontextu a bez většího úsilí vrátit její výsledek do aktuálního kontextu:

/* Toto bude vyvoláno ve vlákně thread1 */ static gboolean my_func_idle (gpointer user_data) { GTask *task = G_TASK (user_data); MyFuncData *data; gboolean retval;

/* Zavolá my_func() a vrácenou pravdivostní hodnotu propaguje * do hlavního vlákna */ data = g_task_get_task_data (task); retval = my_func (data->some_string, data->some_int, data->some_object); g_task_return_boolean (task, retval);

return G_SOURCE_REMOVE; }

/* Ať je toto vyvoláno z kteréhokoliv vlákna, vyvolá se funkce * @callback, jakmile je dokončena my_func() a vrátí výsledek */ static void invoke_my_func_with_result (GMainContext *thread1_main_context, const gchar *some_string, guint some_int, GObject *some_object, GAsyncReadyCallback callback, gpointer user_data) { MyFuncData *data;

/* Vytvoří zapouzdření dat pro předání všech požadovaných proměnných * mezi vlákny */ data = g_new0 (MyFuncData, 1); data->some_string = g_strdup (some_string); data->some_int = some_int; data->some_object = g_object_ref (some_object);

/* Vytvoří GTask pro obsluhu vráceného výsledku do hlavního výchozího * kontextu aktuálního vlákna */ task = g_task_new (NULL, NULL, callback, user_data); g_task_set_task_data (task, data, (GDestroyNotify) my_func_data_free);

/* Vyvolá funkci */ g_main_context_invoke_full (thread1_main_context, G_PRIORITY_DEFAULT, my_func_idle, task, (GDestroyNotify) g_object_unref); }