Philip Withnall
philip.withnall@collabora.co.uk 2015

This work is licensed under a Creative Commons Attribution-Share Alike 3.0 United States License.

Jako zvláštní výjimka se vám držitelem autorských práv uděluje svolení kopírovat, upravovat a šířit ukázkový kód obsažený v tomto dokumentu za podmínek, které si zvolíte, bez dalších omezení.

Přesun výpočtů mimo hlavní vlákno do pracovních vláken

# Vlákna

#

        Shrnutí

          Pokud je to možné, vlákna nepoužívejte ()
          Pokud vlákna použít musíte, použijte GTask nebo GThreadPool a kód vlákna izolujte co nejvíce je možné. ()
          Při ručním požití GThread používejte g_thread_join(), abyste předešli únikům prostředků vlákna. ()
          Při použití vláken dávejte pozor, jaký kód spouštíte v GMainContext. Spuštění kódu v nesprávném kontextu může způsobit souběh podmínek nebo blokování hlavní smyčky. ()

# Kdy použít vlákna

Když píšete projekty s pomocí GLib, mělo by být výchozím přístupem pravidlo nikdy nepoužívat vlákna. Místo toho správně používejte hlavní kontext GLib, který, skrz použití asynchronních operací, umožňuje většině blokujících V/V operací pokračovat na pozadí, zatímco hlavní kontext pokračuje ve zpracování dalších událostí. Analýza, kontrola a ladění programového kódu vláken se velmi rychle dokáže zvrhnout ve velmi složitou věc.

Vlákna by se měla používat jen, když je to nutné kvůli externí knihovně, která má blokující funkce, které potřebujete volat z kódu GLib. Jestliže knihovna poskytuje neblokující variantu, nebo nějakou integrovanou se smyčkou `poll()`, měli byste takové variantě dát přednost. Pokud musíte opravdu použít blokující funkci, měli byste k ní napsat tenký obalující kód, který ji převede na běžnou asynchronní funkci ve stylu `GAsyncResult` z GLib, a který spustí blokující operaci v pracovním vlákně.

Například:

int some_blocking_function (void *param1, void *param2);

By měla být obalena jako:

void some_blocking_function_async (void *param1, void *param2, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data); int some_blocking_function_finish (GAsyncResult *result, GError **error);

S nějakou takovouto implementací:

/* Zapouzdření pro parametry volání */ typedef struct { void *param1; void *param2; } SomeBlockingFunctionData;

static void some_blocking_function_data_free (SomeBlockingFunctionData *data) { free_param (data->param1); free_param (data->param2);

g_free (data); }

static void some_blocking_function_thread_cb (GTask *task, gpointer source_object, gpointer task_data, GCancellable *cancellable) { SomeBlockingFunctionData *data = task_data; int retval;

/* Obsluha zrušení */ if (g_task_return_error_if_cancelled (task)) { return; }

/* Spuštění blokující funkce */ retval = some_blocking_function (data->param1, data->param2); g_task_return_int (task, retval); }

void some_blocking_function_async (void *param1, void *param2, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GTask *task = NULL; /* vlastněno */ SomeBlockingFunctionData *data = NULL; /* vlastněno */

g_return_if_fail (validate_param (param1)); g_return_if_fail (validate_param (param2)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));

task = g_task_new (NULL, cancellable, callback, user_data); g_task_set_source_tag (task, some_blocking_function_async);

/* Zrušení by mělo být obslouženo ručně pomocí mechanizmu určeného * konkrétně pro some_blocking_function(). */ g_task_set_return_on_cancel (task, FALSE);

/* Nastaví zapouzdření obsahující parametry volání. Zkopíruje je, aby se * předešlo problémům se zamykáním mezi volajícím vláknem a pracovním vláknem */ data = g_new0 (SomeBlockingFunctionData, 1); data->param1 = copy_param (param1); data->param2 = copy_param (param2);

g_task_set_task_data (task, data, some_blocking_function_data_free);

/* Spustí úlohu v pracovním vlákně a ihned se vrátí, zatímco zpracování * pokračuje na pozadí. Když je dokončeno, je zavolána funkce @callback * ve výchozím hlavním kontextu aktuálního vlákna */ g_task_run_in_thread (task, some_blocking_function_thread_cb);

g_object_unref (task); }

int some_blocking_function_finish (GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, some_blocking_function_async), -1); g_return_val_if_fail (error == NULL || *error == NULL, -1);

return g_task_propagate_int (G_TASK (result), error); }

Další podrobnosti viz dokumentace k `GAsyncResult`. Jednoduchým způsobem, jak implementovat pracovní vlákno, je `GTask` a `g_task_run_in_thread()`. (Viz také .)

# Používání vláken

Pokud není pro napsání pracovního vlákna použitelný `GTask`, musí být použit přístup na nižší úrovni. To ale hodně dobře zvažte, protože je velmi snadné napsat kód vlákna nesprávným způsobem, který způsobí za běhu nepředvidatelné chyby, nekonečné zámky nebo spotřebu přílišného množství prostředků a ukončení programu.

Kompletní návod pro psaní vláken je mimo rozsah tohoto dokumentu, ale existuje řada dalších příruček, podle kterých se můžete řídit, abyste omezili vznik potenciálních chyb v kódu vlákna. Obecným principem je omezit množství kódu a dat, které budou vláknem ovlivněny. Například omezením počtu vláken, složitosti implementace pracovního vlákna a množství dat sdílených mezi vlákny.

Pokud je to možné, použijte místo ručního vytváření svých `GThread` třídu `GThreadPool`. `GThreadPool` podporuje pracovní fronty, omezení počtu spuštěných vláken a automatické sloučení dokončených vláken, takže nedochází k jejich úniku.

Kdy není možné použít `GThreadPool` (což je zřídkavý případ):

Použijte ke spuštění vlákna `g_thread_try_new()` namísto `g_thread_new()`, a chyby způsobené vybočením z vlákna pak můžete skvěle ošetřit, místo aby došlo k nepodmíněnému přerušení programu.

Výslovně spojte vlákna pomocí `g_thread_join()`, abyste předešli úniku prostředků vlákna.

Místo ručního zamykání pomocí mutexů použijte raději předávání zpráv do dat přenášených mezi vlákny. `GThreadPool` to vyloženě podporuje pomocí `g_thread_pool_push()`.

Když se musí použít mutexy:

Programový kód vlákna izolujte co nejvíce to jde, mutexy udržujte v rámci tříd privátní a pevně je spojte s velmi konkrétně zaměřenými členy třídy.

U všech deklarací mutexů by měly být srozumitelné komentáře, ve kterých jsou uvedeny struktury nebo proměnné, k nimž chrání přístup. A obdobně by u oněch proměnných měl být komentář říkající, že by se k nim mělo přistupovat pouze pomocí mutexu, který je drží.

Buďte opatrní s interakcemi mezi hlavním kontextem a vlákny. Například funkce `g_timeout_add_seconds()` přidává časovač, který bude spuštěn v globálním výchozím hlavním kontextu, který běží v hlavním vlákně, což není nutně aktuální vlákno. Když se to udělá špatně, může to znamenat, že to co bylo zamýšleno pro pracovní vlákno nešťastnou náhodou skončí spuštěné mimo v hlavním vlákně. (Viz také: .)

# Ladění

Ladění vláken je poněkud zapeklité. Jednak protože se chyby těžko reprodukují a jednak protože je těžké odhalit jejich původ. To je jeden z hlavních důvodů, proč se vyhýbat vláknům a nevolit je jako první řešení.

Při výskytu takovéto chyby však mohou být užitečné nástroje drd a helgrind z Valgrind.