NAME | SYNOPSIS | DESCRIPTION | Function Comparison | LOCKING | SCHEDULING | ALTERNATE IMPLEMENTATION | ERRORS | ATTRIBUTES | FILES | SEE ALSO
cc –mt [ flag... ] file...– lpthread [ -lposix4 library... ]
#include <pthread.h>
cc – mt [ flag... ] file...[ library... ]
#include <sched.h>
#include <thread.h>
POSIX and Solaris threads each have their own implementation of the threads library. The libpthread library is associated with POSIX; the libthread library is associated with Solaris. Both implementations are interoperable, their functionality similar, and can be used within the same application. Only POSIX threads are guaranteed to be fully portable to other POSIX-compliant environments. POSIX and Solaris threads require different source, include files and linking libraries. See SYNOPSIS.
Most of the functions in the libpthread and libthread, libraries have a counterpart in the other corresponding library. POSIX function names, with the exception of the semaphore names, have a "pthread" prefix. Function names for similar POSIX and Solaris have similar endings. Typically, similar POSIX and Solaris functions have the same number and use of arguments.
POSIX pthreads and Solaris threads differ in the following ways:
POSIX threads are more portable.
POSIX threads establish characteristics for each thread according to configurable attribute objects.
POSIX pthreads implement thread cancellation.
POSIX pthreads enforce scheduling algorithms.
POSIX pthreads allow for clean-up handlers for fork(2) calls.
Solaris threads can be suspended and continued.
Solaris threads implement an optimized mutex and interprocess robust mutex locks.
Solaris threads implement daemon threads, for whose demise the process does not wait.
The following table compares the POSIX pthreads and Solaris threads functions. When a comparable interface is not available either in POSIX pthreads or Solaris threads, a hyphen (–) appears in the column.
POSIX (libpthread) | Solaris (libthread) |
pthread_create() | thr_create() |
pthread_attr_init() | – |
pthread_attr_setdetachstate() | – |
pthread_attr_getdetachstate() | – |
pthread_attr_setinheritsched() | – |
pthread_attr_getinheritsched() | – |
pthread_attr_setschedparam() | – |
pthread_attr_getschedparam() | – |
pthread_attr_setschedpolicy() | – |
pthread_attr_getschedpolicy() | – |
pthread_attr_setscope() | – |
pthread_attr_getscope() | – |
pthread_attr_setstackaddr() | – |
pthread_attr_getstackaddr() | – |
pthread_attr_setstacksize() | – |
pthread_attr_getstacksize() | – |
pthread_attr_getguardsize() | – |
pthread_attr_setguardsize() | – |
pthread_attr_destroy() | – |
– | thr_min_stack() |
POSIX (libpthread) | Solaris (libthread) |
pthread_exit() | thr_exit() |
pthread_join() | thr_join() |
pthread_detach() | – |
POSIX (libpthread) | Solaris (libthread) |
pthread_key_create() | thr_keycreate() |
pthread_setspecific() | thr_setspecific() |
pthread_getspecific() | thr_getspecific() |
pthread_key_delete() | – |
POSIX (libpthread) | Solaris (libthread) |
– | thr_yield() |
– | thr_suspend() |
– | thr_continue() |
pthread_setconcurrency() | thr_setconcurrency() |
pthread_getconcurrency() | thr_getconcurrency() |
pthread_setschedparam() | thr_setprio() |
pthread_getschedparam() | thr_getprio() |
POSIX (libpthread) | Solaris (libthread) |
pthread_cancel() | – |
pthread_setcancelstate() | – |
pthread_setcanceltype() | – |
pthread_testcancel() | – |
pthread_cleanup_pop() | – |
pthread_cleanup_push() | – |
POSIX (libpthread) | Solaris (libthread) |
pthread_mutex_init() | mutex_init() |
pthread_mutexattr_init() | – |
pthread_mutexattr_setpshared() | – |
pthread_mutexattr_getpshared() | – |
pthread_mutexattr_setprotocol() | – |
pthread_mutexattr_getprotocol() | – |
pthread_mutexattr_setprioceiling() | – |
pthread_mutexattr_getprioceiling() | – |
pthread_mutexattr_settype() | – |
pthread_mutexattr_gettype() | – |
pthread_mutexattr_destroy() | – |
pthread_mutex_setprioceiling() | – |
pthread_mutex_getprioceiling() | – |
pthread_mutex_lock() | mutex_lock() |
pthread_mutex_trylock() | mutex_trylock() |
pthread_mutex_unlock() | mutex_unlock() |
pthread_mutex_destroy() | mutex_destroy() |
POSIX (libpthread) | Solaris (libthread) |
pthread_cond_init() | cond_init() |
pthread_condattr_init() | – |
pthread_condattr_setpshared() | – |
pthread_condattr_getpshared() | – |
pthread_condattr_destroy() | – |
pthread_cond_wait() | cond_wait() |
pthread_cond_timedwait() | cond_timedwait() |
pthread_cond_signal() | cond_signal() |
pthread_cond_broadcast() | cond_broadcast() |
pthread_cond_destroy() | cond_destroy() |
POSIX (libpthread) | Solaris (libthread) |
pthread_rwlock_init() | rwlock_init() |
pthread_rwlock_rdlock() | rw_rdlock() |
pthread_rwlock_tryrdlock() | rw_tryrdlock() |
pthread_rwlock_wrlock() | rw_wrlock() |
pthread_rwlock_trywrlock() | rw_trywrlock() |
pthread_rwlock_unlock() | rw_unlock() |
pthread_rwlock_destroy() | rwlock_destroy() |
pthread_rwlockattr_init() | – |
pthread_rwlockattr_destroy() | – |
pthread_rwlockattr_getpshared() | – |
pthread_rwlockattr_setpshared() | – |
POSIX (libpthread) | Solaris (libthread) |
sem_init() | sema_init() |
sem_open() | – |
sem_close() | – |
sem_wait() | sema_wait() |
sem_trywait() | sema_trywait() |
sem_post() | sema_post() |
sem_getvalue() | – |
sem_unlink() | – |
sem_destroy() | sema_destroy() |
POSIX (libpthread) Solaris (libthread) Multi-threaded behavior is asynchronous, and therefore, optimized for concurrent and parallel processing. As threads, always from within the same process and sometimes from multiple processes, share global data with each other, they are not guaranteed exclusive access to the shared data at any point in time. Securing mutually exclusive access to shared data requires synchronization among the threads. Both POSIX and Solaris implement four synchronization mechanisms: mutexes, condition variables, reader/writer locking (optimized frequent-read occasional-write mutex), and semaphores.
Synchronizing multiple threads diminishes their concurrency. The coarser the grain of synchronization, that is, the larger the block of code that is locked, the lesser the concurrency.
If a POSIX threads program calls fork(2), it implicitly calls fork1(2), which replicates only the calling thread. Should there be any outstanding mutexes throughout the process, the application should call pthread_atfork(3THR), to wait for and acquire those mutexes, prior to calling fork().
Scheduling allocation size per thread is greater than one. POSIX supports the following three scheduling policies:
Timesharing (TS) scheduling policy. It is based on the timesharing scheduling class.
First-In-First-Out (FIFO) scheduling policy. Threads scheduled to this policy, if not pre-empted by a higher priority, will proceed until completion. Threads whose contention scope is system (PTHREAD_SCOPE_SYSTEM) are in real-time (RT) scheduling class. The calling process must have a effective user ID of 0. SCHED_FIFO for threads whose contention scope's process (PTHREAD_SCOPE_PROCESS) is based on the TS scheduling class.
Round-Robin scheduling policy. Threads scheduled to this policy, if not pre-empted by a higher priority, will execute for a time period determined by the system. Threads whose contention scope is system (PTHREAD_SCOPE_SYSTEM) are in real-time (RT) scheduling class and the calling process must have a effective user ID of 0. SCHED_RR for threads whose contention scope is process (PTHREAD_SCOPE_PROCESS) is based on the TS scheduling class.
Only scheduling policy supported is SCHED_OTHER, which is timesharing, based on the TS scheduling class.
The default threads library implementation is a two-level model in which user-level threads are multiplexed over possibly fewer lightweight processes, or LWPs. An LWP is the fundamental unit of execution that is dispatched to a processor by the operating system.
The Solaris 8 operating environment provides an alternate threads library implementation, a one-level model, in which user-level threads are associated one-to-one with LWPs.
The version of the alternate threads library in Solaris 8 Update 7 has been improved over older versions in previous Solaris 8 updates with the addition of user-level sleep queues and adaptive mutex locking. It is the same as what will be the default threads library included in the next full release of Solaris.
This version of the alternate threads library has proved to be beneficial for essentially all multithreaded applications, providing improved performance and scalability over the default threads library. It provides exactly the same interfaces, both for POSIX threads and Solaris threads, as the default threads library. It obeys the following constraints that are not obeyed by the default threads library:
All runnable threads are attached to LWPs (no need for the application to specify a desired concurrency level).
No hidden threads are created by the library itself.
A multithreaded process with only one thread has semantics identical to that of a traditional single threaded process.
To link with the alternate threads library, use the following runpath (-R) options when linking the program:
cc -mt ... -lpthread ... -R /usr/lib/lwp (32-bit) cc -mt ... -lpthread ... -R /usr/lib/lwp/64 (64-bit) |
cc -mt ... -R /usr/lib/lwp (32-bit) cc -mt ... -R /usr/lib/lwp/64 (64-bit) |
For multithreaded programs that have been previously linked with the default threads library, the environment variables LD_LIBRARY_PATH and LD_LIBRARY_PATH_64 can be set as follows to bind the program at runtime to the alternate threads library:
LD_LIBRARY_PATH=/usr/lib/lwp LD_LIBRARY_PATH_64=/usr/lib/lwp/64 |
Note that if an LD_LIBRARY_PATH environment variable is in effect for a secure application (one with its set-uid or set-gid flag set), then only the trusted directories specified by this variable will be used to augment the runtime linker's search rules. Such applications should be linked with the alternate threads library using the runpath options described above.
The runtime linker can also be instructed to use the alternate threads library by establishing an alternative object cache; see crle(1) with the -a option.
When using the alternate one-level threads library, be aware that it could create more LWPs than the default threads library using unbound threads. Each LWP requires system memory for a stack and other data structures to use while executing in the kernel, approximately 10 Kbytes for a 32-bit operating system and 20 Kbytes for a 64-bit operating system. Running applications with many thousands of threads might require additional physical memory on the system.
In a multi-threaded application, linked with libpthread or libthread, EINTR may be returned whenever another thread calls fork(2), which calls fork1(2) instead.
See attributes(5) for descriptions of the following attributes:
ATTRIBUTE TYPE | ATTRIBUTE VALUE |
---|---|
MT-Level | MT-Safe, Fork 1-Safe |
/usr/include/pthread.h /lib/libpthread.* /lib/libposix4.*
/usr/include/thread.h /usr/include/sched.h /lib/libthread.*
crle(1), fork(2), pthread_atfork(3THR), pthread_create(3THR), attributes(5), standards(5)
Linker and Libraries Guide
NAME | SYNOPSIS | DESCRIPTION | Function Comparison | LOCKING | SCHEDULING | ALTERNATE IMPLEMENTATION | ERRORS | ATTRIBUTES | FILES | SEE ALSO