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

这是GCD介绍的第二篇

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

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

#import 
#import 

// 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 
#import 

// 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将恢复执行。
恭喜！你已经学会了怎么用串行队列代替互斥锁。在接下来的文章中，我们将学习一下并发队列，它是一个强而有力的小伙伴。