gtask笔记

1、创建Task

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

source_object：GObject对象，拥有者

cancellable：可否取消

callback：task完成后调用函数

callback_data：task完成后调用函数数据参数

2、设置数据

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

处理函数使用task_data方式：typedef void (*GTaskThreadFunc)(GTask *task,gpointer source_object,gpointer task_data,GCancellable *cancellable);

3、同步执行和异步执行，注: 一定调用 g_task_return_pointer或者g_task_return_error返回

void g_task_run_in_thread(GTask *task,GTaskThreadFunc task_func);

void g_task_run_in_thread_sync(GTask *task, GTaskThreadFunc task_func);

调用时机：调用task完成后的回调函数, GAsyncReadyCallback的调用时机 是main event loop的下一次迭代。

4、执行回调函数

typedef void (*GAsyncReadyCallback) (GObject *source_object,GAsyncResult *res,gpointer data);

5、示例

extern "C"{
#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;static void cake_data_free(CakeData *cake_data)
{printf("main thread %p: %s\n", g_thread_self(), __func__);g_free(cake_data->message);g_slice_free(CakeData, cake_data);
}static Cake *bake_cake(GObject *self, guint radius, CakeFlavor flavor,CakeFrostingType frosting, char *message,GCancellable *cancellable, GError **error)
{printf("end------sub thread %p: %s\n\n", g_thread_self(), __func__);return (Cake *)g_object_new(G_TYPE_OBJECT, NULL);
}static void bake_cake_thread(GTask *task, gpointer source_object,gpointer task_data, GCancellable *cancellable)
{GObject *self = (GObject *)source_object;CakeData *cake_data = (CakeData *)task_data;Cake *cake;GError *error = NULL;printf("\nstart-----sub thread %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);if (g_task_set_return_on_cancel (task, FALSE)){g_task_return_pointer (task, cake, g_object_unref);}
}static void baker_bake_cake_async(GObject *self, guint radius, CakeFlavor flavor,CakeFrostingType frosting,const char *message,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data)
{CakeData *cake_data;GTask *task;printf("main thread %p: %s\n", g_thread_self(), __func__);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);g_task_set_task_data(task, cake_data, (GDestroyNotify)cake_data_free);
//    g_task_set_return_on_cancel (task, TRUE);g_task_run_in_thread(task, bake_cake_thread);
//    g_task_set_check_cancellable(task,TRUE);g_object_unref(task);
}static Cake * baker_bake_cake_sync(GObject *self, guint radius, CakeFlavor flavor,CakeFrostingType frosting,const char *message,GCancellable *cancellable,GAsyncReadyCallback callback,gpointer user_data)
{CakeData *cake_data;GTask *task;printf("main thread %p: %s\n", g_thread_self(), __func__);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, NULL, NULL);g_task_set_task_data(task, cake_data, (GDestroyNotify)cake_data_free);
//    g_task_set_return_on_cancel (task, TRUE);g_task_run_in_thread_sync(task, bake_cake_thread);Cake *cake;GError *error = NULL;cake = (Cake *)g_task_propagate_pointer (task, &error);printf("baker_bake_cake_sync cake: %p\n", cake);g_object_unref(task);return cake;
}static Cake *baker_bake_cake_finish(GObject *self, GAsyncResult *res,GError **error)
{g_return_val_if_fail(g_task_is_valid(res, self), NULL);printf("main thread %p: %s\n", g_thread_self(), __func__);return (Cake *)g_task_propagate_pointer(G_TASK(res), error);
}static void my_callback(GObject *source_object, GAsyncResult *res,gpointer user_data)
{GObject *baker = (GObject *)source_object;GMainLoop *loop = (GMainLoop *)user_data;Cake *cake;GError *error = NULL;printf("main thread %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)
{GObject *baker = (GObject *)g_object_new(G_TYPE_OBJECT, NULL);GCancellable *cancellable = g_cancellable_new();GMainLoop *loop = g_main_loop_new(NULL, FALSE);Cake * cake = baker_bake_cake_sync(baker, 10, 20, 30, "sync", cancellable, my_callback, loop);g_object_unref(cake);baker_bake_cake_async(baker, 10, 20, 30, "async", cancellable, my_callback, loop);g_object_unref(cancellable);printf("main thread %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;
}

输出结果：

main thread 000001F6F9BED030: baker_bake_cake_sync

start-----sub thread 000001F6F9BEF0C0: bake_cake_thread

end------sub thread 000001F6F9BEF0C0: bake_cake

baker_bake_cake_sync cake: 000001F6F9BEE140

main thread 000001F6F9BED030: cake_data_free

main thread 000001F6F9BED030: baker_bake_cake_async

main thread 000001F6F9BED030: start event loop.

start-----sub thread 000001F6F9BEF0C0: bake_cake_thread

end------sub thread 000001F6F9BEF0C0: bake_cake

main thread 000001F6F9BED030: my_callback

main thread 000001F6F9BED030: baker_bake_cake_finish

A cake is baked: 000001F6F9BEE380

main thread 000001F6F9BED030: cake_data_free