十三、GIO GTask

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);
	else
		g_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的例子: