Scribd
Upload
10 views18 pages

Front Threads

The document provides an overview of threads in operating systems, explaining the differences between processes and threads, as well as the advantages and drawbacks of using threads. It details how to create and manage threads using the pthreads library in C, including functions for creating, joining, and synchronizing threads with mutexes and semaphores. Additionally, it includes sample code demonstrating thread creation and synchronization mechanisms.

Uploaded by

guptaniraj730
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
10 views18 pages

Front Threads

The document provides an overview of threads in operating systems, explaining the differences between processes and threads, as well as the advantages and drawbacks of using threads. It details how to create and manage threads using the pthreads library in C, including functions for creating, joining, and synchronizing threads with mutexes and semaphores. Additionally, it includes sample code demonstrating thread creation and synchronization mechanisms.

Uploaded by

guptaniraj730
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 18

Operating Systems

Threads
Process vs. Thread
• process:
• an address space with 1 or more threads
executing within that address space, and the
required system resources for those threads
• a program that is running
• thread:
• a sequence of control within a process
• shares the resources in that process
Advantages of Threads
• The overhead for creating a thread is
significantly less than that for creating a
process
• Multitasking, i.e., one process serves multiple
clients
• Switching between threads requires the OS to
do much less work than switching between
processes
Drawbacks of Threads
• Not as widely available as longer established
features
• Writing multithreaded programs require more
careful thought
• More difficult to debug than single threaded
programs
• For single processor machines, creating several
threads in a program may not necessarily produce
an increase in performance
main thread
• initial thread created when main() is invoked by
the process loader
• once in the main(), the application has the ability
to create daughter threads
• if the main thread returns, the process terminates
even if there are running threads in that process,
unless special precautions are taken
• to explicitly avoid terminating the entire process,
use pthread_exit()
Create thread
• int pthread_create( pthread_t *thread, pthread_attr_t
*attr, void *(*thread_function)(void *), void *arg );

• 1st arg – pointer to the identifier of the created thread


• 2nd arg – thread attributes. If null, then the thread is
created with default attributes
• 3rd arg – pointer to the function the thread will execute
• 4th arg – the argument of the executed function
• returns 0 for success
Waiting threads
• int pthread_join( pthread_t thread, void
**thread_return )
• main thread will wait for daughter thread thread to finish
• 1st arg – the thread to wait for
• 2nd arg – pointer to a pointer to the return value from the
thread
• returns 0 for success
• threads should always be joined; otherwise, a thread might
keep on running even when the main thread has already
terminated
Threads Programming Model
• pipeline model – threads are run one after
the other
• master-slave model – master (main) thread
doesn't do any work, it just waits for the
slave threads to finish working
• equal-worker model – all threads work
Sample Pthreads Program in C
• The program in C calls the pthread.h header file.
Pthreads related statements are preceded by the
pthread_ prefix (except for semaphores).
• How to compile:
 gcc hello.c –pthread –o hello
#include <stdio.h>

#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>

int main(int argc, char **argv){


pthread_t t1;
int thread_id = 1;

if ( (pthread_create(&t1, NULL, (void *)&worker, (void *)&thread_id)) != 0) {


printf("Error creating thread\n");
exit(1);
}

pthread_join(t1, NULL);

return 0;
}

void worker(void *a) {


int *cnt = (int *)a;

printf("This is thread %d\n", *cnt);


pthread_exit(0);
}
Thread Synchronization
Mechanisms
• Mutual exclusion (mutex):
• guard against multiple threads modifying the
same shared data simultaneously
• provides locking/unlocking critical code
sections where shared data is modified
• each thread waits for the mutex to be unlocked
(by the thread who locked it) before performing
the code section
Basic Mutex Functions
int pthread_mutex_init(pthread_mutex_t *mutex, const
pthread_mutexattr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

• a new data type named pthread_mutex_t is designated


for mutexes
• a mutex is like a key (to access the code section) that is
handed to only one thread at a time
• the attribute of a mutex can be controlled by using the
pthread_mutex_init() function
• the lock/unlock functions work in tandem
#include <pthread.h>
...
pthread_mutex_t my_mutex;
...
int main()
{
int tmp;
...
// initialize the mutex
tmp = pthread_mutex_init( &my_mutex, NULL );
...
// create threads
...
pthread_mutex_lock( &my_mutex );
do_something_private();
pthread_mutex_unlock( &my_mutex );
...
…
pthread_mutex_destroy(&my_mutex );
return 0;
}

• Whenever a thread reaches the lock/unlock block, it first determines if


the mutex is locked. If so, it waits until it is unlocked. Otherwise, it
takes the mutex, locks the succeeding code, then frees the mutex and
unlocks the code when it's done.
Semaphores
• Counting Semaphores:
• permit a limited number of threads to execute a
section of the code
• similar to mutexes
• should include the semaphore.h header file
• semaphore functions do not have pthread_
prefixes; instead, they have sem_ prefixes
Basic Semaphore Functions
• creating a semaphore:
int sem_init(sem_t *sem, int pshared, unsigned int value);
– initializes a semaphore object pointed to by sem
– pshared is a sharing option; a value of 0 means the
semaphore is local to the calling process
– gives an initial value value to the semaphore
• terminating a semaphore:
int sem_destroy(sem_t *sem);
– frees the resources allocated to the semaphore sem
– usually called after pthread_join()
– an error will occur if a semaphore is destroyed for
which a thread is waiting
Basic Semaphore Functions
• semaphore control:
int sem_post(sem_t *sem);
int sem_wait(sem_t *sem);

– sem_post atomically increases the value of a


semaphore by 1, i.e., when 2 threads call sem_post
simultaneously, the semaphore's value will also be
increased by 2 (there are 2 atoms calling)
– sem_wait atomically decreases the value of a
semaphore by 1; but always waits until the semaphore
has a non-zero value first
#include <pthread.h>
#include <semaphore.h>
...
void *thread_function( void *arg );
...
sem_t semaphore; // also a global variable just like mutexes
...
int main()
{
int tmp;
...
// initialize the semaphore
tmp = sem_init( &semaphore, 0, 0 );
...
// create threads
pthread_create( &thread[i], NULL, thread_function, NULL );
...
while ( still_has_something_to_do() )
{
sem_post( &semaphore );
...
}
...
pthread_join( thread[i], NULL );
sem_destroy( &semaphore );
return 0;
}
void *thread_function( void *arg )
{
sem_wait( &semaphore );
perform_task_when_sem_open();
...
pthread_exit( NULL );
}

• the main thread increments the semaphore's count value


in the while loop
• the threads wait until the semaphore's count value is
non-zero before performing
perform_task_when_sem_open() and further
• daughter thread activities stop only when pthread_join()
is called

You might also like