标签：ios   线程   

原英文网址为:

同步

在应用程序中的多个线程的存在开辟了潜在的问题，关于安全访问到资源从多个执行线程。两个线程修改相同的资源可能会相互干扰，以意想不到的方式。例如，一个线程可能会覆盖其他人的更改或应用程序置于未知和潜在无效的状态。如果你很幸运，已损坏的资源可能会导致明显的性能问题或相对容易，跟踪并修复的崩溃。如果你运气不好，然而，腐败可能导致不直到很久以后，表现自己的细微错误或错误可能需要你基本的编码假设任何重大改革。

线程安全的时候，一个好的设计是最好的保护你。避免共享的资源，减少您的线程之间的交互就不太可能，这些线程，互相干扰。完全无干涉的设计并不总是可能的然而。在哪里您的线程必须进行交互的情况下，您需要使用同步工具来确保当它们交互，他们这样做安全。

OS X 和 iOS 提供许多的同步工具，帮助您使用，从提供给那些在您的应用程序中正确的事件序列的相互独占访问的工具。以下各节描述了这些工具以及您如何使用它们在您的代码，会影响到你的程序的资源的安全访问。

同步工具

若要防止意外更改的数据从不同的线程，你可以任意设计您的应用程序，没有同步问题或您可以使用同步工具。虽然一共避免同步问题是可取的但它并不总是可能。以下各节描述了同步工具可供您使用的基本范畴。

原子操作

原子操作是同步的简单形式的工作在简单数据类型。原子操作的优点是不会阻塞争用线程。对于简单的操作如递增计数器变量，这可以导致更好的表现比采用锁。

OS X 和 iOS 包括许多行动来执行基本的数学和逻辑运算，在 32 位和 64 位的值。这些操作中，原子版本的比较和交换、 测试集和测试和清除操作。支持的原子操作的列表，请参阅/usr/include/libkern/OSAtomic.h头文件或参阅atomic的手册页。

内存屏障和 Volatile 变量

为了实现最佳性能，编译器通常重新排列程序集级指令保持尽可能详尽地处理器指令管线。作为这种优化的一部分，编译器可能在它认为这样做不能生成不正确的数据时访问主存储器的指令重新排序。不幸的是，并非总是可能为编译器检测内存相关的所有操作。如果看似独立的变量实际上互相影响，编译器优化可以更新这些变量以错误的顺序生成潜在错误的结果。

一个内存屏障是一种非阻塞同步类型工具，用来确保内存按正确的顺序发生的操作。一个内存屏障就像一个屏障，迫使处理器来完成任何负载和存储位于屏障，它允许执行加载和存储操作后屏障定位之前的操作。内存屏障通常被用来确保内存操作由一个线程 （但可见到另一个） 始终预期的顺序出现。缺乏一个内存屏障，在这种情况可能允许其他线程看到看似不可能的结果。（例如，见内存屏障的维基百科词条）。聘请一个内存屏障，你只是调用OSMemoryBarrier函数在适当时候在您的代码中。

Volatile 变量适用于单个变量的另一种类型的内存约束。编译器经常通过加载到寄存器的变量的值来优化代码。用于本地变量，通常这并非一个问题。如果变量不过是从另一个线程可见，这样的优化可能会阻止其他线程注意到对它的任何更改。volatile关键字应用到一个变量强制编译器，它用每次从内存加载该变量。你可能会为volatile声明一个变量，如果它的值可以在任何时间改变由编译器可能不能够检测到外部源。

因为内存屏障和 volatile 变量减少的优化编译器可以执行的次数，他们应该谨慎使用，只在需要确保正确性。有关使用内存屏障的信息，请参阅OSMemoryBarrier手册页。

锁

锁是最常用的同步工具之一。你可以使用锁来保护您的代码，这是一段代码每次只有一个线程允许访问临界区。例如，一个临界区可能操纵一种特定的数据结构或使用的一些资源，支持最多的一位客户一次。通过在该节周围放置一把锁，您排除其他线程进行更改可能会影响您的代码的正确性。

表 4-1列出了一些常用的程序员的锁。OS X 和 iOS 提供大部分的这些锁的类型，但并不是所有的实现。对于不支持的锁定类型，说明列解释了为什么那些锁不直接在平台实现的原因。

有关如何使用锁的信息，请参阅使用锁. 

条件

一个条件是信号的另一种类型的允许线程彼此的信号，当某个条件为真时。条件通常用于指示资源的可用性，或以确保按特定的顺序执行任务。当一个线程测试一个条件时，它可以阻止除非这种情况已经是真实。它仍然是阻止，直到某个其他线程显式更改和信号的条件。一个条件和互斥锁之间的区别是多个线程可能会在同一时间允许访问的条件。条件是多一个让不同的线程，通过一些指定的条件取决于门的看门人。

您可能使用条件的一种方法是管理一个池的挂起事件。事件队列将使用条件变量到信号正在等待的线程，当有事件队列中。如果一个事件发生时，该队列将正确传递信号的条件。如果一个线程已经等待时，它会被吵醒于是将拉从队列的事件，并对其进行处理。如果两个事件在大致相同的时间进来到队列，队列将信号条件下两次，两个线程中醒来。

该系统为条件在几个不同的技术提供支持。正确实施条件需要细致的编码，然而，所以你应该看在您自己的代码中使用它们之前的示例中使用的条件。

执行器例程

可可粉的应用程序都在向单个线程同步的方式传递信息的简便方法。NSObject类声明在一个应用程序的活动线程上执行一个选择器的方法。这些方法允许您传送消息以异步方式与保证他们将同步由目标线程的线程。例如，您可以使用选择器消息交付结果从一个分布式的计算，到您的应用程序的主线程或到指定的协调员线程执行。排队目标线程运行环路上的每个请求执行一个选择器和请求然后按顺序处理收到的顺序。

为总结执行选择器例程和如何使用它们，请参阅可可执行选择器来源有关的详细信息. 

同步成本和性能

同步可帮助确保您的代码的正确性，但这样做会降低性能。利用同步工具，介绍了拖延，甚至在无异议的情况下。锁定和原子操作通常涉及使用内存屏障和内核级同步，以确保代码适当的保障。如果有一把锁的争用，您的线程可以阻止和经验甚至更多延误。

表 4-2列出了一些与互斥体和在无异议的情况下的原子操作相关联的近似成本。这些测量代表接管几个一千个样品的平均时间。随着与线程创作时代虽然互斥体采集时间 （即使在无争议的情况下） 可以极大地取决于处理器加载，电脑和的系统和程序的可用内存量的速度。

当设计你的并发任务，正确性是最重要的因素，但是您还应该考虑性能因素。正确执行下多个线程，但低于相同的代码在单独的线程上运行的代码是很难改善。

如果你改造现有的单线程应用程序，你应该总是一套基线测量性能的关键任务。后添加额外的线程，然后应该采取新的测量方法，为这些相同的任务，并比较性能的多线程的单线程的情况。如果后调优您的代码，线程不能提高性能，要完全重新考虑您的特定实现或线程的使用。

有关性能和工具来收集度量标准的信息，请参阅性能概述。有关成本的锁定和原子操作的特定信息，请参阅线程的成本.

线程安全和信号

线程应用程序的时候，什么都不会导致更多恐惧或混乱而不会这一问题的处理信号。信号是一种低级的 BSD 机制，可用于将信息提供给一个进程或以某种方式操纵它。某些程序使用信号来检测某些事件，如一个子进程的死亡。该系统使用信号终止失控的进程，并交流其他类型的信息。

信号的问题是不是他们做了什么，但他们的行为，当您的应用程序有多个线程。在单线程应用程序中，所有的信号处理程序的主线程上运行。在多线程应用程序中，不依赖于特定的硬件错误 （如非法的指令） 的信号被传送到哪个线程碰巧在的时间运行。如果多个线程同时运行，信号被传递到哪个系统碰巧捡。换句话说，信号可以传送到您的应用程序中的任何线程。

第一条规则为在应用程序中实现信号处理程序是为了避免假设关于哪个线程处理信号。如果一个特定的线程想要处理一个给定的信号，你需要想出一些办法的信号到达时通知该线程。你不能想当然地安装一个信号处理程序从该线程将导致信号被传递到同一个线程中。

有关信号和安装信号处理程序的详细信息，请参见signal和sigaction手册页。

线程安全设计的技巧

同步工具是有用的途径来使您的代码线程安全的但他们并不是万能。用得太多，锁和其他类型的同步基元，实际上可以降低您的应用程序线程的性能相比，其非线程的性能。找到正确的平衡安全性和性能之间是需要经验的艺术。以下各节提供提示，帮助您选择适当的同步为您的应用程序级别。

完全避免同步

对于任何新的项目，你的工作，和甚至对于现有项目，设计你的代码和数据的结构，以避免对同步的需求是最佳可行的解决方案。虽然锁和其它同步工具是有用的而且的确会影响任何应用程序的性能。如果总体设计导致特定资源之间的大量争用，您的线程可能要等更长的时间。

实现并发的最好方法是减少你的并发任务之间的相互依赖与互动。如果每个任务运行在它自己的私有数据集上，它并不需要保护这些数据，使用锁。即使在两个任务在哪里做共享一组公用的数据的情况下，你可以看的分区的方式，设置或提供的各项任务与它自己的拷贝。当然，复制的数据集有其代价也，所以你必须权衡这些同步在你做出决定之前的费用。

了解同步的限制

同步工具是有效的只有当他们一贯使用的应用程序中的所有线程。如果您创建一个互斥锁来限制对特定资源的访问，所有您的线程在试图操纵资源之前必须获取相同的互斥锁。未能做这么失败保护提供受此互斥体，是一个程序员的错误。

要意识到，代码正确性的威胁

使用锁和内存屏障时，你应该总是给仔细考虑它们的位置在您的代码中。甚至看起来好放置的锁可以实际上哄得你虚假的安全感。下面的一系列例子试图说明这一问题，指出在看似无害的代码中的缺陷。基本前提是你有一个可变的数组，包含一套不可改变的对象。假设您想要调用的数组中的第一个对象的方法。你可以使用下面的代码：

NSLock* arrayLock = GetArrayLock();

NSMutableArray* myArray = GetSharedArray();

id anObject;

[arrayLock lock];

anObject = [myArray objectAtIndex:0];

[arrayLock unlock];

[anObject doSomething];

因为数组是可变的锁在阵列附近阻止其他线程修改数组，直到你得到所需的对象。因为您检索该对象本身是不可变的一把锁不需要围绕对doSomething方法的调用。

虽然还有一个与前面的示例中的问题。如果您释放该锁，另一个线程进来之前，你有机会来执行doSomething方法从数组中移除所有对象，会发生什么？在无垃圾收集的应用程序，您的代码保存的对象可以被释放，离开anObject指向无效的内存地址。要解决此问题，您可能决定只是重新排列您的现有代码，并释放该锁后你的电话转给doSomething，如下所示：

NSLock* arrayLock = GetArrayLock();

NSMutableArray* myArray = GetSharedArray();

id anObject;

[arrayLock lock];

anObject = [myArray objectAtIndex:0];

[anObject doSomething];

[arrayLock unlock];

通过移动doSomething电话锁内的，您的代码保证在调用方法时，对象是仍然有效。不幸的是，如果doSomething方法需要很长的时间来执行，这可能会导致您代码持有锁的很长的时间，可以创建一个性能瓶颈。

代码的问题不是关键区域定义不清，但实际问题并不理解。真正的问题是只能由其他线程存在触发的内存管理问题。因为它可以由另一个线程释放，更好的解决方案将释放该锁之前保留anObject。此解决方案涉及的实际问题，正在释放对象，这样做没有介绍潜在的性能缺陷。

NSLock* arrayLock = GetArrayLock();

NSMutableArray* myArray = GetSharedArray();

id anObject;

[arrayLock lock];

anObject = [myArray objectAtIndex:0];

[anObject retain];

[arrayLock unlock];

[anObject doSomething];

[anObject release];

虽然前面的示例非常简单，自然，他们说明了很重要的一点。正确性的时候，你得想超越明显的问题。内存管理和设计的其他方面可能也受存在多个线程，所以你要想想前面这些问题。此外，您应该总是假定编译器会做最坏的可能事，安全的时候。这种意识和警惕性应该帮助你避免潜在的问题，并确保您的代码的行为正确。

如何使您的程序线程安全的更多示例，请参见线程安全摘要.

观看了死锁和制造

任何线程尝试在同一时间，采取多个锁定的时间有可能会发生死锁。当两个不同的线程持有的锁，另一个需要，然后尝试获取由另一个线程持有的锁的时候，就会发生死锁。结果是了，每个线程块永久因为它可以永远不会获得其他的锁。

锁是类似于一个死锁，当两个线程争夺相同的资源集时发生。在锁情况下，一个线程放弃其第一个锁在企图收购它的第二个锁。一旦它的第二次的锁，它可追溯，并尝试再次获取第一个锁。它锁定，因为它花费所有时间释放一个锁和尝试获取其他的锁，而不是做任何实际的工作。

最好的方法，以避免死锁和活锁的情况是，一次只能有一个锁。如果您必须一次获得多个锁，您应该确保其他线程不要试图做同样的事情。

正确使用 Volatile 变量

如果你已经在使用一个互斥锁保护的代码段，不要自动假定你需要使用volatile关键字来保护该节内的重要变量。互斥体包括一个内存屏障，以确保合适的次序的负载和存储操作。volatile关键字添加一个变量在一个临界区部队要每一次访问它时从内存加载的值。两个同步技术的结合可能需要在特定情况下，但也会导致重大的性能损失。如果互斥对象仅足以保护该变量，请省略volatile关键字。

它也是重要的你做不使用 volatile 变量在试图避免使用互斥锁。一般情况下，互斥锁和其他同步机制是更好的方式来保护你比 volatile 变量的数据结构的完整性。volatile关键字只确保变量是从内存加载，而不是存储在寄存器中。它不能确保您的代码正确访问的变量。

使用原子操作

非阻塞同步是一个办法执行某些类型的操作，避免锁的开支。虽然锁是有效的方法来同步两个线程，获取锁是相对昂贵的操作，即使在无异议的情况下。相比之下，许多原子操作需要的时间即可完成一小部分就像一把锁一样有效。

原子操作使您可以执行简单的数学和逻辑运算，在 32 位或 64 位的值。这些操作依赖于特殊的硬件指令 （和可选内存屏障），以确保在给定的操作完成之前再次访问受影响的内存。在多线程的情况下，您应始终使用包含一个内存屏障，以确保内存正确同步线程之间的原子操作。

表 4-3列出了可用的原子数学和逻辑运算和相应的函数名称。所有在/usr/include/libkern/OSAtomic.h头文件中，在那里你还可以找到完整的语法来声明这些函数。这些函数的 64 位版本是仅在 64 位进程中可用。

大多数原子函数的行为应该是相对比较简单，你会期望。然而，清单 4-1，表明原子的测试集和比较和交换操作，稍微复杂的行为。第三个调用OSAtomicTestAndSet函数表明位操纵公式正在使用一个整数值，而其结果可能从你期望有何不同。最后两个来电显示OSAtomicCompareAndSwap32函数的行为。在所有情况下，这些函数的调用在无异议的情况下当没有其他线程正在操作的值。

清单 4 1执行原子操作

int32_t  theValue = 0;

OSAtomicTestAndSet(0, &theValue);

// theValue is now 128.

theValue = 0;

OSAtomicTestAndSet(7, &theValue);

// theValue is now 1.

theValue = 0;

OSAtomicTestAndSet(15, &theValue)

// theValue is now 256.

OSAtomicCompareAndSwap32(256, 512, &theValue);

// theValue is now 512.

OSAtomicCompareAndSwap32(256, 1024, &theValue);

// theValue is still 512.

原子操作有关的信息，请参阅atomic的手册页和/usr/include/libkern/OSAtomic.h头文件。

使用锁定

锁是线程编程基本同步工具。锁使您能够轻松地保护大段代码，以便您可以确保该代码的正确性。OS X 和 iOS 为所有应用程序类型提供了基本的互斥锁和基础架构定义一些互斥锁的特殊情况下的其他款式。以下各节说明了如何使用这些锁类型的几个。

使用 POSIX 互斥锁

POSIX 互斥锁是非常容易使用，从任何应用程序。若要创建互斥锁，您声明并初始化一个pthread_mutex_t结构。若要锁定和解锁互斥锁，则使用pthread_mutex_lock 和pthread_mutex_unlock 功能。清单 4-2显示初始化和使用 POSIX 线程互斥锁所需的基本代码。当你完成这个锁定时，只需调用pthread_mutex_destroy 以释放锁数据结构。

清单 4-2使用互斥锁

pthread_mutex_t mutex;

void MyInitFunction()

{

    pthread_mutex_init(&mutex, NULL);

}

void MyLockingFunction()

{

    pthread_mutex_lock(&mutex);

    // Do work.

    pthread_mutex_unlock(&mutex);

}

使用 NSLock 类

NSLock 对象实现可可应用程序基本的互斥锁。所有的锁 （包括NSLock） 的界面实际上是由NSLocking协议，定义了lock和unlock的方法定义的。您可以使用这些方法来获取和释放锁，正如你将任何互斥体。

除了标准的锁定行为， NSLock类添加tryLock 和lockBeforeDate: 方法。tryLock方法尝试获取锁，但不阻塞锁是否不可用 ；相反，此方法只返回NO。lockBeforeDate:方法尝试获取锁，但取消阻止线程 （及其返回NO） 如果在指定期限内不获取锁。

下面的示例演示如何使用NSLock对象来协调更新的视觉展示，其数据正在计算由多个线程。如果线程无法立即获取锁，它只是会继续其计算，直到它可以获取该锁，并更新显示。

BOOL moreToDo = YES;

NSLock *theLock = [[NSLock alloc] init];

...

while (moreToDo) {

    /* Do another increment of calculation */

    /* until there’s no more to do. */

    if ([theLock tryLock]) {

        /* Update display used by all threads. */

        [theLock unlock];

    }

}

使用 @synchronized 指令

@synchronized指令是很方便地在目标 C 代码中动态创建互斥锁。@synchronized指令做出任何其他互斥锁会做 — — 它可以防止不同的线程在同一时间获得相同的锁。在这种情况下，你却不需要直接创建该互斥体或锁定的对象。相反，您只需使用任何目标 C 对象，作为一个锁定的标记，如下面的示例所示：

- (void)myMethod:(id)anObj

{

    @synchronized(anObj)

    {

        // Everything between the braces is protected by the @synchronized directive.

    }

}

对象传递给@synchronized指令是用来区分受保护的块的唯一标识符。如果你在两个不同的线程中执行前面的方法，传递anObj参数不同的对象在每个线程，每个会采取它的锁并没有被阻止由其他继续处理。如果你通过相同的对象在这两种情况下，然而，其中一个线程会第一次获取锁，另将被阻塞，直到第一个线程完成的关键部分。

作为预防措施， @synchronized块隐式地将异常处理程序添加到受保护的代码。此处理程序会自动释放互斥锁事件中引发的异常。这意味着要使用@synchronized指令，您还必须启用目标 C 中异常处理代码。如果你不想引起隐式异常处理程序的额外开销，您应该考虑使用的锁类。

关于@synchronized指令的详细信息，请参阅目标 C 编程语言. 

使用其他可可锁

以下各节描述了使用几种其他类型的可可锁的过程。

使用 NSRecursiveLock 对象

NSRecursiveLock类定义了一种锁，可以通过多次相同的线程而不会导致死锁的线程。递归锁定跟踪的它成功收购了多少次。每个成功的收购，锁的一定平衡由相应的调用，则打开挡板锁。只有当所有锁定和解锁电话平衡是实际上释放，以便其他线程可以获得它的锁。

正如其名称所暗示，这种类型的锁常用里面的递归函数以防止递归阻塞线程。你能同样用于非递归情况下调用的函数的语义要求他们也采取锁。这里是一个简单的递归函数，通过递归的锁一个例子。如果你没有为此代码使用一个NSRecursiveLock对象，该线程将死锁，当再次调用该函数。

NSRecursiveLock *theLock = [[NSRecursiveLock alloc] init];

void MyRecursiveFunction(int value)

{

    [theLock lock];

    if (value != 0)

    {

        --value;

        MyRecursiveFunction(value);

    }

    [theLock unlock];

}

MyRecursiveFunction(5);

使用 NSConditionLock 对象

NSConditionLock对象定义互斥锁，可以锁定和解锁与特定的值。你不应该混淆这种类型的锁，一个条件 （请参见条件）。行为是条件，有点类似，但以非常不同的方式实现。

通常情况下，您使用一个NSConditionLock对象，当线程需要按特定的顺序，例如当一个线程产生另一种消耗的数据执行任务。而执行的生产者，消费者获取锁使用特定于您的程序的一个条件。（条件本身是只是一个整数值，您定义）。当制作完成后时，它开启的锁和锁条件设置为相应的整数值，以唤醒使用者线程，然后继续处理数据。

NSConditionLock对象响应的锁定和解锁的方法可以用于任意组合。例如，您可以将配对与lock消息unlockWithCondition:，或lockWhenCondition:unlock的消息。当然，这后者的组合解锁锁定，但可能不释放任何线程等待一个特定的条件值。

下面的示例演示如何可能出现的生产者-消费者问题处理使用条件锁定。想象一下，一个应用程序包含队列的数据。一个生产者线程将数据添加到队列中，和使用者线程从队列中提取数据。生产者不需要等待一个特定的条件，但它必须等待锁可用，因此它可以安全地将数据添加到队列。

id condLock = [[NSConditionLock alloc] initWithCondition:NO_DATA];

while(true)

{

    [condLock lock];

    /* Add data to the queue. */

    [condLock unlockWithCondition:HAS_DATA];

}

因为锁初始状态设置为NO_DATA，制造者线程应该有没有麻烦最初获取锁。它用数据填充该队列，并将条件设置为HAS_DATA。在随后的迭代中，制造者线程可以添加新数据，因为它到达时，无论是否该队列为空或仍然有一些数据。它会阻止的唯一时间是当使用者线程从队列中提取数据。

因为使用者线程必须要处理的数据，它等待在队列中使用一个特定的条件。当生产者将数据放到队列上时，使用者线程醒来并获取它的锁。然后，它可以从队列中提取一些数据和更新队列的状态。下面的示例演示基本结构的使用者线程的处理循环。

while (true)

{

    [condLock lockWhenCondition:HAS_DATA];

    /* Remove data from the queue. */

    [condLock unlockWithCondition:(isEmpty ? NO_DATA : HAS_DATA)];

    // Process the data locally.

}

使用 NSDistributedLock 对象

的NSDistributedLock班在多个主机上的多个应用程序可用于限制对一些共享的资源如文件访问。锁本身实际上是使用文件系统项目如文件或目录实现互斥锁。也可以使用NSDistributedLock对象的锁必须可写由使用它的所有应用程序。这通常意味着放在可访问到的所有正在运行的应用程序的计算机的文件系统上。

不同于其他类型的锁， NSDistributedLock并不符合NSLocking协议，因而没有lock的方法。lock方法会阻止该线程的执行，并要求系统轮询锁在预定的速度。而比这刑罚对您的代码时， NSDistributedLock提供tryLock方法，并允许您决定是否不是轮询一次。

因为它使用文件系统实现，除非所有者显式地释放它不释放一个NSDistributedLock对象。如果您的应用程序崩溃时持有一个分布式的锁，其他客户端将无法访问受保护的资源。在这种情况，您可以使用breakLock方法，以打破现有的锁定，以便您可以获得它。破碎的锁应一般避免，不过，除非您确信所拥有的进程死并不能释放该锁。

与其他类型的锁，当你完成你使用NSDistributedLock对象，通过调用unlock的方法释放它。

使用条件

条件是锁的一种特殊类型，您可以使用同步操作必须出发的顺序。他们在一个微妙的方式不同的互斥锁。等待某一条件的线程仍处于阻塞状态，直到该条件明确由另一个线程终止状态。

由于参与执行操作系统的最微妙之处，条件锁获准返回杂散的成功，即使他们实际上不终止由您的代码。为了避免引起这些杂散信号的问题，你应该总是使用谓词会同与您的条件锁定。谓词是更具体的方式确定是否它是安全的您的线程继续。条件只是保持您的线程睡着直到谓词可以通过信号的线程设置。

以下各节说明了如何在您的代码中使用条件。

使用 NSCondition 类

NSCondition类提供 POSIX 条件相同的语义，但是在单个对象包装所需的锁和条件的数据结构。结果是一个对象，你可以像一个互斥锁，然后等像一个条件。

清单 4-3显示了代码片段演示用于在NSCondition对象上等待的事件序列。cocoaCondition变量包含对象NSCondition和timeToDoWork变量是从前夕信号条件下的另一个线程递增的整数。

清单 4-3使用可可条件

[cocoaCondition lock];

while (timeToDoWork <= 0)

    [cocoaCondition wait];

timeToDoWork--;

// Do real work here.

[cocoaCondition unlock];

清单 4-4显示了用于信号可可条件和递增谓词变量的代码。你总是应该向其发出信号之前锁定条件。

清单 4-4信号可可条件

[cocoaCondition lock];

timeToDoWork++;

[cocoaCondition signal];

[cocoaCondition unlock];

使用 POSIX 条件

POSIX 线程状态锁定要求使用一个条件的数据结构和一个互斥锁。虽然两个锁结构是独立的互斥锁是紧密地捆绑在运行时条件结构。线程等待信号应始终使用相同的互斥锁和条件结构在一起。更改的配对会导致错误。

清单 4-5显示了基本的初始化和使用条件和谓词。初始化条件和互斥锁，等待线程进入后一种 while 循环使用ready_to_go变量作为其谓词。只有当设置谓词和随后终止的条件并等待线程醒来，开始做其工作。

清单 4-5使用 POSIX 条件

pthread_mutex_t mutex;

pthread_cond_t condition;

Boolean     ready_to_go = true;

void MyCondInitFunction()

{

    pthread_mutex_init(&mutex);

    pthread_cond_init(&condition, NULL);

}

void MyWaitOnConditionFunction()

{

    // Lock the mutex.

    pthread_mutex_lock(&mutex);

    // If the predicate is already set, then the while loop is bypassed;

    // otherwise, the thread sleeps until the predicate is set.

    while(ready_to_go == false)

    {

        pthread_cond_wait(&condition, &mutex);

    }

    // Do work. (The mutex should stay locked.)

    // Reset the predicate and release the mutex.

    ready_to_go = false;

    pthread_mutex_unlock(&mutex);

}

该信号的线程是负责设置谓词并将信号发送到条件锁。清单 4-6显示了用于实现此类行为的代码。在此示例中，条件被示意在互斥锁防止等待状态的线程之间发生争用条件。

清单 4 6信号条件下锁

void SignalThreadUsingCondition()

{

    // At this point, there should be work for the other thread to do.

    pthread_mutex_lock(&mutex);

    ready_to_go = true;

    // Signal the other thread to begin work.

    pthread_cond_signal(&condition);

    pthread_mutex_unlock(&mutex);

}

iOS线程编程指南

标签：ios   线程   

原文地址：http://blog.csdn.net/zhaoguodongios/article/details/44081347