Threads

Question 1

Describe a thread?

Answer 1

A thread is a sequence of instructions that are executed by a process. it is a lightweight program.

Each thread that belongs to a process space has a separate stack and registers but they all share the same vritual address space.

So they share the same code, data and and open files

Question 2

Why are multiple threads needed?

Answer 2

Because applications do more than one thing at a time.

Multithreading allows us to not have to program the interleaved execution ourselves

We do not have to wait for one task to complete (like IO operations) before doing another task

Question 3

What flag do you use to link the thread library to the user code.

Answer 3

Use the “-pthread” flag

Question 4

What is the data type of

• thread ID:
• thread attr:
• thread start routine:

Answer 4

• thread ID: pthread_t – unsigned long
• thread attr: pthread_attr_t
• thread start routine: void* (*start_routine) (void*)

Question 5

What is the prototype of pthread create, what does it return?

Answer 5

int pthread_create(

• pthread_t* restrict threadid,
• pthread_attr* restrict threadattr,
• void* ( *start_routine ) ( void* ),
• void* restrict arg

)

the restrict keyword is used to make sure that the pointers do not point to any of the same memory locations.

Success: returns 0

Failure: returns an error number

Question 6

In which 3 cases does a thread terminate?

Answer 6

A thread terminates on one of the 3 cases.

1. The start routine function ends
2. The thread calls the pthread_exit function
3. The program terminates ( main function terminates )

Question 7

What is the prototype for pthread_exit()

Answer 7

void pthread_exit(void* )

Question 8

What function is used to get the id of the current thread:

Answer 8

Use the pthread_self( ) function to get id of the current thread.

Question 9

What is a thread safe function

Answer 9

A thread safe function is a function that executes correctly even when it is executed simultaneously by multiple threads.

Question 10

What are re-entrant functions?

Answer 10

These are thread safe functions, they usually have _r at the end.

Question 11

Prototype of the pthread_join

Answer 11

void pthread_join(pthread_t threadid, void ** ptr)

threadid: id of the thread that is to be joined.
ptr: the pointer to where the return value of the thread is stored.

Question 12

What is thread cancellation and what is the function that can be used for this?

Answer 12

One thread can request the cancellation of another thread.

int pthread_cancel( pthread_t thread)

On success this returns 0 or otherwise it just returns an error value

Question 13

What are the 3 ways in which multithreaded programs can go wrong?

Answer 13

The three ways are:

• Race conditions
• Thread starvation
• Deadlock

Question 14

What are race conditions?

What are critical sections?

Answer 14

Simultaneuous access of 2 threads lead to data being stored to be inconsistent

Critical sections are those points in the code that can lead to data race conditions

Question 15

Give an example for race condition.

Answer 15

Incrementing of a variable int i = 1

i++;

First thread sees i = 1

Second thread sees i = 1 before the first thread can increment it and write it back

First thread increments i to 2 and writes it back to the memory location of i

Second thread also increments its copy of i ( which was 1 ) to 2 and writes it back

The final value of i is 2, when actually it should’ve been 3.

Question 16

What are mutexes and what do they ensure?

Answer 16

Mutexes are variables that can be locked on by threads.

They provide mutual exclusion or non interference between threads that execute the same code.

Question 17

How do you create a mutex?

Answer 17

You create mutex using the pthread_mutex_init function

int pthread_mutex_init( pthread_mutex_t* mutex, const pthread_mutexattr_t* attr );

Question 18

How do you create mutexes for global variables?

Answer 18

You use the static mutex initialazer

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER

Question 19

How do you destroy a mutex?

Why is it important to destroy a mutex once you are done using it?

Answer 19

You use the pthead_mutex_destroy function and this taken in the pointer to the mutex

pthread_mutex_destroy( pthread_mutex_t* mutex );

You must destroy a mutex because the pthread library does not clean up for you.

Question 20

When can the usage of mutexes lead to undefined behaviour

Answer 20

The usage of mutexes can lead to undefined behaviour when:

• trying to lock a mutex that has not been initialized
• trying to unlock a mutex that has not been locked
• trying lock a mutex twice
• trying to lock a mutex that has been locked by another thread

Question 21

What is trylock and what does it return?

Answer 21

Trylock is used when you want a thread to attempt to lock on a mutex but not wait wait on the mutex if it is unavailable.

It returns:

• 0, if it is successful
• EBUSY if it was unsuccessful
• EINVAL if the mutex is invalid

Question 22

What is deadlock?

Answer 22

Deadlock is when 2 threads that are executing are waiting on each other’s resources.

So if 2 threads A and B are executing and if A is waiting for B’s resources while B is waiting for A’s resources, then the neither of the threads can continue their execution and this condition is called a deadlock.

Question 23

What do you have to keep in mind when you’re working with multiple locks inorder to avoid deadlocks?

Answer 23

When you’re working with mutliple locks, you would need to make sure that you lock the mutexes in the same order in the different threads.

Question 24

Why is it advantageous to hold mutexes for as short as possible?

Answer 24

When you minimize the time the time that you spend holding onto mutexes, then

• there is less chance that there are mutex related mistakes, like relocking or forgetting to unlock
• it makes the code more parallel as more number of threads are allowed into the code block.

Question 25

Elaborate on semaphores.

Answer 25

Semaphores are threading objects designed to solve a variety of threading problems They have an internal state that is always greater than or equal to 0. There are 2 basic operations on semaphores - wait: Wait decrements the internal state of semaphore unless it's 0, then it waits for it to be incremented. - signal: incrementst the value.

Question 26

How do you make one thread wait on another thread without using mutexes?

Answer 26

Initialize a semaphore at 0, and make on thread wait on it. When the thread that is being waited upon has finished, it can just increment the value of the semaphore ( post ) and this notifies the other thread that it can begin the execution.

Question 27

What is interprocess communication and what are the different types?

Answer 27

IPC is when processes communicate by exchanging data between separate address spaces. * Message passing * Synchronization * Shared Memory

Question 28

What are FIFOs?

Answer 28

Fifos ( named pipes ) are just like pipes except they allow communication between unrelated processes.

Question 29

What function is used for creating a fifo and what is the protype of this function?

Answer 29

Using the function mkfifo to create a mutex programatically int mkfifo( char\* path, mode\_t mode ); path: this is the name of the fifo mode: this is the permissions that are given to the fifo.

Question 30

1. FIFOs can be opened for reading and writing. For the blocking versions. 1. Opening a fifo for reading will cause the fifo to block until the same fifo is opened for writing 2. Opening a fifo for writing will cause it to block until the fifo is opened for reading 2. If the fifo is opened in a non blocking using the flag 0\_NONBLOCK way then the fifo will fail only if it is opened for writing without being opened for reading. 3. Closing a named semaphore does not remove it from the system. It remains in the system until it is rebooted. 4. Name sems can be used for task ordering.

Question 31

Since there are multiple writers allowed for a FIFO then how is interleaving of writes prevented?

Answer 31

If there are multiple bytes then interleaving of bytes are ensured with the help of a constant called PIPE\_BUF This specifies the minimum number of bytes that will be written atomically. Any less than the specified number will not be interleaved.

Question 32

What are named semaphores?

Answer 32

Named semaphores are posix semaphores used to synchronize threads and processes.

Question 33

How do you open an existing semaphore ( function prot )? How do you open an existing semphore or creating one if it doesn't exist?

Answer 33

sem\_t\* sem\_open( const char\* name, int flags ); sem\_t sem\_open(const char\* name, int flags, mode\_t mode, int value); name: name of the new semaphore oflag: set to O\_CREAT for creating a new semaphore. mode: permissions for the new semaphore value: initial value for the new semaphore.

Question 34

How do you close a semaphore? How do you remove a semaphore from the system?

Answer 34

sem\_t\* sem\_close( sem\_t\* name ) you need to pass in the actual semaphore variable rather than just the name ( I think ) int sem\_unlink ( char\* name );

Question 35

Which is the fastest form of interprocess communication and why is this the fastest?

Answer 35

The fastest form of interprocess communication is shared memory because no data is actually coppied over.

Question 36

What happens in the shared memory ( type of IPC )? What should you watch out for?

Answer 36

In this type of IPC, the processes write to a shared memory region which is visible to all the processes. You need to make sure that access is synchronized to avoid data inconsistency

Question 37

What is Amdahl's law?

Answer 37

Amdahl's law says that a program has p parts which are parellelisable and ( 1 - p ) non-parellisable parts.