Linux Threads Home Page: Dictionary

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.
Synchronization |
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.

[Previous Page] | [First Page] | [Dictionary] | [Email Author] | [Next Page]