JavaScript is required to for searching.
Skip Navigation Links
Exit Print View
Multithreaded Programming Guide     Oracle Solaris 11.1 Information Library
search filter icon
search icon

Document Information


1.  Covering Multithreading Basics

Multithreading Terms

Oracle Solaris Multithreading Libraries and Standards

Benefiting From Multithreading

Improving Application Responsiveness

Using Multiprocessors Efficiently

Improving Program Structure

Using Fewer System Resources

Combining Threads and RPC

Multithreading Concepts

Concurrency and Parallelism

Multithreading Structure

User-Level Threads

User-Level Threads State

Thread Scheduling

Thread Cancellation

Thread Synchronization

Using the 64-bit Architecture

2.  Basic Threads Programming

3.  Thread Attributes

4.  Programming with Synchronization Objects

5.  Programming With the Oracle Solaris Software

6.  Programming With Oracle Solaris Threads

7.  Safe and Unsafe Interfaces

8.  Compiling and Debugging

9.  Programming Guidelines

A.  Extended Example: A Thread Pool Implementation


Multithreading Terms

Table 1-1 introduces some of the terms that are used in this book.

Table 1-1 Multithreading Terms

The UNIX environment, such as file descriptors, user ID, and so on, created with the fork(2) system call, which is set up to run a program.
A sequence of instructions executed within the context of a process.
POSIX pthreads
A threads interface that is POSIX threads compliant. See Oracle Solaris Multithreading Libraries and Standards for more information.
Oracle Solaris threads
An Oracle Solaris threads interface that is not POSIX threads compliant. A predecessor of pthreads.
Restricts access to a single thread. Execution is through sequential processing, limited to one thread of control.
Allows access to two or more threads. Execution occurs in more than one thread of control, using parallel or concurrent processing.
User-level or Application-level threads
Threads managed by threads routines in user space, as opposed to kernel space. The POSIX pthreads and Oracle Solaris threads APIs are used to create and handle user threads. In this manual, and in general, a thread is a user-level thread.

Note - Because this manual is for application programmers, kernel thread programming is not discussed.

Lightweight processes
Kernel threads, also called LWPs, that execute kernel code and system calls. LWPs are managed by the system thread scheduler, and cannot be directly controlled by the application programmer. Beginning with Solaris 9, every user-level thread has a dedicated LWP. This is known as a 1:1 thread model.
Bound thread (obsolete term)
Prior to Solaris 9, a user-level thread that is permanently bound to one LWP. Beginning with Solaris 9, every thread has a dedicated LWP, so all threads are bound threads. The concept of an unbound thread no longer exists.
Unbound thread (obsolete term)
Prior to Solaris 9, a user-level thread that is not necessarily bound to one LWP. Beginning with Solaris 9, every thread has a dedicated LWP, so the concept of unbound threads no longer exists.
Attribute object
Contains opaque data types and related manipulation functions. These data types and functions standardize some of the configurable aspects of POSIX threads, mutual exclusion locks (mutexes), and condition variables.
Mutual exclusion locks
Objects used to lock and unlock access to shared data. Such objects are also known as mutexes.
Condition variables
Objects used to block threads until a change of state.
Read-write locks
Objects used to allow multiple read-only access to shared data, but exclusive access for modification of that data.
Counting semaphore
A memory-based synchronization mechanism in which a non-negative integer count is used to coordinate access by multiple threads to shared resources.
A condition that arises when at least two threads are executing simultaneously.
A condition that exists when at least two threads are making progress. A more generalized form of parallelism that can include time-slicing as a form of virtual parallelism.