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.

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:

SCHED_OTHER

Timesharing (TS) scheduling policy. It is based on the timesharing scheduling class.

SCHED_FIFO

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.

SCHED_RR

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 -mt compiler option compiles and links for multithreaded code. It compiles source files with -D_REENTRANT and augments the set of support libraries to include -lthread in the required order.

To ensure proper library linking order, use this option rather than -lthread to link with libthread.

/usr/include/pthread.h /lib/libpthread.* /lib/librt.*

/usr/include/thread.h /usr/include/sched.h /lib/libthread.*