1. FCFS Scheduling

#include<stdio.h>
int main() {
    int n, i;
    int bt[10], wt[10], tat[10];
    float avg_wt = 0, avg_tat = 0;
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        printf("Enter Burst Time of P%d: ", i+1);
        scanf("%d", &bt[i]);
    }
    wt[0] = 0;
    for(i=1; i<n; i++) {
        wt[i] = wt[i-1] + bt[i-1];
    }
    for(i=0; i<n; i++) {
        tat[i] = wt[i] + bt[i];
        avg_wt += wt[i];
        avg_tat += tat[i];
        printf("P%d WT=%d TAT=%d\n", i+1, wt[i], tat[i]);
    }
    printf("Average Waiting Time = %.2f\n", avg_wt/n);
    printf("Average Turnaround Time = %.2f\n", avg_tat/n);
    return 0;
}

⸻

2. Shortest Job First (SJF)

#include<stdio.h>
int main() {
    int n, i, j;
    int bt[10], wt[10], tat[10], p[10], temp;
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        p[i] = i+1;
        printf("Enter Burst Time of P%d: ", i+1);
        scanf("%d", &bt[i]);
    }
    for(i=0; i<n-1; i++) {
        for(j=i+1; j<n; j++) {
            if(bt[i] > bt[j]) {
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    wt[0] = 0;
    for(i=1; i<n; i++) {
        wt[i] = wt[i-1] + bt[i-1];
    }
    for(i=0; i<n; i++) {
        tat[i] = wt[i] + bt[i];
        printf("P%d WT=%d TAT=%d\n", p[i], wt[i], tat[i]);
    }
    return 0;
}

⸻

3. Priority Scheduling (Non-Preemptive)

#include<stdio.h>
int main() {
    int n, i, j, temp;
    int bt[10], pr[10], wt[10], tat[10], p[10];
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        p[i] = i+1;
        printf("Enter Burst Time of P%d: ", i+1);
        scanf("%d", &bt[i]);
        printf("Enter Priority of P%d: ", i+1);
        scanf("%d", &pr[i]);
    }
    for(i=0; i<n-1; i++) {
        for(j=i+1; j<n; j++) {
            if(pr[i] > pr[j]) {
                temp = pr[i];
                pr[i] = pr[j];
                pr[j] = temp;
                temp = bt[i];
                bt[i] = bt[j];
                bt[j] = temp;
                temp = p[i];
                p[i] = p[j];
                p[j] = temp;
            }
        }
    }
    wt[0] = 0;
    for(i=1; i<n; i++) {
        wt[i] = wt[i-1] + bt[i-1];
    }
    for(i=0; i<n; i++) {
        tat[i] = wt[i] + bt[i];
        printf("P%d WT=%d TAT=%d\n", p[i], wt[i], tat[i]);
    }
    return 0;
}

⸻

4. Shortest Remaining Time First (SRTF)

#include<stdio.h>
int main() {
    int n, i, time = 0, remain, shortest;
    int bt[10], rt[10], wt[10], tat[10];
    float avgwt = 0, avgtat = 0;
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        printf("Enter Burst Time: ");
        scanf("%d", &bt[i]);
        rt[i] = bt[i];
    }
    remain = n;
    while(remain != 0) {
        shortest = -1;
        for(i=0; i<n; i++) {
            if(rt[i] > 0) {
                if(shortest == -1 || rt[i] < rt[shortest])
                    shortest = i;
            }
        }
        rt[shortest]--;
        printf("P%d ", shortest+1);
        if(rt[shortest] == 0) {
            remain--;
            tat[shortest] = time + 1;
            wt[shortest] = tat[shortest] - bt[shortest];
            avgwt += wt[shortest];
            avgtat += tat[shortest];
        }
        time++;
    }
    printf("\nAverage WT = %.2f", avgwt/n);
    printf("\nAverage TAT = %.2f", avgtat/n);
    return 0;
}

⸻

5. Round Robin Scheduling

#include<stdio.h>
int main() {
    int n, tq, i, remain, time = 0;
    int bt[10], rt[10], wt[10], tat[10];
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        printf("Enter Burst Time: ");
        scanf("%d", &bt[i]);
        rt[i] = bt[i];
    }
    printf("Enter Time Quantum: ");
    scanf("%d", &tq);
    remain = n;
    while(remain > 0) {
        for(i=0; i<n; i++) {
            if(rt[i] > 0) {
                if(rt[i] <= tq) {
                    time += rt[i];
                    rt[i] = 0;
                    remain--;
                    tat[i] = time;
                    wt[i] = tat[i] - bt[i];
                }
                else {
                    rt[i] -= tq;
                    time += tq;
                }
                printf("P%d ", i+1);
            }
        }
    }
    printf("\n");
    for(i=0; i<n; i++) {
        printf("P%d WT=%d TAT=%d\n", i+1, wt[i], tat[i]);
    }
    return 0;
}

⸻

6. First Fit Memory Allocation

#include<stdio.h>
int main() {
    int b[10], p[10], nb, np, i, j;
    printf("Enter number of blocks: ");
    scanf("%d", &nb);
    printf("Enter number of processes: ");
    scanf("%d", &np);
    for(i=0; i<nb; i++) {
        printf("Block %d: ", i+1);
        scanf("%d", &b[i]);
    }
    for(i=0; i<np; i++) {
        printf("Process %d: ", i+1);
        scanf("%d", &p[i]);
    }
    for(i=0; i<np; i++) {
        for(j=0; j<nb; j++) {
            if(b[j] >= p[i]) {
                printf("Process %d allocated to Block %d\n", i+1, j+1);
                b[j] -= p[i];
                break;
            }
        }
    }
    return 0;
}

⸻

7. Best Fit Memory Allocation

#include<stdio.h>
int main() {
    int b[10], p[10], nb, np, i, j, best;
    printf("Enter number of blocks: ");
    scanf("%d", &nb);
    printf("Enter number of processes: ");
    scanf("%d", &np);
    for(i=0; i<nb; i++)
        scanf("%d", &b[i]);
    for(i=0; i<np; i++)
        scanf("%d", &p[i]);
    for(i=0; i<np; i++) {
        best = -1;
        for(j=0; j<nb; j++) {
            if(b[j] >= p[i]) {
                if(best == -1 || b[j] < b[best])
                    best = j;
            }
        }
        if(best != -1) {
            printf("Process %d -> Block %d\n", i+1, best+1);
            b[best] -= p[i];
        }
    }
    return 0;
}

⸻

8. Worst Fit Memory Allocation

#include<stdio.h>
int main() {
    int b[10], p[10], nb, np, i, j, worst;
    printf("Enter number of blocks: ");
    scanf("%d", &nb);
    printf("Enter number of processes: ");
    scanf("%d", &np);
    for(i=0; i<nb; i++)
        scanf("%d", &b[i]);
    for(i=0; i<np; i++)
        scanf("%d", &p[i]);
    for(i=0; i<np; i++) {
        worst = -1;
        for(j=0; j<nb; j++) {
            if(b[j] >= p[i]) {
                if(worst == -1 || b[j] > b[worst])
                    worst = j;
            }
        }
        if(worst != -1) {
            printf("Process %d -> Block %d\n", i+1, worst+1);
            b[worst] -= p[i];
        }
    }
    printf("Remaining Blocks:\n");
    for(i=0; i<nb; i++) {
        printf("%d ", b[i]);
    }
    return 0;
}

⸻

9. FIFO Page Replacement

#include<stdio.h>
int main() {
    int pages[20], frame[10];
    int n, f, i, j, k = 0, faults = 0, found;
    printf("Enter number of pages: ");
    scanf("%d", &n);
    for(i=0; i<n; i++)
        scanf("%d", &pages[i]);
    printf("Enter number of frames: ");
    scanf("%d", &f);
    for(i=0; i<f; i++)
        frame[i] = -1;
    for(i=0; i<n; i++) {
        found = 0;
        for(j=0; j<f; j++) {
            if(frame[j] == pages[i]) {
                found = 1;
                break;
            }
        }
        if(!found) {
            frame[k] = pages[i];
            k = (k + 1) % f;
            faults++;
        }
        for(j=0; j<f; j++)
            printf("%d ", frame[j]);
        printf("\n");
    }
    printf("Page Faults = %d", faults);
    return 0;
}

⸻

10. LRU Page Replacement

#include<stdio.h>
int main() {
    int pages[20], frame[10], time[10];
    int n, f, i, j, pos, faults = 0, count = 0, found;
    printf("Enter number of pages: ");
    scanf("%d", &n);
    for(i=0; i<n; i++)
        scanf("%d", &pages[i]);
    printf("Enter number of frames: ");
    scanf("%d", &f);
    for(i=0; i<f; i++)
        frame[i] = -1;
    for(i=0; i<n; i++) {
        found = 0;
        for(j=0; j<f; j++) {
            if(frame[j] == pages[i]) {
                found = 1;
                count++;
                time[j] = count;
            }
        }
        if(!found) {
            pos = 0;
            for(j=1; j<f; j++) {
                if(time[j] < time[pos])
                    pos = j;
            }
            frame[pos] = pages[i];
            count++;
            time[pos] = count;
            faults++;
        }
        for(j=0; j<f; j++)
            printf("%d ", frame[j]);
        printf("\n");
    }
    printf("Page Faults = %d", faults);
    return 0;
}

⸻

11. Optimal Page Replacement

#include<stdio.h>
int main() {
    int pages[20], frame[10];
    int n, f, i, j, k, farthest, pos, faults = 0, found;
    printf("Enter number of pages: ");
    scanf("%d", &n);
    for(i=0; i<n; i++)
        scanf("%d", &pages[i]);
    printf("Enter number of frames: ");
    scanf("%d", &f);
    for(i=0; i<f; i++)
        frame[i] = -1;
    for(i=0; i<n; i++) {
        found = 0;
        for(j=0; j<f; j++) {
            if(frame[j] == pages[i]) {
                found = 1;
                break;
            }
        }
        if(!found) {
            pos = -1;
            farthest = i;
            for(j=0; j<f; j++) {
                for(k=i+1; k<n; k++) {
                    if(frame[j] == pages[k]) {
                        if(k > farthest) {
                            farthest = k;
                            pos = j;
                        }
                        break;
                    }
                }
                if(k == n) {
                    pos = j;
                    break;
                }
            }
            if(pos == -1)
                pos = 0;
            frame[pos] = pages[i];
            faults++;
        }
        for(j=0; j<f; j++)
            printf("%d ", frame[j]);
        printf("\n");
    }
    printf("Page Faults = %d", faults);
    return 0;
}

12. Paging Simulation

#include<stdio.h>
int main() {
    int pageTable[10], logical, physical;
    int pageSize, pageNo, offset, frameNo;
    printf("Enter page size: ");
    scanf("%d", &pageSize);
    printf("Enter page table mapping:\n");
    for(int i=0; i<5; i++) {
        printf("Page %d -> Frame: ", i);
        scanf("%d", &pageTable[i]);
    }
    printf("Enter logical address: ");
    scanf("%d", &logical);
    pageNo = logical / pageSize;
    offset = logical % pageSize;
    frameNo = pageTable[pageNo];
    physical = frameNo * pageSize + offset;
    printf("Page Number = %d\n", pageNo);
    printf("Offset = %d\n", offset);
    printf("Physical Address = %d\n", physical);
    return 0;
}

⸻

13. Segmentation Simulation

#include<stdio.h>
int main() {
    int base[10], limit[10];
    int seg, offset, physical;
    printf("Enter Base and Limit of 3 segments:\n");
    for(int i=0; i<3; i++) {
        printf("Segment %d Base: ", i);
        scanf("%d", &base[i]);
        printf("Segment %d Limit: ", i);
        scanf("%d", &limit[i]);
    }
    printf("Enter Segment Number: ");
    scanf("%d", &seg);
    printf("Enter Offset: ");
    scanf("%d", &offset);
    if(offset < limit[seg]) {
        physical = base[seg] + offset;
        printf("Physical Address = %d\n", physical);
    }
    else {
        printf("Invalid Offset\n");
    }
    return 0;
}

⸻

14. Segmentation with Paging

#include<stdio.h>
int main() {
    int segTable[5], pageTable[5][5];
    int seg, page, offset;
    int frame, physical, pageSize;
    printf("Enter page size: ");
    scanf("%d", &pageSize);
    printf("Enter segment table:\n");
    for(int i=0; i<3; i++) {
        printf("Segment %d pages: ", i);
        scanf("%d", &segTable[i]);
    }
    printf("Enter page table:\n");
    for(int i=0; i<3; i++) {
        for(int j=0; j<segTable[i]; j++) {
            printf("Segment %d Page %d -> Frame: ", i, j);
            scanf("%d", &pageTable[i][j]);
        }
    }
    printf("Enter Segment Number: ");
    scanf("%d", &seg);
    printf("Enter Page Number: ");
    scanf("%d", &page);
    printf("Enter Offset: ");
    scanf("%d", &offset);
    frame = pageTable[seg][page];
    physical = frame * pageSize + offset;
    printf("Physical Address = %d\n", physical);
    return 0;
}

⸻

15. Producer Consumer Problem

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
sem_t empty, full, mutex;
int buffer = 0;
void *producer(void *arg) {
    for(int i=1; i<=5; i++) {
        sem_wait(&empty);
        sem_wait(&mutex);
        buffer = i;
        printf("Produced: %d\n", buffer);
        sem_post(&mutex);
        sem_post(&full);
        sleep(1);
    }
}
void *consumer(void *arg) {
    for(int i=1; i<=5; i++) {
        sem_wait(&full);
        sem_wait(&mutex);
        printf("Consumed: %d\n", buffer);
        sem_post(&mutex);
        sem_post(&empty);
        sleep(1);
    }
}
int main() {
    pthread_t p, c;
    sem_init(&empty, 0, 1);
    sem_init(&full, 0, 0);
    sem_init(&mutex, 0, 1);
    pthread_create(&p, NULL, producer, NULL);
    pthread_create(&c, NULL, consumer, NULL);
    pthread_join(p, NULL);
    pthread_join(c, NULL);
    return 0;
}

⸻

16. Multilevel Queue Scheduling

#include<stdio.h>
int main() {
    int n, i;
    int bt[10], wt[10], tat[10];
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(i=0; i<n; i++) {
        printf("Enter Burst Time of P%d: ", i+1);
        scanf("%d", &bt[i]);
    }
    wt[0] = 0;
    for(i=1; i<n; i++) {
        wt[i] = wt[i-1] + bt[i-1];
    }
    printf("\nSystem Queue:\n");
    for(i=0; i<n/2; i++) {
        tat[i] = wt[i] + bt[i];
        printf("P%d WT=%d TAT=%d\n", i+1, wt[i], tat[i]);
    }
    printf("\nUser Queue:\n");
    for(i=n/2; i<n; i++) {
        tat[i] = wt[i] + bt[i];
        printf("P%d WT=%d TAT=%d\n", i+1, wt[i], tat[i]);
    }
    return 0;
}

⸻

17. FCFS Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    int req[n];
    for(int i=0; i<n; i++)
        scanf("%d", &req[i]);
    printf("Enter initial head position: ");
    scanf("%d", &head);
    for(int i=0; i<n; i++) {
        total += abs(req[i] - head);
        head = req[i];
    }
    printf("Total Seek Time = %d", total);
    return 0;
}

⸻

18. SSTF Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    int req[n], visited[n];
    for(int i=0; i<n; i++) {
        scanf("%d", &req[i]);
        visited[i] = 0;
    }
    printf("Enter head position: ");
    scanf("%d", &head);
    printf("Order: ");
    for(int i=0; i<n; i++) {
        int min = 9999, pos = -1;
        for(int j=0; j<n; j++) {
            if(!visited[j] && abs(req[j]-head) < min) {
                min = abs(req[j]-head);
                pos = j;
            }
        }
        visited[pos] = 1;
        total += min;
        head = req[pos];
        printf("%d ", head);
    }
    printf("\nTotal Seek Time = %d", total);
    return 0;
}

⸻

19. Multilevel Feedback Queue Scheduling

#include<stdio.h>
int main() {
    int n, bt[10], rt[10];
    int tq = 2, time = 0;
    printf("Enter number of processes: ");
    scanf("%d", &n);
    for(int i=0; i<n; i++) {
        printf("Burst Time of P%d: ", i+1);
        scanf("%d", &bt[i]);
        rt[i] = bt[i];
    }
    printf("Queue Execution:\n");
    for(int i=0; i<n; i++) {
        if(rt[i] > tq) {
            printf("P%d moved to Queue 2\n", i+1);
            rt[i] -= tq;
            time += tq;
        }
        else {
            time += rt[i];
            rt[i] = 0;
            printf("P%d completed\n", i+1);
        }
    }
    printf("Total Time = %d\n", time);
    return 0;
}

⸻

20. SCAN Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int req[20], n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%d", &req[i]);
    printf("Enter head position: ");
    scanf("%d", &head);
    printf("Head Movement:\n");
    for(int i=0; i<n; i++) {
        total += abs(req[i] - head);
        head = req[i];
        printf("%d ", head);
    }
    printf("\nTotal Seek Time = %d", total);
    return 0;
}

⸻

21. LOOK Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int req[20], n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%d", &req[i]);
    printf("Enter head position: ");
    scanf("%d", &head);
    printf("Order:\n");
    for(int i=0; i<n; i++) {
        total += abs(req[i] - head);
        head = req[i];
        printf("%d ", head);
    }
    printf("\nTotal Head Movement = %d", total);
    return 0;
}
22. C-SCAN Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int req[20], n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%d", &req[i]);
    printf("Enter initial head position: ");
    scanf("%d", &head);
    printf("Head Movement Order:\n");
    for(int i=0; i<n; i++) {
        total += abs(req[i] - head);
        head = req[i];
        printf("%d ", head);
    }
    printf("\nTotal Seek Operations = %d", total);
    return 0;
}

⸻

23. C-LOOK Disk Scheduling

#include<stdio.h>
#include<stdlib.h>
int main() {
    int req[20], n, head, total = 0;
    printf("Enter number of requests: ");
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%d", &req[i]);
    printf("Enter head position: ");
    scanf("%d", &head);
    printf("Execution Order:\n");
    for(int i=0; i<n; i++) {
        total += abs(req[i] - head);
        head = req[i];
        printf("%d ", head);
    }
    printf("\nTotal Seek Time = %d", total);
    return 0;
}

⸻

24. Wait-For Graph Deadlock Detection

#include<stdio.h>
int main() {
    int n, graph[10][10];
    printf("Enter number of processes: ");
    scanf("%d", &n);
    printf("Enter Wait-For Graph Matrix:\n");
    for(int i=0; i<n; i++) {
        for(int j=0; j<n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    int deadlock = 0;
    for(int i=0; i<n; i++) {
        if(graph[i][i] == 1)
            deadlock = 1;
    }
    if(deadlock)
        printf("Deadlock Exists\n");
    else
        printf("No Deadlock\n");
    return 0;
}

⸻

25. Banker’s Algorithm

#include<stdio.h>
int main() {
    int n, m;
    int alloc[10][10], max[10][10], need[10][10];
    int avail[10], finish[10] = {0}, safe[10];
    printf("Enter number of processes: ");
    scanf("%d", &n);
    printf("Enter number of resources: ");
    scanf("%d", &m);
    printf("Enter Allocation Matrix:\n");
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
            scanf("%d", &alloc[i][j]);
    printf("Enter Max Matrix:\n");
    for(int i=0; i<n; i++)
        for(int j=0; j<m; j++)
            scanf("%d", &max[i][j]);
    printf("Enter Available Resources:\n");
    for(int i=0; i<m; i++)
        scanf("%d", &avail[i]);
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            need[i][j] = max[i][j] - alloc[i][j];
        }
    }
    int count = 0;
    while(count < n) {
        for(int i=0; i<n; i++) {
            if(finish[i] == 0) {
                int flag = 1;
                for(int j=0; j<m; j++) {
                    if(need[i][j] > avail[j]) {
                        flag = 0;
                        break;
                    }
                }
                if(flag) {
                    safe[count++] = i;
                    for(int j=0; j<m; j++) {
                        avail[j] += alloc[i][j];
                    }
                    finish[i] = 1;
                }
            }
        }
    }
    printf("Safe Sequence:\n");
    for(int i=0; i<n; i++) {
        printf("P%d ", safe[i]);
    }
    return 0;
}

⸻

26. Dining Philosophers Problem

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
sem_t chopstick[5];
void *philosopher(void *num) {
    int id = *(int *)num;
    printf("Philosopher %d is Thinking\n", id);
    sem_wait(&chopstick[id]);
    sem_wait(&chopstick[(id+1)%5]);
    printf("Philosopher %d is Eating\n", id);
    sleep(1);
    sem_post(&chopstick[id]);
    sem_post(&chopstick[(id+1)%5]);
    printf("Philosopher %d Finished Eating\n", id);
}
int main() {
    pthread_t p[5];
    int id[5];
    for(int i=0; i<5; i++)
        sem_init(&chopstick[i], 0, 1);
    for(int i=0; i<5; i++) {
        id[i] = i;
        pthread_create(&p[i], NULL, philosopher, &id[i]);
    }
    for(int i=0; i<5; i++)
        pthread_join(p[i], NULL);
    return 0;
}

⸻

27. Reader Writer Problem

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
sem_t mutex, wrt;
int readcount = 0;
void *reader(void *arg) {
    sem_wait(&mutex);
    readcount++;
    if(readcount == 1)
        sem_wait(&wrt);
    sem_post(&mutex);
    printf("Reader is Reading\n");
    sem_wait(&mutex);
    readcount--;
    if(readcount == 0)
        sem_post(&wrt);
    sem_post(&mutex);
}
void *writer(void *arg) {
    sem_wait(&wrt);
    printf("Writer is Writing\n");
    sem_post(&wrt);
}
int main() {
    pthread_t r1, r2, w1;
    sem_init(&mutex, 0, 1);
    sem_init(&wrt, 0, 1);
    pthread_create(&r1, NULL, reader, NULL);
    pthread_create(&r2, NULL, reader, NULL);
    pthread_create(&w1, NULL, writer, NULL);
    pthread_join(r1, NULL);
    pthread_join(r2, NULL);
    pthread_join(w1, NULL);
    return 0;
}

⸻

28. Sleeping Barber Problem

#include<stdio.h>
#include<pthread.h>
#include<semaphore.h>
#include<unistd.h>
sem_t customers, barber, mutex;
int waiting = 0;
void *barberFunc(void *arg) {
    while(1) {
        sem_wait(&customers);
        sem_wait(&mutex);
        waiting--;
        sem_post(&barber);
        sem_post(&mutex);
        printf("Barber is Cutting Hair\n");
        sleep(2);
    }
}
void *customerFunc(void *arg) {
    sem_wait(&mutex);
    if(waiting < 3) {
        waiting++;
        printf("Customer Waiting\n");
        sem_post(&customers);
        sem_post(&mutex);
        sem_wait(&barber);
        printf("Customer Getting Haircut\n");
    }
    else {
        sem_post(&mutex);
        printf("Customer Left Shop\n");
    }
}
int main() {
    pthread_t b, c1, c2, c3;
    sem_init(&customers, 0, 0);
    sem_init(&barber, 0, 0);
    sem_init(&mutex, 0, 1);
    pthread_create(&b, NULL, barberFunc, NULL);
    pthread_create(&c1, NULL, customerFunc, NULL);
    pthread_create(&c2, NULL, customerFunc, NULL);
    pthread_create(&c3, NULL, customerFunc, NULL);
    pthread_join(c1, NULL);
    pthread_join(c2, NULL);
    pthread_join(c3, NULL);
    return 0;
}

⸻

29. Peterson’s Solution Algorithm

#include<stdio.h>
#include<pthread.h>
int flag[2] = {0,0};
int turn;
int counter = 0;
void *process0(void *arg) {
    for(int i=0; i<5; i++) {
        flag[0] = 1;
        turn = 1;
        while(flag[1] && turn == 1);
        counter++;
        printf("Process 0 Counter = %d\n", counter);
        flag[0] = 0;
    }
}
void *process1(void *arg) {
    for(int i=0; i<5; i++) {
        flag[1] = 1;
        turn = 0;
        while(flag[0] && turn == 0);
        counter++;
        printf("Process 1 Counter = %d\n", counter);
        flag[1] = 0;
    }
}
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, process0, NULL);
    pthread_create(&t2, NULL, process1, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}

⸻

30. Dekker’s Solution Algorithm

#include<stdio.h>
#include<pthread.h>
int flag[2] = {0,0};
int turn = 0;
int counter = 0;
void *process0(void *arg) {
    for(int i=0; i<5; i++) {
        flag[0] = 1;
        while(flag[1]) {
            if(turn == 1) {
                flag[0] = 0;
                while(turn == 1);
                flag[0] = 1;
            }
        }
        counter++;
        printf("Process 0 Counter = %d\n", counter);
        turn = 1;
        flag[0] = 0;
    }
}
void *process1(void *arg) {
    for(int i=0; i<5; i++) {
        flag[1] = 1;
        while(flag[0]) {
            if(turn == 0) {
                flag[1] = 0;
                while(turn == 0);
                flag[1] = 1;
            }
        }
        counter++;
        printf("Process 1 Counter = %d\n", counter);
        turn = 0;
        flag[1] = 0;
    }
}
int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, process0, NULL);
    pthread_create(&t2, NULL, process1, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    return 0;
}