A specific style of program that displays a graphical interface to the user.
The principle of organizing an application around blocks of code that can be run concurrently with an application’s main thread or other threads of execution. Asynchronous tasks are started by one thread but actually run on a different thread, taking advantage of additional processor resources to finish their work more quickly.
A C construct for encapsulating inline code and data so that it can be performed later. You use blocks to encapsulate tasks you want to perform, either inline in the current thread or on a separate thread using a dispatch queue. For more information, see Blocks Programming Topics.
An operation object that does not perform its task in the thread from which its start method was called. A concurrent operation typically sets up its own thread or calls an interface that sets up a separate thread on which to perform the work.
A construct used to synchronize access to a resource. A thread waiting on a condition is not allowed to proceed until another thread explicitly signals the condition.
A portion of code that must be executed by only one thread at a time.
A dispatch source used to process application-defined events. A custom source calls your custom event handler in response to events that your application generates.
An abstract identifier used to access a file, socket, or other system resource.
A Grand Central Dispatch (GCD) structure that you use to execute your application’s tasks. GCD defines dispatch queues for executing tasks either serially or concurrently.
A Grand Central Dispatch (GCD) data structure that you create to process system-related events.
A dispatch source used to process file-related events. A file descriptor source calls your custom event handler either when file data is available for reading or writing or in response to file system changes.
A binary executable that is loaded dynamically into an application’s process space rather than linked statically as part of the application binary.
A type of bundle that packages a dynamic shared library with the resources and header files that support that library. For more information, see Framework Programming Guide.
A dispatch queue provided to your application automatically by Grand Central Dispatch (GCD). You do not have to create global queues yourself or retain or release them. Instead, you retrieve them using the system-provided functions.
A technology for executing asynchronous tasks concurrently. GCD is available in Mac OS X v10.6 and later and iOS 4.0 and later.
A source of asynchronous events for a thread. Input sources can be port based or manually triggered and must be attached to the thread’s run loop.
A thread whose resources are not reclaimed immediately upon termination. Joinable threads must be explicitly detached or be joined by another thread before the resources can be reclaimed. Joinable threads provide a return value to the thread that joins with them.
A UNIX feature for monitoring low-level system events. For more information see the kqueue man page.
A dispatch source used to process events arriving on a Mach port.
A special type of thread created when its owning process is created. When the main thread of a program exits, the process ends.
A lock that provides mutually exclusive access to a shared resource. A mutex lock can be held by only one thread at a time. Attempting to acquire a mutex held by a different thread puts the current thread to sleep until the lock is finally acquired.
A standards-based technology for performing general-purpose computations on a computer’s graphics processor. For more information, see OpenCL Programming Guide for Mac OS X.
An instance of the NSOperation class. Operation objects wrap the code and data associated with a task into an executable unit.
An instance of the NSOperationQueue class. Operation queues manage the execution of operation objects.
A dispatch queue that you create, retain, and release explicitly.
The runtime instance of an application or program. A process has its own virtual memory space and system resources (including port rights) that are independent of those assigned to other programs. A process always contains at least one thread (the main thread) and may contain any number of additional threads.
A dispatch source used to handle process-related events. A process source calls your custom event handler in response to changes to the process you specify.
A combination of code and resources that can be run to perform some task. Programs need not have a graphical user interface, although graphical applications are also considered programs.
Code that can be started on a new thread safely while it is already running on another thread.
An event-processing loop, during which events are received and dispatched to appropriate handlers.
A collection of input sources, timer sources, and run loop observers associated with a particular name. When run in a specific “mode,” a run loop monitors only the sources and observers associated with that mode.
An instance of the NSRunLoop class or CFRunLoopRef opaque type. These objects provide the interface for implementing an event-processing loop in a thread.
A recipient of notifications during different phases of a run loop’s execution.
A protected variable that restricts access to a shared resource. Mutexes and conditions are both different types of semaphore.
A UNIX mechanism for manipulating a process from outside its domain. The system uses signals to deliver important messages to an application, such as whether the application executed an illegal instruction. For more information see the signal man page.
A dispatch source used to process UNIX signals. A signal source calls your custom event handler whenever the process receives a UNIX signal.
A quantity of work to be performed. Although some technologies (most notably Carbon Multiprocessing Services) use this term differently, the preferred usage is as an abstract concept indicating some quantity of work to be performed.
A flow of execution in a process. Each thread has its own stack space but otherwise shares memory with other threads in the same process.
A dispatch source used to process periodic events. A timer source calls your custom event handler at regular, time-based intervals.
Last updated: 2010-04-13