苹果Cocoa框架下的多线程编程实战指南

2星需积分: 9 141 浏览量更新于2024-07-24 收藏 838KB PDF 举报

"Multithreading cocoa 多线程编程教程，详细介绍了苹果操作系统中的多线程技术，适用于iOS开发" 在苹果的操作系统，如iOS和macOS中，Cocoa框架提供了强大的多线程支持，使得开发者能够充分利用现代处理器的多核优势，提高应用程序的性能和响应性。多线程编程是实现并发执行任务的关键技术，它允许程序在不同的线程上同时运行多个独立的工作单元。 Threading Programming Guide是苹果官方提供的文档，旨在帮助开发者理解和使用Cocoa中的多线程特性。这份文档涵盖了线程的创建、管理以及线程安全等问题，内容丰富，适合有经验的iOS开发者深入学习。在iOS cocoa多线程编程中，主要涉及以下知识点： 1. **NSThread**：Cocoa提供的一种轻量级线程实现，开发者可以直接创建和控制线程。通过继承NSThread类或者使用block来启动线程，可以方便地执行后台任务。 2. **NSOperationQueue**：基于队列的多线程模型，比NSThread更高级，提供了任务调度和依赖管理。开发者可以添加NSOperation对象到队列中，系统会自动根据设备性能和当前负载来决定执行顺序和线程数量。 3. **GCD (Grand Central Dispatch)**：苹果引入的并行编程框架，提供了一种更抽象的方式来管理并发。GCD使用队列（Dispatch Queues）和任务（Dispatch Work Items），可以轻松实现同步和异步执行，同时支持串行和并行处理。 4. **线程安全**：在多线程环境中，数据访问和修改需要考虑线程安全问题。苹果提供了锁（NSLock、@synchronized关键字）、互斥量（NSMutex）、条件变量（NSCondition）等机制来确保数据一致性。 5. **内存管理**：在多线程环境下，内存管理变得复杂，需要遵循苹果的内存管理规则，比如ARC（Automatic Reference Counting）在多线程中的应用，以及如何避免内存泄漏。 6. **线程优先级与调度**：线程的优先级和调度策略影响程序的执行效率。苹果提供了线程优先级设置，以及对操作队列的QoS（Quality of Service）分类，帮助开发者优化性能。 7. **能源效率**：在移动设备上，多线程编程还需要考虑能源效率，合理安排任务执行，避免无谓的CPU唤醒，延长电池寿命。 8. **KVO（Key-Value Observing）与多线程**：当KVO在多线程环境中使用时，需要注意线程安全，避免因不同线程中对同一对象的属性进行观察而引发的问题。 9. **NSRunLoop**：在多线程中，每个线程都有自己的NSRunLoop，用于处理事件循环。理解NSRunLoop的工作原理对于实现自定义的长时间运行任务至关重要。 10. **错误处理与调试**：在多线程编程中，错误处理和调试也是一大挑战。学会使用 Instruments 工具进行性能分析和线程检测，可以帮助定位和解决多线程问题。苹果的Cocoa框架提供了丰富的工具和API来支持多线程编程，开发者可以根据实际需求选择合适的方法来实现并发，提升应用性能，同时需要关注线程安全和资源管理，确保程序的稳定性和效率。通过深入学习Threading Programming Guide，开发者可以更好地掌握iOS和macOS平台上的多线程编程技巧。

Threading Support

If you have existing code that uses threads, Mac OS X and iOS provide several technologies for creating

threads in your applications. In addition, both systems also provide support for managing and synchronizing

the work that needs to be done on those threads. The following sections describe some of the key technologies

that you need to be aware of when working with threads in Mac OS X and iOS.

Threading Packages

Although the underlying implementation mechanism for threads is Mach threads, you rarely (if ever) work

with threads at the Mach level. Instead, you usually use the more convenient POSIX API or one of its derivatives.

The Mach implementation does provide the basic features of all threads, however, including the preemptive

execution model and the ability to schedule threads so they are independent of each other.

Listing 2-2 lists the threading technologies you can use in your applications.

Table 1-2 Thread technologies

DescriptionTechnology

Cocoa implements threads using the NSThread class. Cocoa also provides methods

on NSObject for spawning new threads and executing code on already-running

threads. For more information, see “Using NSThread” (page 22) and “Using NSObject

to Spawn a Thread” (page 25).

Cocoa threads

POSIX threads provide a C-based interface for creating threads. If you are not writing

a Cocoa application, this is the best choice for creating threads. The POSIX interface

is relatively simple to use and offers ample flexibility for configuring your threads.

For more information, see “Using POSIX Threads” (page 24)

POSIX threads

Multiprocessing Services is a legacy C-based interface used by applications

transitioning from older versions of Mac OS. This technology is available in Mac OS

X only and should be avoided for any new development. Instead, you should use

the NSThread class or POSIX threads. For more information about this technology,

however, see Multiprocessing Services Programming Guide.

Multiprocessing

Services

At the application level, all threads behave in essentially the same way as on other platforms. After starting

a thread, the thread runs in one of three main states: running, ready, or blocked. If a thread is not currently

running, it is either blocked and waiting for input or it is ready to run but not scheduled to do so yet. The

thread continues moving back and forth among these states until it finally exits and moves to the terminated

state.

When you create a new thread, you must specify an entry-point function (or an entry-point method in the

case of Cocoa threads) for that thread. This entry-point function constitutes the code you want to run on the

thread. When the function returns, or when you terminate the thread explicitly, the thread stops permanently

and is reclaimed by the system. Because threads are relatively expensive to create in terms of memory and

time, it is therefore recommended that your entry point function do a significant amount of work or set up

a run loop to allow for recurring work to be performed.

Threading Support

CHAPTER 1

About Threaded Programming

For more information about the available threading technologies and how to use them, see “Thread

Management” (page 21).

Run Loops

A run loop is a piece of infrastructure used to manage events arriving asynchronously on a thread. A run loop

works by monitoring one or more event sources for the thread. As events arrive, the system wakes up the

thread and dispatches the events to the run loop, which then dispatches them to the handlers you specify.

If no events are present and ready to be handled, the run loop puts the thread to sleep.

You are not required to use a run loop with any threads you create but doing so can provide a better

experience for the user. Run loops make it possible to create long-lived threads that use a minimal amount

of resources. Because a run loop puts its thread to sleep when there is nothing to do, it eliminates the need

for polling, which wastes CPU cycles and prevents the processor itself from sleeping and saving power.

To configure a run loop, all you have to do is launch your thread, get a reference to the run loop object,

install your event handlers, and tell the run loop to run. The infrastructure provided by both Cocoa and

Carbon handles the configuration of the main thread’s run loop for you automatically. If you plan to create

long-lived secondary threads, however, you must configure the run loop for those threads yourself.

Details about run loops and examples of how to use them are provided in “Run Loops” (page 33).

Synchronization Tools

One of the hazards of threaded programming is resource contention among multiple threads. If multiple

threads try to use or modify the same resource at the same time, problems can occur. One way to alleviate

the problem is to eliminate the shared resource altogether and make sure each thread has its own distinct

set of resources on which to operate. When maintaining completely separate resources is not an option

though, you may have to synchronize access to the resource using locks, conditions, atomic operations, and

other techniques.

Locks provide a brute force form of protection for code that can be executed by only one thread at a time.

The most common type of lock is mutual exclusion lock, also known as a mutex. When a thread tries to

acquire a mutex that is currently held by another thread, it blocks until the lock is released by the other

thread. Several system frameworks provide support for mutex locks, although they are all based on the same

underlying technology. In addition, Cocoa provides several variants of the mutex lock to support different

types of behavior, such as recursion. For more information about the available types of locks, see “Locks” (page

58).

In addition to locks, the system provides support for conditions, which ensure the proper sequencing of tasks

within your application. A condition acts as a gatekeeper, blocking a given thread until the condition it

represents becomes true. When that happens, the condition releases the thread and allows it to continue.

The POSIX layer and Foundation framework both provide direct support for conditions. (If you use operation

objects, you can configure dependencies among your operation objects to sequence the execution of tasks,

which is very similar to the behavior offered by conditions.)

Although locks and conditions are very common in concurrent design, atomic operations are another way

to protect and synchronize access to data. Atomic operations offer a lightweight alternative to locks in

situations where you can perform mathematical or logical operations on scalar data types. Atomic operations

use special hardware instructions to ensure that modifications to a variable are completed before other

threads have a chance to access it.

Threading Support 15

CHAPTER 1

About Threaded Programming

For more information about the available synchronization tools, see “Synchronization Tools” (page 57).

Interthread Communication

Although a good design minimizes the amount of required communication, at some point, communication

between threads becomes necessary. (A thread’s job is to do work for your application, but if the results of

that job are never used, what good is it?) Threads may need to process new job requests or report their

progress to your application’s main thread. In these situations, you need a way to get information from one

thread to another. Fortunately, the fact that threads share the same process space means you have lots of

options for communication.

There are many ways to communicate between threads, each with its own advantages and disadvantages.

“Configuring Thread-Local Storage” lists the most common communication mechanisms you can use in Mac

OS X. (With the exception of message queues and Cocoa distributed objects, these technologies are also

available in iOS.) The techniques in this table are listed in order of increasing complexity.

Table 1-3 Communication mechanisms

DescriptionMechanism

Cocoa applications support the ability to perform selectors directly on other threads.

This capability means that one thread can essentially execute a method on any other

thread. Because they are executed in the context of the target thread, messages sent

this way are automatically serialized on that thread. For information about input

sources, see “Cocoa Perform Selector Sources” (page 36).

Direct messaging

Another simple way to communicate information between two threads is to use a

global variable, shared object, or shared block of memory. Although shared variables

are fast and simple, they are also more fragile than direct messaging. Shared variables

must be carefully protected with locks or other synchronization mechanisms to ensure

the correctness of your code. Failure to do so could lead to race conditions, corrupted

data, or crashes.

Global variables,

shared memory,

and objects

Conditions are a synchronization tool that you can use to control when a thread

executes a particular portion of code. You can think of conditions as gate keepers,

letting a thread run only when the stated condition is met. For information on how

to use conditions, see “Using Conditions” (page 70).

Conditions

A custom run loop source is one that you set up to receive application-specific

messages on a thread. Because they are event driven, run loop sources put your thread

to sleep automatically when there is nothing to do, which improves your thread’s

efficiency. For information about run loops and run loop sources, see “Run Loops” (page

33).

Run loop sources

Port-based communication is a more elaborate way to communication between two

threads, but it is also a very reliable technique. More importantly, ports and sockets

can be used to communicate with external entities, such as other processes and

services. For efficiency, ports are implemented using run loop sources, so your thread

sleeps when there is no data waiting on the port. For information about run loops

and about port-based input sources, see “Run Loops” (page 33).

Ports and sockets

Threading Support

CHAPTER 1

About Threaded Programming

DescriptionMechanism

Multiprocessing Services defines a first-in, first-out (FIFO) queue abstraction for

managing incoming and outgoing data. Although message queues are simple and

convenient, they are not as efficient as some other communications techniques. For

more information about how to use message queues, see Multiprocessing Services

Programming Guide.

Message queues

Distributed objects is a Cocoa technology that provides a high-level implementation

of port-based communications. Although it is possible to use this technology for

interthread communication, doing so is highly discouraged because of the amount

of overhead it incurs. Distributed objects is much more suitable for communicating

with other processes, where the overhead of going between processes is already high.

For more information, see Distributed Objects Programming Topics.

Cocoa distributed

objects

Design Tips

The following sections offer guidelines to help you implement threads in a way that ensures the correctness

of your code. Some of these guidelines also offer tips for achieving better performance with your own

threaded code. As with any performance tips, you should always gather relevant performance statistics

before, during, and after you make changes to your code.

Avoid Creating Threads Explicitly

Writing thread-creation code manually is tedious and potentially error-prone and you should avoid it whenever

possible. Mac OS X and iOS provide implicit support for concurrency through other APIs. Rather than create

a thread yourself, consider using asynchronous APIs, GCD, or operation objects to do the work. These

technologies do the thread-related work behind the scenes for you and are guaranteed to do it correctly. In

addition, technologies such as GCD and operation objects are designed to manage threads much more

efficiently than your own code ever could by adjusting the number of active threads based on the current

system load. For more information about GCD and operation objects, see Concurrency Programming Guide.

Keep Your Threads Reasonably Busy

If you decide to create and manage threads manually, remember that threads consume precious system

resources. You should do your best to make sure that any tasks you assign to threads are reasonably long-lived

and productive. At the same time, you should not be afraid to terminate threads that are spending most of

their time idle. Threads use a nontrivial amount of memory, some of it wired, so releasing an idle thread not

only helps reduce your application’s memory footprint, it also frees up more physical memory for other

system processes to use.

Design Tips 17

CHAPTER 1

About Threaded Programming

剩余83页未读，继续阅读

江中散人

粉丝: 2w+
资源: 19

苹果Cocoa框架下的多线程编程实战指南

C++多线程编程食谱：全面掌握并发技术

掌握Linux多线程编程实战指南

现代多线程编程：Java与C++/Pthreads/Win32实现、测试与调试

Multithreading(苹果操作系统cocoa多线程编程)定义.pdf

苹果 cocoa编程教程

iOS多线程编程指南

Cocoa Programming for Mac OS X

掌握多线程编程：概念与实战指南

【中国房地产业协会-2024研报】2024年第三季度房地产开发企业信用状况报告.pdf

【中国银行-2024研报】美国大选结果对我国芯片产业发展的影响和应对建议.pdf

最新资源