Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.

html

The POSIX thread libraries are a standards based thread API for C/C++. It allows one to spawn a new
concurrent process flow. It is most effective on multi-processor or multi-core systems where the
process flow can be scheduled to run on another processor thus gaining speed through parallel or
distributed processing. Threads require less overhead than "forking" or spawning a new process
because the system does not initialize a new system virtual memory space and environment for the
process. While most effective on a multiprocessor system, gains are also found on uniprocessor
systems which exploit latency in I/O and other system functions which may halt process execution.
(One thread may execute while another is waiting for I/O or some other system latency.) Parallel
programming technologies such as MPI and PVM are used in a distributed computing environment
while threads are limited to a single computer system. All threads within a process share the same
address space. A thread is spawned by defining a function and its arguments which will be
processed in the thread. The purpose of using the POSIX thread library in your software is to execute
software faster.

Table of Contents:

# Thread Basics
# Thread Creation and
Termination
# Thread
Synchronization
# Thread Scheduling
# Thread Pitfalls
# Thread Debugging
# Thread Man Pages Congratulations, You are our 888,888th visitor!
# Links right now online That's why we've just selected you to be the our possible winner:
on 11/04/2011 - an Apple iMac - iPhone4 - iPad
# Books at 00:04 If selected: >>click here<<

| Home Page | Linux Tutorials | Terms | Privacy Policy | Advertising | Contact |

Thread Basics:
Related YoLinux
Tutorials:
Thread operations include thread creation, termination, synchronization
° C++ on Linux (joins,blocking), scheduling, data management and process interaction.
A thread does not maintain a list of created threads, nor does it know the
° C++ STL (Standard thread that created it.
Template Library) example All threads within a process share the same address space.
of a linked list using a list
Threads in the same process share:
° C++ string class Process instructions
examples Most data
open files (descriptors)
° X-emacs and C++ signals and signal handlers
development current working directory
User and group id
° C++ Structure Example
and Tutorial Each thread has a unique:
Thread ID
° Linux software set of registers, stack pointer
development tutorial stack for local variables, return addresses
signal mask
°YoLinux Tutorials Index
priority
Return value: errno
pthread functions return "0" if OK.

Thread Creation and Termination:

Example: pthread1.c

01 #include <stdio.h>

1 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

02 #include <stdlib.h>
03 #include <pthread.h>
04
05 void *print_message_function( void *ptr );
06
07 main()
08 {
09 pthread_t thread1, thread2;
10 char *message1 = "Thread 1";
11 char *message2 = "Thread 2";
12 int iret1, iret2;
13
14 /* Create independent threads each of which will
execute function */
15
16 iret1 = pthread_create( &thread1, NULL,
print_message_function, (void*) message1);
17 iret2 = pthread_create( &thread2, NULL,
print_message_function, (void*) message2);
18
19 /* Wait till threads are complete before main
continues. Unless we */
20 /* wait we run the risk of executing an exit which
will terminate */
21 /* the process and all threads before the threads
have completed. */
22
23 pthread_join( thread1, NULL);
24 pthread_join( thread2, NULL);
25
26 printf("Thread 1 returns: %d\n",iret1);
27 printf("Thread 2 returns: %d\n",iret2);
28 exit(0);
29 }
30
31 void *print_message_function( void *ptr )
32 {
33 char *message;
34 message = (char *) ptr;
35 printf("%s \n", message);
36 }
Ads by Google
Linux Server
Linux Books Compile:
Linux Download
Tutorial
Linux OS Tutorial
C compiler: cc -lpthread pthread1.c
or
C++ compiler: g++ -lpthread pthread1.c
Free Information
Technology
Magazines and Run: ./a.out
Document Downloads Results:
Thread 1
Thread 2
Thread 1 returns: 0
Thread 2 returns: 0

Details:

In this example the same function is used in each thread. The arguments
are different. The functions need not be the same.
Free Information Threads terminate by explicitly calling pthread_exit, by letting the function
Technology Software return, or by a call to the function exit which will terminate the process
and Development including any threads.
Magazine
Subscriptions and Function call: pthread_create - create a new thread
Document Downloads
int pthread_create(pthread_t * thread,
const pthread_attr_t * attr,
void * (*start_routine)(void *),
void *arg);

Arguments:
thread - returns the thread id. (unsigned long int defined in

2 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

bits/pthreadtypes.h)
attr - Set to NULL if default thread attributes are used. (else define
members of the struct pthread_attr_t defined in bits/pthreadtypes.h)
Attributes include:
detached state (joinable? Default: PTHREAD_CREATE_JOINABLE. Other
option: PTHREAD_CREATE_DETACHED)
scheduling policy (real-time?
PTHREAD_INHERIT_SCHED,PTHREAD_EXPLICIT_SCHED,SCHED_OTHER)
scheduling parameter
inheritsched attribute (Default: PTHREAD_EXPLICIT_SCHED Inherit from
parent thread: PTHREAD_INHERIT_SCHED)
scope (Kernel threads: PTHREAD_SCOPE_SYSTEM User threads:
PTHREAD_SCOPE_PROCESS Pick one or the other not both.)
guard size
stack address (See unistd.h and bits/posix_opt.h
_POSIX_THREAD_ATTR_STACKADDR)
stack size (default minimum PTHREAD_STACK_SIZE set in pthread.h),
void * (*start_routine) - pointer to the function to be threaded.
Function has a single argument: pointer to void.
*arg - pointer to argument of function. To pass multiple arguments,
send a pointer to a structure.

Function call: pthread_join - wait for termination of another thread

int pthread_join(pthread_t th, void **thread_return);

Arguments:
th - thread suspended until the thread identified by th terminates,
either by calling pthread_exit() or by being cancelled.
thread_return - If thread_return is not NULL, the return value of th is
stored in the location pointed to by thread_return.

Function call: pthread_exit - terminate the calling thread

void pthread_exit(void *retval);

Arguments:
retval - Return value of thread.

This routine kills the thread. The pthread_exit function never returns. If the
thread is not detached, the thread id and return value may be examined
from another thread by using pthread_join.
Note: the return pointer *retval, must not be of local scope otherwise it
would cease to exist once the thread terminates.

[C++ pitfalls]: The above sample program will compile with the GNU C and
C++ compiler g++. The following function pointer representation below will
work for C but not C++. Note the subtle differences and avoid the pitfall
below:

1 void print_message_function( void *ptr );

2 ...
3 ...
4 iret1 = pthread_create( &thread1, NULL,
(void*)&print_message_function, (void*) message1);
5 ...
6 ...

Thread Synchronization:

The threads library provides three synchronization mechanisms:

mutexes - Mutual exclusion lock: Block access to variables by other

threads. This enforces exclusive access by a thread to a variable or set of
variables.
joins - Make a thread wait till others are complete (terminated).
condition variables - data type pthread_cond_t

3 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

Mutexes:

Mutexes are used to prevent data inconsistencies due to operations by multiple

threads upon the same memory area performed at the same time or to prevent
race conditions where an order of operation upon the memory is expected. A
contention or race condition often occurs when two or more threads need to
perform operations on the same memory area, but the results of computations
depends on the order in which these operations are performed. Mutexes are
used for serializing shared resources such as memory. Anytime a global resource
is accessed by more than one thread the resource should have a Mutex
associated with it. One can apply a mutex to protect a segment of memory
("critical region") from other threads. Mutexes can be applied only to threads in a
single process and do not work between processes as do semaphores.

Example threaded function:

Without Mutex With Mutex

1 int 01 /* Note scope of variable and mutex

counter=0; are the same */
2 02 pthread_mutex_t mutex1 =
3 /* Function C PTHREAD_MUTEX_INITIALIZER;
*/ 03 int counter=0;
4 void 04
functionC() 05 /* Function C */
5 { 06 void functionC()
6 07 {
7 counter++ 08 pthread_mutex_lock( &mutex1 );
8 09 counter++
9 } 10 pthread_mutex_unlock( &mutex1 );
11 }

Possible execution sequence

Thread 1 Thread 2 Thread 1 Thread 2
counter = counter = counter =
counter = 0
0 0 0
counter = counter = counter = Thread 2 locked out.
1 1 1 Thread 1 has exclusive use of variable
counter
counter = 2

If register load and store operations for the incrementing of variable counter
occurs with unfortunate timing, it is theoretically possible to have each thread
increment and overwrite the same variable with the same value. Another
possibility is that thread two would first increment counter locking out thread one
until complete and then thread one would increment it to 2.

Sequence Thread 1 Thread 2

1 counter = 0 counter=0
Thread 1 locked out.
2 counter = 1
Thread 2 has exclusive use of variable counter
3 counter = 2

Code listing: mutex1.c

01 #include <stdio.h>
02 #include <stdlib.h>
03 #include <pthread.h>
04
05 void *functionC();
06 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
07 int counter = 0;
08
09 main()
10 {
11 int rc1, rc2;

4 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

12 pthread_t thread1, thread2;

13
14 /* Create independent threads each of which will
execute functionC */
15
16 if( (rc1=pthread_create( &thread1, NULL, &functionC,
NULL)) )
17 {
18 printf("Thread creation failed: %d\n", rc1);
19 }
20
21 if( (rc2=pthread_create( &thread2, NULL, &functionC,
NULL)) )
22 {
23 printf("Thread creation failed: %d\n", rc2);
24 }
25
26 /* Wait till threads are complete before main
continues. Unless we */
27 /* wait we run the risk of executing an exit which will
terminate */
28 /* the process and all threads before the threads have
completed. */
29
30 pthread_join( thread1, NULL);
31 pthread_join( thread2, NULL);
32
33 exit(0);
34 }
35
36 void *functionC()
37 {
38 pthread_mutex_lock( &mutex1 );
39 counter++;
40 printf("Counter value: %d\n",counter);
41 pthread_mutex_unlock( &mutex1 );
42 }

Compile: cc -lpthread mutex1.c

Run: ./a.out
Results:
Counter value: 1
Counter value: 2

When a mutex lock is attempted against a mutex which is held by another

thread, the thread is blocked until the mutex is unlocked. When a thread
terminates, the mutex does not unless explicitly unlocked. Nothing happens by
default.

Man Pages:

pthread_mutex_lock() - acquire a lock on the specified mutex variable. If the

mutex is already locked by another thread, this call will block the calling
thread until the mutex is unlocked.
pthread_mutex_unlock() - unlock a mutex variable. An error is returned if
mutex is already unlocked or owned by another thread.
pthread_mutex_trylock() - attempt to lock a mutex or will return error code if
busy. Useful for preventing deadlock conditions.

Joins:

A join is performed when one wants to wait for a thread to finish. A thread calling
routine may launch multiple threads then wait for them to finish to get the results.
One waits for the completion of the threads with a join.

Sample code: join1.c

01 #include <stdio.h>
02 #include <pthread.h>
03
04 #define NTHREADS 10

5 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

05 void *thread_function(void *);

06 pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
07 int counter = 0;
08
09 main()
10 {
11 pthread_t thread_id[NTHREADS];
12 int i, j;
13
14 for(i=0; i < NTHREADS; i++)
15 {
16 pthread_create( &thread_id[i], NULL,
thread_function, NULL );
17 }
18
19 for(j=0; j < NTHREADS; j++)
20 {
21 pthread_join( thread_id[j], NULL);
22 }
23
24 /* Now that all threads are complete I can print the
final result. */
25 /* Without the join I could be printing a value before
all the threads */
26 /* have been
completed.
*/
27
28 printf("Final counter value: %d\n", counter);
29 }
30
31 void *thread_function(void *dummyPtr)
32 {
33 printf("Thread number %ld\n", pthread_self());
34 pthread_mutex_lock( &mutex1 );
35 counter++;
36 pthread_mutex_unlock( &mutex1 );
37 }

Compile: cc -lpthread join1.c

Run: ./a.out
Results:
Thread number 1026
Thread number 2051
Thread number 3076
Thread number 4101
Thread number 5126
Thread number 6151
Thread number 7176
Thread number 8201
Thread number 9226
Thread number 10251
Final counter value: 10

Man Pages:

pthread_create() - create a new thread

pthread_join() - wait for termination of another thread
pthread_self() - return identifier of current thread

Condition Variables:

A condition variable is a variable of type pthread_cond_t and is used with the

appropriate functions for waiting and later, process continuation. The condition
variable mechanism allows threads to suspend execution and relinquish the
processor until some condition is true. A condition variable must always be
associated with a mutex to avoid a race condition created by one thread
preparing to wait and another thread which may signal the condition before the
first thread actually waits on it resulting in a deadlock. The thread will be
perpetually waiting for a signal that is never sent. Any mutex can be used, there
is no explicit link between the mutex and the condition variable.

Man pages of functions used in conjunction with the condition variable:

6 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

Creating/Destroying:
pthread_cond_init
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_cond_destroy
Waiting on condition:
pthread_cond_wait - unlocks the mutex and waits for the condition
variable cond to be signaled.
pthread_cond_timedwait - place limit on how long it will block.
Waking thread based on condition:
pthread_cond_signal - restarts one of the threads that are waiting on
the condition variable cond.
pthread_cond_broadcast - wake up all threads blocked by the
specified condition variable.

Example code: cond1.c

01 #include <stdio.h>
02 #include <stdlib.h>
03 #include <pthread.h>
04
05 pthread_mutex_t count_mutex =
PTHREAD_MUTEX_INITIALIZER;
06 pthread_cond_t condition_var =
PTHREAD_COND_INITIALIZER;
07
08 void *functionCount1();
09 void *functionCount2();
10 int count = 0;
11 #define COUNT_DONE 10
12 #define COUNT_HALT1 3
13 #define COUNT_HALT2 6
14
15 main()
16 {
17 pthread_t thread1, thread2;
18
19 pthread_create( &thread1, NULL, &functionCount1, NULL);
20 pthread_create( &thread2, NULL, &functionCount2, NULL);
21
22 pthread_join( thread1, NULL);
23 pthread_join( thread2, NULL);
24
25 printf("Final count: %d\n",count);
26
27 exit(0);
28 }
29
30 // Write numbers 1-3 and 8-10 as permitted by
functionCount2()
31
32 void *functionCount1()
33 {
34 for(;;)
35 {
36 // Lock mutex and then wait for signal to relase
mutex
37 pthread_mutex_lock( &count_mutex );
38
39 // Wait while functionCount2() operates on count
40 // mutex unlocked if condition varialbe in
functionCount2() signaled.
41 pthread_cond_wait( &condition_var, &count_mutex );
42 count++;
43 printf("Counter value functionCount1: %d\n",count);
44
45 pthread_mutex_unlock( &count_mutex );
46
47 if(count >= COUNT_DONE) return(NULL);
48 }
49 }
50
51 // Write numbers 4-7
52
53 void *functionCount2()
54 {

7 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

55 for(;;)
56 {
57 pthread_mutex_lock( &count_mutex );
58
59 if( count < COUNT_HALT1 || count > COUNT_HALT2 )
60 {
61 // Condition of if statement has been met.
62 // Signal to free waiting thread by freeing the
mutex.
63 // Note: functionCount1() is now permitted to
modify "count".
64 pthread_cond_signal( &condition_var );
65 }
66 else
67 {
68 count++;
69 printf("Counter value functionCount2:
%d\n",count);
70 }
71
72 pthread_mutex_unlock( &count_mutex );
73
74 if(count >= COUNT_DONE) return(NULL);
75 }
76
77 }

Compile: cc -lpthread cond1.c

Run: ./a.out
Results:
Counter value functionCount1: 1
Counter value functionCount1: 2
Counter value functionCount1: 3
Counter value functionCount2: 4
Counter value functionCount2: 5
Counter value functionCount2: 6
Counter value functionCount2: 7
Counter value functionCount1: 8
Counter value functionCount1: 9
Counter value functionCount1: 10
Final count: 10

Note that functionCount1() was halted while count was between the values
COUNT_HALT1 and COUNT_HALT2. The only thing that has been ensures is
that functionCount2 will increment the count between the values COUNT_HALT1
and COUNT_HALT2. Everything else is random.

The logic conditions (the "if" and "while" statements) must be chosen to insure
that the "signal" is executed if the "wait" is ever processed. Poor software logic
can also lead to a deadlock condition.

Note: Race conditions abound with this example because count is used as the
condition and can't be locked in the while statement without causing deadlock.

Thread Scheduling:

When this option is enabled, each thread may have its own scheduling
properties. Scheduling attributes may be specified:

during thread creation

by dynamically by changing the attributes of a thread already created
by defining the effect of a mutex on the thread's scheduling when creating
a mutex
by dynamically changing the scheduling of a thread during synchronization
operations.

The threads library provides default values that are sufficient for most cases.

Thread Pitfalls:

Race conditions: While the code may appear on the screen in the order you
wish the code to execute, threads are scheduled by the operating system

8 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

and are executed at random. It cannot be assumed that threads are

executed in the order they are created. They may also execute at different
speeds. When threads are executing (racing to complete) they may give
unexpected results (race condition). Mutexes and joins must be utilized to
achieve a predictable execution order and outcome.

Thread safe code: The threaded routines must call functions which are
"thread safe". This means that there are no static or global variables which
other threads may clobber or read assuming single threaded operation. If
static or global variables are used then mutexes must be applied or the
functions must be re-written to avoid the use of these variables. In C, local
variables are dynamically allocated on the stack. Therefore, any function
that does not use static data or other shared resources is thread-safe.
Thread-unsafe functions may be used by only one thread at a time in a
program and the uniqueness of the thread must be ensured. Many
non-reentrant functions return a pointer to static data. This can be avoided
by returning dynamically allocated data or using caller-provided storage. An
example of a non-thread safe function is strtok which is also not
re-entrant. The "thread safe" version is the re-entrant version strtok_r.

Mutex Deadlock: This condition occurs when a mutex is applied but then
not "unlocked". This causes program execution to halt indefinitely. It can
also be caused by poor application of mutexes or joins. Be careful when
applying two or more mutexes to a section of code. If the first
pthread_mutex_lock is applied and the second pthread_mutex_lock fails
due to another thread applying a mutex, the first mutex may eventually lock
all other threads from accessing data including the thread which holds the
second mutex. The threads may wait indefinitely for the resource to become
free causing a deadlock. It is best to test and if failure occurs, free the
resources and stall before retrying.

01 ...
02 pthread_mutex_lock(&mutex_1);
03 while ( pthread_mutex_trylock(&mutex_2) ) /* Test if
already locked */
04 {
05 pthread_mutex_unlock(&mutex_1); /* Free resource to
avoid deadlock */
06 ...
07 /* stall here */
08 ...
09 pthread_mutex_lock(&mutex_1);
10 }
11 count++;
12 pthread_mutex_unlock(&mutex_1);
13 pthread_mutex_unlock(&mutex_2);
14 ...

The order of applying the mutex is also important. The following code
segment illustrates a potential for deadlock:

01 void *function1()
02 {
03 ...
04 pthread_mutex_lock(&lock1); // Execution step
1
05 pthread_mutex_lock(&lock2); // Execution step
3 DEADLOCK!!!
06 ...
07 ...
08 pthread_mutex_lock(&lock2);
09 pthread_mutex_lock(&lock1);
10 ...
11 }
12
13 void *function2()
14 {
15 ...
16 pthread_mutex_lock(&lock2); // Execution step
2
17 pthread_mutex_lock(&lock1);
18 ...

9 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

19 ...
20 pthread_mutex_lock(&lock1);
21 pthread_mutex_lock(&lock2);
22 ...
23 }
24
25 main()
26 {
27 ...
28 pthread_create(&thread1, NULL, function1, NULL);
29 pthread_create(&thread2, NULL, function2, NULL);
30 ...
31 }

If function1 acquires the first mutex and function2 acquires the second, all
resources are tied up and locked.

Condition Variable Deadlock: The logic conditions (the "if" and "while"
statements) must be chosen to insure that the "signal" is executed if the
"wait" is ever processed.

Thread Debugging:

GDB:
Debugging Programs with Multiple Threads
GDB: Stopping and starting multi-thread programs
GDB/MI: Threads commands
DDD:
Examining Threads

Thread Man Pages:

pthread_atfork - register handlers to be called at fork(2) time

pthread_attr_destroy [pthread_attr_init] - thread creation attributes
pthread_attr_getdetachstate [pthread_attr_init] - thread creation attributes
pthread_attr_getguardsize - get the guardsize attribute in the attr object.
pthread_attr_getinheritsched [pthread_attr_init] - thread creation attributes
pthread_attr_getschedparam [pthread_attr_init] - thread creation attributes
pthread_attr_getschedpolicy [pthread_attr_init] - thread creation attributes
pthread_attr_getscope [pthread_attr_init] - thread creation attributes
pthread_attr_getstack - get the thread creation stack attributes stackaddr
and stacksize in the attr object.
pthread_attr_getstackaddr - get the thread creation stackaddr attributes
stackaddr attribute in the attr object.
pthread_attr_getstacksize - get the thread creation stacksize attribute in the
attr object.
pthread_attr_init - thread creation attributes
pthread_attr_setdetachstate [pthread_attr_init] - thread creation attributes
pthread_attr_setguardsize - set the guardsize attribute in the attr object.
pthread_attr_setinheritsched [pthread_attr_init] - thread creation attributes
pthread_attr_setschedparam [pthread_attr_init] - thread creation attributes
pthread_attr_setschedpolicy [pthread_attr_init] - thread creation attributes
pthread_attr_setscope [pthread_attr_init] - thread creation attributes
pthread_attr_setstack - set the thread creation stack attributes stackaddr
and stacksize in the attr object.
pthread_attr_setstackaddr - set the thread creation stackaddr attributes
stackaddr attribute in the attr object.
pthread_attr_setstacksize - set the thread creation stacksize attribute in the
attr object.
pthread_cancel - thread cancellation
pthread_cleanup_pop [pthread_cleanup_push] - install and remove
cleanup handlers
pthread_cleanup_pop_restore_np [pthread_cleanup_push] - install and
remove cleanup handlers
pthread_cleanup_push - install and remove cleanup handlers
pthread_cleanup_push_defer_np [pthread_cleanup_push] - install and
remove cleanup handlers

10 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

pthread_condattr_destroy [pthread_condattr_init] - condition creation

attributes
pthread_condattr_init - condition creation attributes
pthread_cond_broadcast [pthread_cond_init] - operations on conditions
pthread_cond_destroy [pthread_cond_init] - operations on conditions
pthread_cond_init - operations on conditions
pthread_cond_signal [pthread_cond_init] - operations on conditions
pthread_cond_timedwait [pthread_cond_init] - operations on conditions
pthread_cond_wait [pthread_cond_init] - operations on conditions
pthread_create - create a new thread
pthread_detach - put a running thread in the detached state
pthread_equal - compare two thread identifiers
pthread_exit - terminate the calling thread
pthread_getschedparam [pthread_setschedparam] - control thread
scheduling parameters
pthread_getspecific [pthread_key_create] - management of thread-specific
data
pthread_join - wait for termination of another thread
pthread_key_create - management of thread-specific data
pthread_key_delete [pthread_key_create] - management of thread-specific
data
pthread_kill_other_threads_np - terminate all threads in program except
calling thread
pthread_kill [pthread_sigmask] - handling of signals in threads
pthread_mutexattr_destroy [pthread_mutexattr_init] - mutex creation
attributes
pthread_mutexattr_getkind_np [pthread_mutexattr_init] - mutex creation
attributes
pthread_mutexattr_init - mutex creation attributes
pthread_mutexattr_setkind_np [pthread_mutexattr_init] - mutex creation
attributes
pthread_mutex_destroy [pthread_mutex_init] - operations on mutexes
pthread_mutex_init - operations on mutexes
pthread_mutex_lock [pthread_mutex_init] - operations on mutexes
pthread_mutex_trylock [pthread_mutex_init] - operations on mutexes
pthread_mutex_unlock [pthread_mutex_init] - operations on mutexes
pthread_once - once-only initialization
pthread_self - return identifier of current thread
pthread_setcancelstate [pthread_cancel] - thread cancellation
pthread_setcanceltype [pthread_cancel] - thread cancellation
pthread_setschedparam - control thread scheduling parameters
pthread_setspecific [pthread_key_create] - management of thread-specific
data
pthread_sigmask - handling of signals in threads
pthread_testcancel [pthread_cancel] - thread cancellation

Links:

Fundamentals Of Multithreading - Paul Mazzucco

Native Posix Thread Library for Linux
Posix threads for MS/Win32: [Announcement / description] sourceforge
home page
Introduction to Programming Threads
Getting Started With POSIX Threads
ITS: Introduction to Threads
GNU Portable Threads
Introduction of threads for Solaris, Linux, and Windows
Comparison of thread implementations
comp.programming.threads FAQ
An in-depth description of PMPthread internal queue functions.
Examples
Pthreads tutorial and examples of thread problems - by Andrae Muys
Valgrind KDE thread checker: Helgrind
Sun's Multithreaded Programming Guide - Not Linux but a good reference.
Linux-mag.com: Concurrent Programming Topics - semaphores, condition
variables

11 of 12 4/11/2011 2:34 PM
Linux Tutorial: POSIX Threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

Linux-mag.com: The Fibers of Threads - Discussion of how Linux threads

work
Platform independent threads:
Gnome GLib 2.0 threads - Thread abstraction; including mutexes,
conditions and thread private data. [example]
OmniORB (CORBA) Thread Library
zThreads
C++ Thread classes:
GNU: Common C++ - support for threading, sockets, file access,
daemons, persistence, serial I/O, XML parsing and system services
ACE: Adaptive Communication Environment - C++ interface
ACE programmers guide: [pdf] (see page 29 for threads)
Thread management examples using ACE
Hood - A C++ Threads Library for Multiprogrammed Multiprocessors
C++ Thread classes - sourceforge
QpThread

News Groups:

comp.programming.threads
comp.unix.solaris

Books:

Pthreads Programming A POSIX

Standard for Better Multiprocessing
By Bradford Nichols, Dick Buttlar,
Jacqueline Proulx Farrell
ISBN #1-56592-115-1, O'Reilly

Programming with POSIX(R) Threads

By David R. Butenhof
ISBN #0201633922, Addison Wesley
Pub. Co.

C++ Network Programming Volume 1

By Douglas C. Schmidt, Stephen D.
Huston
ISBN #0201604647, Addison Wesley
Pub. Co.

Covers ACE (ADAPTIVE Communication

Environment) open-source framework
view of threads and other topics.

YoLinux.com Home Page Pthread

YoLinux Tutorial Index | Terms Open your eyes to OpenMP. Get code
samples and expert advice. Go!
Privacy Policy | Advertise with us | Bookmark
Feedback Form | saved by
0
Unauthorized copying or redistribution
prohibited.
870

Copyright © 2002 - 2011 by Greg Ippolito

12 of 12 4/11/2011 2:34 PM