Threads and Thread Control

1. Threads and Thread Control • Thread Concepts • Pthread Creation and Termination • Pthread synchronization • Threads and Signals

2. Overview • Threads are concurrent lines of execution within a process. Sometimes called “lightweight processes” • All the threads of a process are in its memory space, but each thread has its own • Thread ID • Stack • Register values • Set of blocked and pending signals • Thread specific data • errno variable • There also must be a scheduling policy for thread execution

3. Overview • A typical UNIX process contains only a single thread of execution • Multiple threads allow us to take advantage of parallel programming without the overhead of a new process • May make programming for asynchronous events easier

4. POSIX Threads • pthreads are the optional POSIX standardization for threads • Must include <pthread.h> and link against the pthread library • -lpthread when compiling a C/C++ program

5. Thread Identification • Each thread has an identifier • Only unique within the process to which the thread belongs • IDs can be represented by pthread_t which can be a struct • Implementation of struct is system dependant • A thread can get its own ID structure withpthread_t pthread_self(void); • Compare two thread IDs with int pthread_equal(pthread_t t1, pthread_t t2);

6. Thread Creation int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg); • Arguments • thread points to the new thread ID • pthread_attr_t set of thread attributes. Use NULL for default attributes • start_routine is a function pointer to the function that the new thread will begin executing when it is created • arg is the single argument that may be passed to the start routine. If you need to pass multiple parameters, bundle them as a struct and pass that

7. Thread Termination • If any thread calls exit, _exit or Exit, the entire process will terminate • Thread may terminate due to exec • 3 ways a single thread can terminate • Return from the start routine • Call pthread_exitvoid pthread_exit(void *value_ptr); • Thread cancelled by another thread withint pthread_cancel(pthread_t thread);

8. Joining and Detaching int pthread_join(pthread_t thread, void **value_ptr); int pthread_detach(pthread_t thread); • Join is similar to waitpid. Allows a thread to wait on another to terminate • Termination status of thread waited on returned in value_ptr if specified in call to pthread_exit • pthread_detach allows us to put a thread in the detached state

9. Joinable Attribute • We can specify that a newly created thread is joinable or detached when we create the thread with the pthread_attr_t parameter • Threads created as detached can not be joined • Default is joinable • Detached thread resources are released as soon as thread terminates • Creating a thread as detached prevents synchronization (since we can’t join it)

10. Mutexes • Mutex – “mutual exclusion” • Only one thread at a time can own a particular mutex variable • A thread aquires the mutex by “locking” it. When it is done, it releases it by “unlocking” it • Mutex variable is of type pthread_mutex_t

11. Mutexes int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); • mutex is a pointer to a variable of type pthread_mutex_t • attr is a pointer to a type that holds attributes for non default mutexes. We can pass in NULL for a default mutex

12. Mutex Use • Declare mutex variable • pthread_mutex_t myMutex; • Initialize • pthread_mutex_create(&myMutex, NULL); • A thread locks the mutex • pthread_mutex_lock(&myMutex); • Thread executes critical section and then releases the mutext • pthread_mutex_unlock(&myMutex); • When mutex not longer needed, it can be destroyed • pthread_mutex_destroy(&myMutex);

13. Condition Variables • Allows threads to synchronize based on value of data • Avoids busy loop where threads acquire lock, check value of a variable and repeat until the value changes • Condition variables should always be protected by mutex locks

14. Condition Variables int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); int pthread_cond_destroy(pthread_cond_t *cond); int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t * mutex); int pthread_cond_broadcast(pthread_cond_t *cond); • Notify all threads waiting on this condition int pthread_cond_signal(pthread_cond_t *cond); • Notify a single thread waiting on this condition • See page 384-385 for example

15. Threads and Signals • Signals are delivered to a single thread • If signal is the result of hardware fault, it is usually sent to the thread that caused it • Otherwise signal sent to arbitrary thread • Each thread has its own signal mask int pthread_sigmask(int how, const sigset_t *set, sigset_t *oset); • Signal dispositions shared between all threads in a process

16. Threads and Signals int sigwait(const sigset_t *set, int *sig); • Allows a thread to wait for a signal from the set given by set parameter • The particular signal received is returned through the sig parameter • To prevent race condition, the signal being waited on must be blocked before calling this function int pthread_kill(pthread_t thread, int sig); • Sends a signal to a specified thread