libuv的多线程之间传递消息
官网上给出的例子http://nikhilm.github.io/uvbook/threads.html#inter-thread-communication，中文理解在后边
Inter-thread communication
Sometimes you want various threads to actually send each other messages while they are running. For example you might be running some long duration task in a separate thread (perhaps using uv_queue_work) but want to notify progress to the main thread. This is a simple example of having a download manager informing the user of the status of running downloads.
progress/main.c
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
uv_loop_t *loop;
uv_async_t async;
int main() {
loop = uv_default_loop();
uv_work_t req;
int size = 10240;
req.data = (void*) &size;
uv_async_init(loop, &async, print_progress);
uv_queue_work(loop, &req, fake_download, after);
return uv_run(loop, UV_RUN_DEFAULT);
}
|
The async thread communication works on loops so although any thread can be the message sender, only threads with libuv loops can be receivers (or rather the loop is the receiver). libuv will invoke the callback (print_progress) with the async watcher whenever it receives a message.
Warning
It is important to realize that the message send is async, the callback may be invoked immediately after uv_async_send is called in another thread, or it may be invoked after some time. libuv may also combine multiple calls to uv_async_send and invoke your callback only once. The only guarantee that libuv makes is – The callback function is called at least once after the call to uv_async_send. If you have no pending calls to uv_async_send, the callback won’t be called. If you make two or more calls, and libuv hasn’t had a chance to run the callback yet, it may invoke your callback only once for the multiple invocations of uv_async_send. Your callback will never be called twice for just one event.
progress/main.c
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
void fake_download(uv_work_t *req) {
int size = *((int*) req->data);
int downloaded = 0;
double percentage;
while (downloaded < size) {
percentage = downloaded*100.0/size;
async.data = (void*) &percentage;
uv_async_send(&async);
sleep(1);
downloaded += (200+random())%1000; // can only download max 1000bytes/sec,
// but at least a 200;
}
}
|
In the download function we modify the progress indicator and queue the message for delivery with uv_async_send. Remember: uv_async_send is also non-blocking and will return immediately.
progress/main.c
1 2 3 4 |
void print_progress(uv_async_t *handle, int status /*UNUSED*/) {
double percentage = *((double*) handle->data);
fprintf(stderr, "Downloaded %.2f%%\n", percentage);
}
|
The callback is a standard libuv pattern, extracting the data from the watcher.
Finally it is important to remember to clean up the watcher.
progress/main.c
1 2 3 4 |
void after(uv_work_t *req, int status) {
fprintf(stderr, "Download complete\n");
uv_close((uv_handle_t*) &async, NULL);
}
|
After this example, which showed the abuse of the data field, bnoordhuis pointed out that using the data field is not thread safe, and uv_async_send() is actually only meant to wake up the event loop. Use a mutex or rwlock to ensure accesses are performed in the right order.
这个也有中文版的翻译，可以网上搜到。
文中最后提到的uv_async_t.data不是线程安全的，我的理解如下：
在主线程中开启一个消息循环loop（uv_loop_t对象）,然后为loop注册了一个异步消息监听器async（uv_async_t对象），其他线程就可以通过async给主线程发送消息。做法就是把数据保存在async下，然后将async发给loop,loop异步的获取async，然后从async中得到数据并处理。我想说的是，async对象只有一个，在传递的过程中没有副本，因此从发送消息到消息被获取并处理完毕，这期间async对象都是线程不安全的，应该加上同步机制来保证整个期间async对象只服务于一个其他线程。但是如果同步的话，那libuv提供的异步消息机制岂不没有用了？我们的多线程程序也会在此遇到瓶颈。
我的解决方法有两个：
1.其他线程在每次向主线程发送消息的时候，都新建一个async对象，并临时注册到loop里；当loop获取该async对象，处理完毕后，注销并并删除async对象
2.同时注册多个async对象，将他们保存在队列中。其他线程在向主线程发送消息时，互斥的获取其中一个async对象，等loop处理完该async对象后，将其互斥的插回队列。虽然这样也有同步操作，但它的同步周期大大减小，提高了线程并行度。
