• About Concurrency

• Terminology

• Mac OS X Support

• Threads

• Operation Objects

• Synchronization Tools

• Run Loops

• Interthread Communication

• Alternatives to Threads

• Design Considerations

• Define Your Application’s Expected Behavior

• Factor Your Code Into Discrete Tasks

• Consider Alternatives to Threading

• Design Tips

• Avoid Creating Threads Explicitly

• Keep Your Threads Reasonably Busy

• Avoid Shared Data Structures

• Threads and Your User Interface

• Be Aware of Thread Behaviors at Quit Time

• Handle Exceptions

• Terminate Your Threads Cleanly

• Thread Safety in Libraries

• About Operation Objects and Operation Queues

• Configuration Options for Operation Objects

• Defining Operation Objects

• Using an NSInvocationOperation Object

• Defining a Simple NSOperation Subclass

• Configuring Dependencies Among Operation Objects

• Customizing the Execution Environment of an Operation Object

• Configuring a Custom Runtime Environment

• Maintaining KVO Compliance

• Responding to Errors

• Running Operations

• Using a Queue to Run Operations

• Running an Operation Object Directly

• About Mac OS X Threads

• Threading Technologies

• Thread Costs

• Creating a Thread

• Using NSThread

• Using POSIX Threads

• Using NSObject to Spawn a Thread

• Using Other Threading Technologies

• Creating POSIX Threads in a Cocoa Application

• Protecting the Cocoa Frameworks

• Supporting Autoreleased Objects

• Mixing POSIX and Cocoa Locks

• Configuring Threads

• Configuring the Stack Size of a Thread

• Memory Management in Threads

• Configuring Thread-Local Storage

• Setting Up a Run Loop

• Setting the Detached State of a Thread

• Setting the Thread Priority

• Terminating a Thread

• Synchronization Tools

• Atomic Operations

• Memory Barriers and Volatile Variables

• Locks

• Conditions

• Perform Selector Routines

• Synchronization and Performance

• Thread Safety and Signals

• Tips for Thread-Safe Designs

• Avoid Synchronization Altogether

• Understand the Limits of Synchronization

• Be Aware of Threats to Code Correctness

• Watch Out for Deadlocks and Livelocks

• Use Volatile Variables Correctly

• Using Atomic Operations

• Using Locks

• Using a POSIX Mutex Lock

• Using the NSLock Class

• Using the @synchronized Directive

• Using Other Cocoa Locks

• Using an NSRecursiveLock Object

• Using an NSConditionLock Object

• Using an NSDistributedLock Object

• Using Conditions

• Using the NSCondition Class

• Using POSIX Conditions

• Anatomy of a Run Loop

• Run Loop Modes

• Input Sources

• Port-Based Sources

• Custom Input Sources

• Cocoa Perform Selector Sources

• Timer Sources

• Run Loop Observers

• The Run Loop Sequence of Events

• When Would You Use a Run Loop?

• Using Run Loop Objects

• Getting a Run Loop Object

• Configuring the Run Loop

• Starting the Run Loop

• Exiting the Run Loop

• Thread Safety and Run Loop Objects

• Configuring Run Loop Sources

• Defining a Custom Input Source

• Defining the Input Source

• Installing the Input Source on the Run Loop

• Coordinating with Clients of the Input Source

• Signaling the Input Source

• Configuring Timer Sources

• Configuring a Port-Based Input Source

• Configuring an NSMachPort Object

• Implementing the Main Thread Code

• Implementing the Secondary Thread Code

• Configuring an NSMessagePort Object

• Configuring a Port-Based Input Source in Core Foundation

• Cocoa

• Foundation Framework Thread Safety

• Thread-Safe Classes

• Thread-Unsafe Classes

• Mutable Versus Immutable

• Reentrancy

• Class Initialization

• Autorelease Pools

• Run Loops

• Application Kit Framework Thread Safety

• Windows

• Events

• Drawing

• NSView

• NSGraphicsContext

• NSImage

• Core Data Framework

• Core Foundation