GTask表示管理一个可取消的“任务task”

GCancellable

GCancellable是一个线程安全的操作取消栈，用于整个GIO，以允许取消同步和异步操作。

它继承于GObject对象，不是一个单纯的结构体

相关函数

g_task_new

GTask*
g_task_new (GObject* source_object,GCancellable* cancellable,GAsyncReadyCallback callback,gpointer callback_data
)

创建一个作用于source_object的GTask，它最终会在[thread-default main context][g-main-context-push-thread-default]中被使用去调用callback

在异步方法的“start”方法中调用它，并在异步操作中传递GTask。可以使用g_task_set_task_data()将特定于任务的数据附加到对象上，稍后可以通过g_task_get_task_data()获取这些数据。

默认情况下，如果cancelable被取消，那么任务的返回值总是G_IO_ERROR_CANCELLED，即使任务在取消之前已经完成。取消操作可能意味着该任务所依赖的其他对象已经被销毁，这种情况下的处理可以简化。如果你不想要这种行为，可以使用g_task_set_check_cancellable()来改变它。

g_task_set_task_data

void
g_task_set_task_data (GTask* task,gpointer task_data,GDestroyNotify task_data_destroy
)

设定task任务的数据

g_task_run_in_thread

void
g_task_run_in_thread (GTask* task,GTaskThreadFunc task_func
)

在另一个线程中运行task_func。当task_func返回时，任务的GAsyncReadyCallback将在任务的GMainContext中调用（任务实在那个GMainContext上下文中创建的，就那个上下文中执行回调函数）。

这里会对task进行一个ref，直到task完成。

有关如何处理task_func的更多细节，请参阅GTaskThreadFunc。

尽管GLib当前对通过g_task_run_in_thread()排队的任务进行速率限制，但大家不应该假定它总是这样做。如果你有很多任务要运行(几十个任务)，但又不希望它们同时运行，那么一次只应该将有限数量的任务(大约10个)放入队列。

#include <glib.h>
#include <glib-object.h>
#include <gio/gio.h>
#include <stdio.h>
#include <stdlib.h>typedef int CakeFlavor;
typedef int CakeFrostingType;typedef struct {guint radius; /* 蛋糕半径 */CakeFlavor flavor; /* 蛋糕风味 */CakeFrostingType frosting; /* 蛋糕糖霜类型 */char *message;
} CakeData;typedef GObject Cake;
typedef GObject Baker; /* 面包师 */static void
cake_data_free (CakeData *cake_data) {g_print ("%p: %s\n", g_thread_self(), __func__);g_free (cake_data->message);/*  */g_slice_free (CakeData, cake_data);
}/* 烤面包 */
static Cake *
bake_cake(Baker *self, guint radius, CakeFlavor flavor,CakeFrostingType frosting, char *message,GCancellable *cancellable, GError **error)
{printf("%p: %s\n", g_thread_self(), __func__);return g_object_new(G_TYPE_OBJECT, NULL);
}static void 
bake_cake_thread(GTask *task, gpointer source_object,gpointer task_data, GCancellable *cancellable)
{Baker *self = source_object;CakeData *cake_data = task_data;Cake *cake;GError *error = NULL;printf("%p: %s\n", g_thread_self(), __func__);cake = bake_cake(self, cake_data->radius, cake_data->flavor,cake_data->frosting, cake_data->message, cancellable,&error);if (cake)g_task_return_pointer(task, cake, g_object_unref);elseg_task_return_error(task, error);
}static void 
baker_bake_cake_async(Baker *self, guint radius, CakeFlavor flavor,CakeFrostingType frosting,const char *message,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data) {CakeData *cake_data;GTask *task;printf("%p: %s\n", g_thread_self(), __func__);/* 切片分配内存（这是一个便利的宏，从slice allocator分配内存） */cake_data = g_slice_new(CakeData);cake_data->radius = radius;cake_data->flavor = flavor;cake_data->frosting = frosting;cake_data->message = g_strdup(message);task = g_task_new(self, cancellable, callback, user_data);/* 把数据附加在task上 */g_task_set_task_data(task, cake_data, (GDestroyNotify)cake_data_free);g_task_run_in_thread(task, bake_cake_thread);g_object_unref(task);
}static Cake *
baker_bake_cake_finish(Baker *self, GAsyncResult *res,GError **error) {g_return_val_if_fail(g_task_is_valid(res, self), NULL);printf("%p: %s\n", g_thread_self(), __func__);return g_task_propagate_pointer(G_TASK(res), error);
}static void 
my_callback(GObject *source_object, GAsyncResult *res,gpointer user_data) {/* 创建一个面包师 */Baker *baker = (Baker *)source_object;GMainLoop *loop = (GMainLoop *)user_data;Cake *cake;GError *error = NULL;printf("%p: %s\n", g_thread_self(), __func__);cake = baker_bake_cake_finish(baker, res, &error);printf("A cake is baked: %p\n", cake);// But discard it. I prefer pudding.g_object_unref(cake);// Stop cooking.g_main_loop_quit(loop);
}int 
main(void) {Baker *baker = g_object_new(G_TYPE_OBJECT, NULL);GCancellable *cancellable = g_cancellable_new();GMainLoop *loop = g_main_loop_new(NULL, FALSE);printf("%p: %s\n", g_thread_self(), __func__);baker_bake_cake_async(baker, 10, 20, 30, "emit", cancellable,1, loop);g_object_unref(cancellable);printf("%p: start event loop.\n", g_thread_self());g_main_loop_run(loop);g_main_loop_unref(loop);g_object_unref(baker);return EXIT_SUCCESS;
}

异步操作

GTask最常见的用法是作为一个GAsyncResult，在异步操作期间管理数据。你可以在“start”方法中调用g_task_new()，然后调用g_task_set_task_data()以及类似的方法，如果你需要保留一些与任务相关的额外数据，然后通过异步操作传递任务对象。最终，您将调用诸如g_task_return_pointer()或g_task_return_error()之类的方法，该方法将保存您给它的值，然后在创建它的[thread-default main context][g-main-context-push-thread-default]中调用任务的回调函数(如果需要，首先等待主循环的下一次迭代)。调用者将把GTask传递回操作的finish函数(作为GAsyncResult)，你可以使用g_task_propagate_pointer()或类似的函数来提取返回值。

使用GTask要求thread-default的GMainContext从GTask构建时开始运行，至少直到任务完成并释放其数据。

下面是一个使用GTask作为GAsyncResult的例子: