UNIX Threads

• A thread (or lightweight process) is a basic unit of CPU utilization; it consists of:
  • Program counter
  • Register set
  • Stack space
• A thread shares with its peer threads its:
  • Code segment
  • Data segment
  • Operating-system resources, e.g., when one thread alters a code segment memory item, all other threads see that, and a file open with one thread is available to others.
• A traditional or heavyweight process is equal to a task with one thread.
• As an OS may supports multiple processes, a process can have multiple threads.

  

• Multithreading your code can have many benefits:
  • Improve application responsiveness
    Any program in which many activities are not dependent upon each other can be redesigned so that each activity is defined as a thread. For example, the user of a multithreaded GUI does not have to wait for one activity to complete before starting another.
  • Use multiprocessors more efficiently
    Typically, applications that express concurrency requirements with threads need not take into account the number of available processors. The performance of the application improves transparently with additional processors. Numerical algorithms and applications with a high degree of parallelism, such as matrix multiplications, can run much faster when implemented with threads on a multiprocessor.
  • Improve program structure
    Many programs are more efficiently structured as multiple independent or semi-independent units of execution instead of as a single, monolithic thread. Multithreaded programs can be more adaptive to variations in user demands than single threaded programs.
  • Use fewer system resources
    Programs that use two or more processes that access common data through shared memory are applying more than one thread of control. However, each process has a full address space and operating systems state. The cost of creating and maintaining this large amount of state information makes each process much more expensive than a thread in both time and space. In addition, the inherent separation between processes can require a major effort by the programmer to communicate between the threads in different processes, or to synchronize their actions.
• Benefits of threads vs processes
  • Less time to create a new thread than a process, because the newly created thread uses the current process address space.
  • Less time to terminate a thread than a process.
  • Less time to switch between two threads within the same process, partly because the newly created thread uses the current process address space.
  • Less communication overheads - communicating between the threads of one process is simple because the threads share everything: address space, in particular. Data produced by one thread is immediately available to all the other threads.

• Include pthread.h and (might have to) link with libpthread
• Creating a (default) thread
  • int pthread_create(pthread_t *tid, const pthread_attr_t *tattr, void*(*start_routine)(void *), void *arg);
  • Creates a thread with attributes specified by tattr, within a process. When tattr is NULL the default thread is created with the following attributes:
    • It is unbounded
    • It is not detached
    • It has a a default stack and stack size
    • It inherits the parent's priority
    A default attribute object can also be created with pthread_attr_init()
  • start_routine is the function at which the new thread begins execution.
    • arg is passed as the sole argument of start_routine.
    • When start_routine returns the thread exits with the exit status set to the value returned by start_routine.
  • When pthread_create is successful the ID of the thread created is stored in the location referred to as tid.
  • pthread_create() returns a zero and exits when it completes successfully. Any other returned value indicates that an error occurred.
  • The arguments passed by pointer in the last argument should reside somewhere stable, e.g., malloc the memory.
• Detaching a thread
  • int pthread_detach(pthread_t thread); - Indicates that storage for the thread can be reclaimed when the thread terminates.
• Terminating a thread
  • Returning from the start_routine
  • By the thread calling pthread_exit(), supplying an exit status.
  • By another thread terminating it with pthread_cancel()
  • Exiting (normally or with exit) from the main thread terminates all threads.
  • If the thread is detached its id, data areas, and exit status are cleaned up.
  • If the thread is not detached, then the thread's ID and the exit status specified by status are retained until the thread is joined.
• ThreadsDetached.c - Simple program that uses threads
• Waiting for non-detached thread termination
  • int pthread_join(thread_t tid, void **status); - Suspends execution of the calling thread until the target thread terminates unless the target thread has already terminated.
  • If status is not NULL, it points to a location that is set to the value passed to pthread_exit() by the terminating thread.
  • If successful the function will return zero.
  • Multiple threads cannot wait for the same thread to terminate. If they try to, one thread returns successfully and the others fail.
  • Quoting the man page ... "There is no pthreads analog of waitpid(-1,&status,0), that is, "join with any terminated thread". If you believe you need this functionality, you probably need to rethink your application design."
  • ThreadsJoin.c - Program that joins threads
• More basic thread functions
  • pthread_t pthread_self(void); - Returns the thread ID of the calling thread.
  • int pthread_equal(pthread_t t1, pthread_t t2); - Returns non-zero if the thread IDs t1 and t2 correspond to the same thread, otherwise it will return zero.
  • int pthread_cancel(pthread_t thread); - Requests that the thread be cancelled.
  • int sched_yield(void); - Forces the running process/thread to relinquish the processor.
  • int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param *param); - Sets the scheduling parameters of the thread. The scheduling policy for a thread can either be SCHED_FIFO (first in, first out) or SCHED_RR (round-robin). The thread priority (param->sched_priority) must be at least PTHREAD_MIN_PRIORITY and no more than PTHREAD_MAX_PRIORITY.
  • int pthread_getschedparam(pthread_t thread, int *policy,struct sched_param *param); - Gets the scheduling parameters of the thread.
• ThreadWars.c - Thread wars

CSC322 STOPS HERE

• A binary semaphore can be used to provide mutual exclusion during access to shared resources.
• ThreadsCS.c - Program that suffers from shared access problems
• int pthread_mutex_init(pthread_mutex_t * mutex, pthread_mutexattr_t *attr); - Initializes a mutex. Can also be done with
  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
• int pthread_mutex_lock(pthread_mutex_t *mutex); - Locks mutex. If mutex is already locked, the calling thread will block until mutex becomes available.
• int pthread_mutex_trylock(pthread_mutex_t *mutex); - Locks mutex. If mutex is already locked returns an error condition.
• int pthread_mutex_unlock(pthread_mutex_t *mutex); - Unlocks mutex.
• int pthread_mutex_destroy(pthread_mutex_t *mutex); - Frees the resources allocated for mutex.
• ThreadsCSMutex.c - Program that soves the shared access problems

• Mutexes waste CPU time because a mutex lock sits testing the mutex.
• ThreadsMutex.c - Program that uses mutexes
• Condition variables can be used to put a thread to sleep until another thread wakes it up.
• int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr); - Initializes a condition variable. Can also be done with
  pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
• int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex); - Atomically blocks the current thread waiting on cond, and unblocks mutex. The waiting thread unblocks only after another thread calls pthread_cond_signal, or pthread_cond_broadcast with the same condition variable. The thread now has to lock on mutex (possibly has to wait in a tight loop).
• int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime); - Like pthread_cond_wait, but unblocks after abstime if no thread signals.
• int pthread_cond_signal(pthread_cond_t *cond); - Unblocks one thread waiting for cond.
• int pthread_cond_broadcast(pthread_cond_t *cond); - Unblocks all threads waiting for cond.
• int pthread_cond_destroy(pthread_cond_t *cond); - Frees the resources allocated to cond.
• ThreadsCV.c - Program that uses condition variables
• General semaphores for threads are now easily implemented
• ThreadsSemaphores.c - Program that uses semaphores