Scribd
Upload
4 views

Critical section problem codes

The document presents two code examples demonstrating the critical section problem using pthreads and mutexes in C. Code 1 shows two threads incrementing a shared resource while ensuring mutual exclusion with a mutex, resulting in a final shared resource value of 2. Code 2 involves two threads incrementing the shared resource 100 times each, leading to a final value of 200, also protected by a mutex.

Uploaded by

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

Critical section problem codes

The document presents two code examples demonstrating the critical section problem using pthreads and mutexes in C. Code 1 shows two threads incrementing a shared resource while ensuring mutual exclusion with a mutex, resulting in a final shared resource value of 2. Code 2 involves two threads incrementing the shared resource 100 times each, leading to a final value of 200, also protected by a mutex.

Uploaded by

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

Critical section problem:

Code 1:

#include <stdio.h> // Include the standard input/output library for


printf function

#include <pthread.h> // Include the pthread library for using threads


and mutexes

pthread_mutex_t mutex; // Declare a mutex variable for synchronizing


access to shared resource

int shared_resource = 0; // Initialize a shared resource that will be


accessed by multiple threads

// Define the function to be executed by threads

void* thread_function(void* arg) {

// Lock the mutex before entering the critical section

pthread_mutex_lock(&mutex); // Lock the mutex to ensure exclusive


access to shared resource
// Print which thread is currently executing the critical section

printf("Thread %ld is in critical section.\n", arg);

shared_resource++; // Increment the shared resource

// Print the current value of the shared resource

printf("Shared resource value: %d\n", shared_resource);

// Unlock the mutex after leaving the critical section

pthread_mutex_unlock(&mutex); // Unlock the mutex to allow other


threads to access the shared resource

return NULL; // Return NULL as this thread function does not need to
return a value

//main function (entry point of the program)

int main() {

pthread_t threads[2]; // Declare an array to hold thread identifiers

pthread_mutex_init(&mutex, NULL); // Initialize the mutex

// Create two threads, passing their index as the argument to


thread_function

for (long i = 0; i < 2; i++) {

pthread_create(&threads[i], NULL, thread_function, (void*)i);

// Wait for both threads to complete execution

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

pthread_join(threads[i], NULL);
}.

pthread_mutex_destroy(&mutex); // Destroy the mutex to clean up


resources

return 0; // Return 0 to indicate successful completion of the program

Output:

Thread 0 is in critical section.

Shared resource value: 1

Thread 1 is in critical section.

Shared resource value: 2

Or

Thread 1 is in critical section.

Shared resource value: 1

Thread 0 is in critical section.

Shared resource value: 2

Code 2:

#include <stdio.h> // Include the standard I/O library for printf

#include <pthread.h> // Include the pthread library for thread


functions and mutexes
int shared_resource = 0; // Define a global variable that will be shared
among threads

pthread_mutex_t mutex; // Declare a mutex to protect access to the


shared resource

// Thread function that increments the shared_resource 100 times

void* thread_function(void* arg) {

// Lock the mutex before entering the critical section

for (int i = 0; i < 100; ++i) { // Loop 100 times

pthread_mutex_lock(&mutex); // Lock the mutex before


accessing shared_resource

shared_resource++; // Increment the shared_resourcep

// Unlock the mutex after exiting the critical section

pthread_mutex_unlock(&mutex); // Unlock the mutex after accessing


shared_resource

return NULL; // Return NULL when the thread function


completes

int main() {

pthread_t thread1, thread2; // Declare two thread identifiers

pthread_mutex_init(&mutex, NULL); // Initialize the mutex with


default attributes

pthread_create(&thread1, NULL, thread_function, NULL); // Create the


first thread to run thread_function

pthread_create(&thread2, NULL, thread_function, NULL); // Create the


second thread to run thread_function

pthread_join(thread1, NULL); // Wait for the first thread to finish

pthread_join(thread2, NULL); // Wait for the second thread to


finish
pthread_mutex_destroy(&mutex); // Destroy the mutex to clean
up resources

printf("Final value of shared_resource: %d\n", shared_resource); // Print


the final value of shared_resource

return 0; // Return 0 to indicate successful completion

Output:

Final value of shared_resource: 200

You might also like