<page xmlns="http://projectmallard.org/1.0/" xmlns:its="http://www.w3.org/2005/11/its" xmlns:xi="http://www.w3.org/2003/XInclude" type="topic" id="main-contexts" xml:lang="cs">

  <info>

    <link type="guide" xref="index#specific-how-tos"/>

    <credit type="author copyright">

      <name>Philip Withnall</name>

      <email its:translate="no">philip.withnall@collabora.co.uk</email>

      <years>2014 – 2015</years>

    </credit>

    <include xmlns="http://www.w3.org/2001/XInclude" href="cc-by-sa-3-0.xml"/>

    <desc>Hlavní kontext GLib, vyvolání funkcí v jiných vláknech a smyčka událostí</desc>

  </info>

  <title>Hlavní kontexty GLib</title>

  <synopsis>

    <title>Shrnutí</title>

    <list>

      <item>
K vyvolání funkcí z jiných vláknech použijte funkci <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-main-context-invoke-full">g_main_context_invoke_full()</link>, která předpokládá, že každé vlákno má výchozí hlavní kontext, který běží po celou dobu existence vlákna (<link xref="#g-main-context-invoke-full"/>)
</item>

      <item>
Ke spuštění funkce na pozadí bez starostí o použití konkrétního vlákna použijte <link href="https://developer.gnome.org/gio/stable/GTask.html">GTask</link> (<link xref="#gtask"/>)
</item>

      <item>
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. (<link xref="#checking-threading"/>)
</item>

      <item>
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 (<link xref="#using-gmaincontext-in-a-library"/>)
</item>

      <item>
Dávejte si pozor na g_idle_add() a podobné funkce, které implicitně používají globální výchozí hlavní kontext (<link xref="#implicit-use-of-the-global-default-main-context"/>)
</item>

    </list>

  </synopsis>

  <section id="what-is-gmaincontext">

    <title>Co je to GMainContext?</title>

    
<link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GMainContext">GMainContext</link> je zobecněná implementace <link href="http://en.wikipedia.org/wiki/Event_loop">smyčky událostí</link>, 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í <link href="man:poll(2)">poll()</link> a skupinových V/V.

    
GMainContext má sadu objektů <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource">GSource</link>, 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:

    <list type="enumerated">

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

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

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

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

    </list>

    
<link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#mainloop-states">Velmi dobře je to vysvětlené</link> v <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSourceFuncs">dokumentaci k GLib</link>.

    
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 <link href="http://www.linux-mag.com/id/357/">tomto článku</link>. 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é <link xref="threading"/>). 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.

  </section>

  <section id="what-is-gmainloop">

    <title>Co je to GMainLoop?</title>

    
Když si odmyslíme počítání referencí a zamykání, je <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GMainLoop">GMainLoop</link> v podstatě jen pár následujících řádků kódu (z <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-main-loop-run">g_main_loop_run()</link>):

    loop->is_running = TRUE;

while (loop->is_running)

  {

    g_main_context_iteration (context, TRUE);

  }

    
Plus čtyři řádky v <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-main-loop-quit">g_main_loop_quit()</link>, 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.

  </section>

  <section id="default-contexts">

    <title>Výchozí kontexty</title>

    
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 <link xref="#implicit-use-of-the-global-default-main-context"/>.)

    
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 <link href="https://developer.gnome.org/gio/stable/GTask.html">GTask</link>: 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í <link href="https://developer.gnome.org/gio/stable/GTask.html#g-task-run-in-thread">g_task_run_in_thread()</link>.

    <example>

      
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);

}

    </example>

    <section id="implicit-use-of-the-global-default-main-context">

      <title>Výchozí použití globálního výchozího hlavního kontextu</title>

      
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()

      <example>

        
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)

{

  /* … */

}

      </example>

    </section>

  </section>

  <section id="using-gmaincontext-in-a-library">

    <title>Použití GMainContext v knihovně</title>

    
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í <link href="http://en.wikipedia.org/wiki/Reentrancy_%28computing%29">problém s opětovným vstupem (reentrance)</link> 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 <link xref="#ensuring-functions-are-called-in-the-right-context"/>.)

    
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 vždy pište interně jako asynchronní (kde je to vhodné, tak pomocí <link xref="#gtask">GTask</link>) 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().

    
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().

  </section>

  <section id="ensuring-functions-are-called-in-the-right-context">

    <title>Zajištění, aby funkce byly volány ve správném kontextu</title>

    
„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 <link href="http://en.wikipedia.org/wiki/Message_queue">frontu zpráv</link> 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ě.

    <example>

      
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í <link href="http://en.wikipedia.org/wiki/Message_passing">předávání zpráv</link>. Umožní to jednotlivým vláknům aktualizovat svá data, kdy se jim to hodí, což významně zjednodušuje zamykání.

   </example>

    
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.

    <example>

      
Například pro průběh volání v <link href="https://developer.gnome.org/gio/stable/GFile.html#g-file-copy-async">g_file_copy_async()</link> je zdokumentováno, že se volá ve výchozím vlákně hlavního kontextu v době volání inicializace.

    </example>

    <section id="invocation-core-principle">

      <title>Principy vyvolání</title>

      
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 <link xref="#g-main-context-invoke-full">vhodná metoda g_main_context_invoke_full()</link>.

      
Do cílového GMainContext, který vyvolá funkci, když je obeslán, musí být přidán <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#GSource">GSource</link>. Tento GSource by většinou měl být zdroj pro nečinnost vytvořený pomocí <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-idle-source-new">g_idle_source_new()</link>, 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 <link xref="#what-is-gmaincontext">vyslán hned, jak bude připraven</link>, 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 <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-source-set-priority">g_source_set_priority()</link>. 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í <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-source-set-callback">g_source_set_callback()</link> 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.

      <example>

        
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í <link href="http://en.wikipedia.org/wiki/Mutual_exclusion">mutexu</link>. 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 <link xref="memory-management"/>).

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

      </example>

    </section>

    <section id="g-main-context-invoke-full">

      <title>Užitečná metoda: g_main_context_invoke_full()</title>

      
To vše se dá úžasně zjednodušit správnou metodou <link href="https://developer.gnome.org/glib/stable/glib-The-Main-Event-Loop.html#g-main-context-invoke-full">g_main_context_invoke_full()</link>. 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().

      <example>

        
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).

      </example>

    </section>

  </section>

  <section id="checking-threading">

    <title>Kontrola vláken</title>

    
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 <link href="https://developer.gnome.org/gobject/stable/gobject-Signals.html#g-signal-emit">g_signal_emit()</link> je asynchronní a vůbec se netýká hlavního kontextu.

    <example>

      
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;

}

    </example>

  </section>

  <section id="gtask">

    <title>GTask</title>

    
<link href="https://developer.gnome.org/gio/stable/GTask.html">GTask</link> 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.

    <example>

      
Zkombinováním <link xref="#g-main-context-invoke-full">g_main_context_invoke_full()</link> 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);

}

    </example>

  </section>

</page>