L11: POSIX Threads

Question 1

What are Threads?

Answer 1

• Lightweight Processes
• Only local variables in a function are specific to a thread
  
  • Each thread has it’s own stack
• Most other data is shared between threads
  
  • global variables
  • the heap

Question 2

Posix Threads:

• Standard
• Library

Answer 2

Standard:

pthreads

Library:

pthread.h

Question 3

Reasons to

use Threads

Answer 3

• Efficiency
• Ease of data sharing
• Leverages parallelism

Question 4

Common uses of

Parallelism

Answer 4

• Overlapping I/O
  
  • Can perform long I/O and CPU tasks at the same time
• Asynchronous Events
  
  • Wait for a response AND do something else at the same time
• Real-Time Scheduling
  
  • Quickly respond to important tasks
• Utilize Multiple Processors

Question 5

Threads

vs

Processes

Answer 5

• Threads use less system resources for the same task
• But, thread may require more user space, depending on the implementation
• Threads within the same process share everything but the stack and processor state
• • Many process-based mechanisms have thread based equivalents that can be used:
    
    • non-blocking I/O
    • Shared Memory (IPC)
    • signals
    • jmp() function
• Threads use an inherently simpler shared memory mechanism than processes
  
  • Interthread communication is far easier
  • Much easier to code for parallelism errors, such as race conditions

Question 6

What is

POSIX?

Answer 6

Portable Operating System Interface (added X for style)

• A family of standards specified by the IEEE Computer Society
• Helps maintain compatibility between operating systems
• Defines :
  
  • API
  • Command Line Shells
  • Utility Interfaces
• For software compatible with varients of Unix and other Operating Systems

Question 7

Problems

with

Threads

Answer 7

• Unpredictable functioning( non-determinism)
• Difficult to Debug
• Impossible to prove correct
• Almost impossible to test thoroughly
• Specific behavior not easily reproducible
• Simple conceptually, but added complexities for dealing with many pitfalls

Question 8

pthread Library:

Function for

Creating a Thread

Answer 8

pthread_create()

Full Declaration:

int pthread_create( p_thread_t *thread,

const pthread_attr_t attr,

void *(*func)(void *),

void *arg);

• Creates a new thread with the attributes specified in attr
  
  • attr can be NULL
• Starts executing func() and passes it arg
• Consider carefully what to pass as argument
• Return 0 if ok, nonzero if error

Question 9

pthread Libary:

Function to

Rejoin Threads

Answer 9

pthread_join()

Full Declaration:

int pthread_join( pthread_t thread,

void **value_ptr);

• Makes the calling thread wait for the specified thread to terminate
• value_ptr is assigned its return value, or assigned PTHREAD_CANCELLED

Question 10

Important Parts

of

Thread Synchronization

Answer 10

• pthread_join()
  
  • Similar to wait() for processes
• mutex variables
  
  • Similar to binary semaphores for processes
• Condition Variables
  
  • wait for an “event”
  • A variable is assigned a certain value, which is “signaled” by another thread

Question 11

pthread Library:

Important Structures

Answer 11

pthread_t

pthread_mutex_t

pthread_attr_t

Question 12

pthread Library:

Important Functions

Answer 12

• Thread related
  
  • pthread_create()
  • pthread_join()
• Mutex related
  
  • pthread_mutex_init()
  • pthread_mutex_lock( pthread_mutex_t *mutex)
  • pthread_mutex_trylock( pthread_mutex_t *mutex)
  • pthread_mutex_unlock( pthread_mutex_t *mutex)

Question 13

Threads and Process Management:

What does an “exec()” call from a thread

do to the threads in the

containing process?

Answer 13

All the threads will terminate.

A new thread is created for the

program to be executed.

Question 14

Posix Threads:

Topics (6)

Answer 14

• Background
• Threads vs Processes
• Thread Synchronization
• Mutex Variables
• Condition Variables
• Threads and Unix

Question 15

What if a thread

blocks

inside a library function?

Answer 15

The pthreads library includes many functions which

only block the thread, not the entire process.

The programmer can also turn off blocking in other function.

Question 16

Mutex Variables:

Overview

Answer 16

Mutual Exclusion Lock

• Allows threads to control access to shared data
• Only one thread can hold a mutex at a time
• The threads must agree to use the mutex to protect shared data
• Mutex variables are not managed by the OS
• This is very efficient because there are no system calls

Question 17

Threads and Process Management:

Guidlines

Answer 17

• Fork from a process with only one thread
• Fork before creating additional threads
• Fork only from the main(parent) thread
• Hold no locks during the fork()

Question 18

Threads and Library Functions:

How do threads

share the same library function

at the same time?

Answer 18

Any function that uses global variables, or statically declared variables, may have trouble with this.

Answer:

Thread Safe Libraries

• Libaries can be made thread-safe by adding mutexes around the library function’s global variables
• Not all library functions are thread-safe
• Many libraries have thread-safe alternatives
  
  • example: ctime vs ctime_r )

Question 19

Threads and Library Functions:

What if a thread

is terminated

while inside a library function?

Answer 19

For example, in the middle of changing data

The pthreads library includes

cancellation-safe functions

These clean up upon cancellation

Should be used when possible

Question 20

Basic Code:

Creating a thread

Answer 20

pthread_t thread1; //declare the thread

//Create the thread, passing a pointer to a function,

// and a pointer to a shared global variable

pthread_create( &thread1, NULL,

(void*) my_function,

(void*) &global_var1);

//After doing whatever, block until thread is finished

pthread_join( thread1, NULL);

Question 21

Threads and Process Management:

What does a fork() call

from a thread do to

other threads in the containing process?

Answer 21

Nothing.

The new child process contains only a single copy of the thread that called fork().

But what happens to mutexes? (follow up on this)

Question 22

Conditional Variables

Answer 22

• Synchronize threads by using events
  
  • e.g. a variable is assigned a certain value
• A thread waits for an event
  
  • The event is signaled by another thread
  • These are NOT Unix Signals
• The Signal causes the waiting thread(s) to wake up

Question 23

pthread Libary:

Mutex Functions:

Unlock

Answer 23

int pthread_mutex_unlock(

pthread_mutex_t *mutex);

Unlocks a mutex.

If any threads are waiting to lock this mutex,

one is woken up.

Question 24

Threads

and

Signals

Answer 24

• Each thread can have its own signal mask and signal actions
• Signals can be sent to:
  
  • a specific thread
  • the process that “holds” the thread(s)
• Synchronous signals get delivered to the thread that caused them
  
  • SEGV
  • SIGFPE

Question 25

Threads and UNIX:

-Background

Answer 25

• UNIX was originally designed to handle processes before shared memory multiprocessors were available
• A process can act as a “container” for one or more threads.
• All the threads share the same process’ memory address space

Question 26

pthread Library:

Mutex Functions:

Try Lock

Answer 26

int pthread_mutex_trylock(

pthread_mutex_t *mutex );

Lock an unlocked mutex,

but if locked, DO NOT BLOCK, and return EBUSY.

Question 27

pthread Library:

Mutex Functions:

Lock

Answer 27

int pthread_mutex_lock(

pthread_mutex_t *mutex);

Locks an unlocked mutex.

If mutex is already locked,

the thread waits until the mutex becomes unlocked.

Question 28

Diagram:

Splitting Tasks with

Processes

Answer 28

• Global Variables, etc are shared by default
• Each thread tries to “lock” r3_mutex before accessing r3.
• If already locked, the thread will wait(blocks) until unlocked
• Both threads have access to all global variables