Dictionary of Thread Terms

Base Address Control An eccentricity of Solaris which allows identification of where the thread will reside in physical memory.
Call-Once Functions An ability to limit execution of a particular function/routine only once. Subsequent calls will return without execution and error.
Cancellation Killing threads from within program.
Condition Variables
Detached Threads
Fork All Threads A flag which forces all thread-creation calls to be forks with shared memory. Since Linux defines a fork() as a specific kind of clone() (thread), this is somewhat inherent. Other implementations have to redefine or encapsulate thread-creation calls in order to accomplish this.
Fork Calling Thread Only
Forked Process A stand-alone task that shares nothing intrinsicly with other tasks. The only communication is has is through pipes, files and explicitly shared memory.
Joinable Threads The ability to merge threads into a single execution context(?).
Kernel-space Threads Threads that are handled/scheduled by the kernel.
Mutex Stands for Mutual Exclusion. A mutex can lock specific sections of memory using access flags.
Mutex Attributes
Per-thread Data Handling Function
Per-thread Signal Handling Ability to specify sharing signals. In other words, several threads can share a signal: if the signal is raised only one thread has to respond. This is different from unshared signals: each thread has its own signal table.
Priority Inversion Handling As threads get I/O blocked, provide a temporary reprioritization of threads.
Priority Scheduling Programmatically identifying the order, priority, or next threads to execute.
Process Essentially the same as a Task, having it's own private data and event regions. However, often "process" defines the whole running program which may have several threads and/or tasks. Also, "process" describes a supervising program.
Processor-specific Thread Allocation The ability to designate a specific thread to a specific processor. This is useful for processors that handle special things like interrupts or excelerators.
Readers/Writer Locking In Solaris, threads can have one writer and several readers at the same time.
Semaphores A pair of functions that lock datasets, p() and v() (lock and unlock, respectively)
Shared/Private Mutexes Having separate spaces for mutexes
Specifying Concurrency The ability to identify which threads will be multiprocessed.
Stack Size Control The ability to limit, resize or check the thread's stack usage.
Task Like the Process, a Task has its own data and event regions, but a task often includes interaction with other parent, child or sister tasks. The task may have specific assignments to perform; whereas, the process may supervise.
Thread The smallest context of execution (COE). Often it is created to share data directly with the parent.
Thread As how Linux Torvalds defines it: a "context of execution". It basically is the minimum basic executable unit that contains shared code, data and stack. Thus it is simply a processor's context.
Thread Attributes
Thread ID Comparison
Thread Suspension Temporarily halting execution of a thread. In Linux kernel-space threads, this can be accomplished using SIGSTOP and SIGCONT.
User-space Threads Threads that are handled/scheduled within a single task by special libraries.

[Left Arrow]
[Book Search]
[Right Arrow]
[Previous Page] [First Page] [Dictionary] [Email Author] [Next Page]