【译】同步使用GCD队列(Using GCD Queues For Synchronization)

来源:互联网 时间:2017-01-22





这是GCD介绍的第二篇


在我之前的文章中,我们已经学习过了在异步的程序中竞态条件是一个很常见的问题。就是当一份数据同时被多个线程操作,产生的结果将不可预测。


该问题的一个典型解决方法就是使用互斥锁(mutual exclusion)。这里有一个使用 Posix threads API的例子:


#import <Foundation/Foundation.h>
#import <pthread/pthread.h>
// Each player gets 100 gems to start
int playerAGems = 100;
int playerBGems = 100;
// Data structure to hold information about the mutual exclusion object
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
void *thread1(void *arg) {
// Move 20 gems from player A to player B
pthread_mutex_lock(&mutex); // Wait until we gain access to the mutex
playerAGems -= 20;
playerBGems += 20;
NSLog(@"Player A now has %d gems, and player B has %d gems.", playerAGems, playerBGems);
pthread_mutex_unlock(&mutex); // Unlock the mutex
return NULL;
}
void *thread2(void *arg) {
// Move 50 gems from player B to player A
pthread_mutex_lock(&mutex);
playerAGems += 50;
playerBGems -= 50;
NSLog(@"Player A now has %d gems, and player B has %d gems.", playerAGems, playerBGems);
pthread_mutex_unlock(&mutex);
return NULL;
}
int main() {
pthread_mutex_init(&mutex, NULL); // Initialize the mutex
pthread_t t1; // Data structure to hold information about thread 1
pthread_t t2; // Data structure to hold information about thread 2
pthread_create(&t1, NULL, thread1, NULL);
pthread_create(&t2, NULL, thread2, NULL);
dispatch_main();
}

运行这个程序若干次,每次产生的结果是你所预期的吗?



注释掉pthread_mutex_lock()pthread_mutex_unlock(),然后再运行几次,有什么不同?


在这个例子中,线程1和线程2同时运行。假如说线程1先走到pthread_mutex_lock(),线程1就获得了一个互斥锁,并且继续执行。
如果在线程1还持有锁的时候,线程2走到pthread_mutex_lock(),这时线程2会暂停执行(或者叫阻塞),直到这个锁被解开。
这就使得线程1可以被玩家1和玩家2原子级的修改,也就是说,不会被别的线程干扰。当线程1执行完毕,就会调用pthread_mutex_unlock(),线程2就可以接着执行并持有一个互斥锁。


一个线程的解锁和下一个线程的加锁是串行的,也是原子级的。也就是说永远不会出现一种2个线程都没加锁的中间状态。互斥锁会从一个线程直接传递到下一个线程。


用队列,不用互斥锁

让我们用GCD重写一下这个例子。黑喂狗:


#import <Foundation/Foundation.h>
#import <pthread/pthread.h>
// Each player gets 100 gems to start
int playerAGems = 100;
int playerBGems = 100;
dispatch_queue_t queue;
void *thread1(void *arg) {
// Move 20 gems from player A to player B
dispatch_sync(queue, ^{
playerAGems -= 20;
playerBGems += 20;
NSLog(@"Player A now has %d gems, and player B has %d gems.", playerAGems, playerBGems);
});
return NULL;
}
void *thread2(void *arg) {
// Move 50 gems from player B to player A
dispatch_sync(queue, ^{
playerAGems += 50;
playerBGems -= 50;
NSLog(@"Player A now has %d gems, and player B has %d gems.", playerAGems, playerBGems);
});
return NULL;
}
int main() {
queue = dispatch_queue_create("Synchronization queue", DISPATCH_QUEUE_SERIAL);
pthread_t t1, t2;
pthread_create(&t1, NULL, thread1, NULL);
pthread_create(&t2, NULL, thread2, NULL);
dispatch_main();
}

在这个例子中,我们继续用pthread_create()来创建新线程。在以后的文章中,我将告诉你们怎么使用全局并发队列来达到一样的效果。


注意到了2种写法相似和不同的地方没有?我们用串行队列取代了互斥锁,但是逻辑还是基本一样。回忆一下,串行队列是一种能够串行执行我们加入到其中的block的数据结构。
我们不是调用pthread_mutex_lock(),而是使用dispatch_sync()来把线程锁在队列中。dispatch_sync()告诉GCD去入队我们的block,并且等待block执行结束才会进行接下来的操作。
假如线程1先运行到dispatch_sync(),它的block(从玩家A拿走20个宝石,给玩家B 20个宝石)被入队到我们的串行队列中,线程1的运行就会被阻塞,直到这个block执行结束。又因为这时队列里是空的,这个block是第一个入队的,所以它将会被立即执行。


"入队的block在哪一个线程上执行?"问这个问题没有什么意义,因为GCD会计算出应该抢占哪个线程去运行你入队的block。


然后当前一个block还在运行的时候,线程2走到了dispatch_sync(),它的block(给玩家A50个宝石,从玩家B拿走50个宝石)将会被入队到串行队列中,排在目前正在运行的block后面,等待它执行完毕才能执行。因为线程2需要等待它的block执行结束,所以这时线程2将处于暂停状态。
第一个block最终运行完毕,然后从队列的头部出队,使得线程1恢复执行。这时线程2中的block就是队列的第一个元素,它将被执行,当它执行完毕时,线程2将恢复执行。
恭喜!你已经学会了怎么用串行队列代替互斥锁。在接下来的文章中,我们将学习一下并发队列,它是一个强而有力的小伙伴。




相关阅读:
Top