Scribd
Upload
7 views4 pages

Process Synchronization OS

Uploaded by

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

Process Synchronization OS

Uploaded by

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

1.

Critical Semaphores

#include<pthread.h>
#include<stdio.h>
#include<semaphore.h>
#include<unistd.h>
void *fun1();
void *fun2();

int shared=1;
sem_t s;
int main()
{
sem_init(&s,0,1);
pthread_t thread1,thread2;
pthread_create(&thread1,NULL,fun1,NULL);
pthread_create(&thread2,NULL,fun2,NULL);
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
printf("Final value of shared is %d\n",shared);
}

void *fun1(){
int x;
sem_wait(&s);
x = shared;
printf("Thread1 reads the value as %d\n",x);
x++;
printf("Local updation of shared varaible is %d\n",x);
sleep(1);
shared = x;
printf("Value of shared variable updated by Thread1 is : %d\n",shared);
sem_post(&s);
}

void *fun2(){
int y;
sem_wait(&s);
y = shared;
printf("Thread2 reads the value as %d\n",y);
y--;
printf("Local updation by Thread2 is %d\n",y);
sleep(1);
shared = y;
printf("Value of shared variable updated by Thread2 is : %d\n",shared);
sem_post(&s);
}

2. B/W Multiple Threads The threads try to acquire a resource that has 2 instances
using semaphores.

#include <stdio.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>

sem_t s;

void *fun(void *);


int main()
{
sem_init(&s, 0, 2);
int num;

printf("Enter the number of threads : ");


scanf("%d", &num);

pthread_t thread[num];
int thread_args[num];

for(int i = 0; i < num; i++) {


thread_args[i] = i;
pthread_create(&thread[i], NULL, fun, &thread_args[i]);
}

for(int j = 0; j < num; j++) {


pthread_join(thread[j], NULL);
}

sem_destroy(&s);
return 0;
}

void *fun(void *x)


{
int n = *(int *)x;
sem_wait(&s);
printf("Thread[%d] acquired the resource\n", n);
sleep(1);
sem_post(&s);
printf("Thread[%d] released the resource\n", n);
pthread_exit(NULL);
}

3. Dead Lock

#include<stdio.h>
#include<pthread.h>
#include<unistd.h>
void *fun1();
void *fun2();
pthread_mutex_t first_mutex;
pthread_mutex_t second_mutex;

int main(){
pthread_mutex_init(&first_mutex,NULL); // initialize the lock
pthread_mutex_init(&second_mutex,NULL);
pthread_t one , two;
pthread_create(&one,NULL,fun1,NULL); //create thread
pthread_create(&two,NULL, fun2,NULL);
pthread_join(one,NULL);
pthread_join(two,NULL);
printf("Thread joined\n");
}

void *fun1(){
pthread_mutex_lock(&first_mutex);
printf("Thread ONE acquired first mutex\n");
sleep(1);
pthread_mutex_lock(&second_mutex);
printf("Thread ONE acquired second mutex\n");
pthread_mutex_unlock(&second_mutex);
printf("Thread ONE released second mutex\n");
pthread_mutex_unlock(&first_mutex);
printf("Thread ONE released first mutex\n");
}

void *fun2(){
pthread_mutex_lock(&second_mutex);
printf("Thread TWO acquired second mutex\n");
sleep(1);
pthread_mutex_lock(&first_mutex);
printf("Thread TWO acquired first mutex\n");
pthread_mutex_unlock(&first_mutex);
printf("Thread TWO released first mutex\n");
pthread_mutex_unlock(&second_mutex);
printf("Thread TWO released second mutex\n");
}

4. Dining Philosopher's Problem

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<semaphore.h>
sem_t chopstick[5];
void * philos(void *);
void eat(int);

int main(){
int i , n[5];
pthread_t T[5];
for(i =0;i<5;i++){
n[i] = i;
sem_init(&chopstick[i],0,1);
pthread_create(&T[i],NULL,philos,(void *)&n[i]);
}
for(i =0;i<5;i++){
pthread_join(T[i],NULL);
}
}

void * philos(void * n){


int ph = *(int *)n;
printf("Philosopher %d wants to eat\n",ph);
printf("Philosopher %d tries to pick left chopstick\n",ph);
sem_wait(&chopstick[ph]);
printf("Philosopher %d picks the left chopstick\n",ph);
printf("Philosopher %d tries to pick the right chopstick\n",ph);
sem_wait(&chopstick[(ph+1)%5]);
printf("Philosopher %d picks the right chopstick\n",ph);
eat(ph);
sleep(2);
printf("Philosopher %d has finished eating\n",ph);
sem_post(&chopstick[(ph+1)%5]);
printf("Philosopher %d leaves the right chopstick\n",ph);
sem_post(&chopstick[ph]);
printf("Philosopher %d leaves the left chopstick\n",ph);
}

void eat(int ph){


printf("Philosopher %d begins to eat\n",ph);
}

5. Student- Library application

#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<semaphore.h>
sem_t OS_copy[2];
void * philos(void *);
void eat(int);

int main(){
int i , n[3];
pthread_t T[3];
for(i =0;i<3;i++){
n[i] = i;
sem_init(&OS_copy[i],0,1);
pthread_create(&T[i],NULL,philos,(void *)&n[i]);
}
for(i =0;i<3;i++){
pthread_join(T[i],NULL);
}
}

void * philos(void * n){


int ph = *(int *)n;
printf("Student %d wants OS book\n",ph);
printf("Student %d tries to pick first Book\n",ph);
sem_wait(&OS_copy[ph]);
printf("Student %d picks the first Book\n",ph);
printf("Student %d tries to pick the second Book\n",ph);
sem_wait(&OS_copy[(ph+1)%3]);
printf("Student %d picks the second Book\n",ph);
eat(ph);
sleep(2);
printf("Student %d has finished reading\n",ph);
sem_post(&OS_copy[(ph+1)%3]);
printf("Student %d submits the second Book\n",ph);
sem_post(&OS_copy[ph]);
printf("Student %d submits the first Book\n",ph);
}

void eat(int ph){


printf("Student %d begins to read\n",ph);
}

You might also like