声明:本文档仅为个人学习过程中顺手翻译之作,方便开发的同胞借鉴参考。如有觉得译的不好不到位的地方,欢迎指正,将及时做出更正
|
- (void)criticalMethod |
{ |
@synchronized(self) { |
// Critical code. |
... |
} |
} |
11-2 展示了一个更常用的方式。在执行一个关键流程时,代码从 Account
类中获得了一个信号量并用它来锁定该关键流程快。 Account
类可以在它的initialize
方法中创建该信号量.
11-2
Account *account = [Account accountFromString:[accountField stringValue]]; |
|
// Get the semaphore. |
id accountSemaphore = [Account semaphore]; |
|
@synchronized(accountSemaphore) { |
// Critical code. |
... |
} |
Objective-C 的同步特性支持可迭代和可重入代码。一个线程可以在一个可迭代情况下多次使用单个信号量。其它的线程则被锁住直到占有锁的线程释放锁,即当 @synchronized()
块正常退出或者通过异常退出后。
当在 @synchronized()
块中的代码抛出一个异常时, Objective-C 运行时会捕获这个异常,释放该信号量 (这样被保护的代码即可以被其它线程执行), 并再次抛出该异常给下一个异常处理器。
英文原文:点击打开链接
Objective-C provides support for thread synchronization and exception handling, which are explained in this chapter and in “Exception
Handling.” To turn on support for these features,
use the -fobjc-exceptions
switch of the GNU Compiler Collection (GCC) version 3.3 and later.
Note: Using either of these features in a program renders the application runnable only in Mac OS X v10.3 and later because runtime support for exception handling and synchronization is not present in earlier versions of the software.
Objective-C supports multithreading in applications. Therefore, two threads can try to modify the same object at the same time, a situation that
can cause serious problems in a program. To protect sections of code from being executed by more than one thread at a time, Objective-C provides the @synchronized()
directive.
The @synchronized()
directive locks a section of code for use
by a single thread. Other threads are blocked until the thread exits the protected code—that is, when execution continues past the last statement in the@synchronized()
block.
The @synchronized()
directive takes as its only argument any Objective-C object, including self
.
This object is known as a mutual exclusion semaphore or mutex. It allows a thread to lock a section of code to prevent
its use by other threads. You should use separate semaphores to protect different critical sections of a program. It’s safest to create all the mutual exclusion objects before the application becomes multithreaded, to avoid race conditions.
Listing 11-1 shows code that uses self
as the mutex
to synchronize access to the instance methods of the current object. You can take a similar approach to synchronize the class methods of the associated class, using the class object instead of self
.
In the latter case, of course, only one thread at a time is allowed to execute a class method because there is only one class object that is shared by all callers.
Listing 11-1 Locking a method using self
- (void)criticalMethod |
{ |
@synchronized(self) { |
// Critical code. |
... |
} |
} |
Listing 11-2 shows a general approach. Before executing a critical process, the code obtains a semaphore from the Account
class
and uses it to lock the critical section. The Account
class could create the semaphore in itsinitialize
method.
Listing 11-2 Locking a method using a custom semaphore
Account *account = [Account accountFromString:[accountField stringValue]]; |
|
// Get the semaphore. |
id accountSemaphore = [Account semaphore]; |
|
@synchronized(accountSemaphore) { |
// Critical code. |
... |
} |
The Objective-C synchronization feature supports recursive and reentrant code. A thread can use a single semaphore several times in a recursive manner; other threads are blocked from using it until the thread releases all the locks obtained with it; that is,
every @synchronized()
block is exited normally or through an exception.
When code in an @synchronized()
block
throws an exception, the Objective-C runtime catches the exception, releases the semaphore (so that the protected code can be executed by other threads), and rethrows the exception to the next exception handler.
|
来自: 现在决定明天 > 《Objective-c官方文档》