Search anything:

Semaphore in C

Binary Tree book by OpenGenus

Open-Source Internship opportunity by OpenGenus for programmers. Apply now.

Reading time: 15 minutes

Semaphore is a data handling technique which is very useful in process synchronization and multithreading. In this article, we will explore how we can use semaphore in C language.

We have the POSIX semaphore library in Linux systems. We will use this in our case.

The basic code of a semaphore cannot be typed directly into client code as it should be atomic and writing code directly would lead to a context switch which would lead to unexpected results.

The POSIX system in Linux presents its own built-in semaphore library. To use it, we have to :

  • Include semaphore.h header file
  • Compile the code by linking with -lpthread -lrt

To lock a semaphore, we can use the sem_wait function:

int sem_wait(sem_t *sem);

To release or signal a semaphore, we use the sem_post function:

int sem_post(sem_t *sem);

A semaphore is initialised by using sem_init (for processes or threads) or sem_open (for Interprocess communication).

sem_init(sem_t *sem, int pshared, unsigned int value);

sem : Specifies the semaphore to be initialized.
pshared : This argument specifies whether or not the newly initialized semaphore is shared between processes or between threads. A non-zero value means the semaphore is shared between processes and a value of zero means it is shared between threads.
value : Specifies the value to assign to the newly initialized semaphore.

To destroy a semaphore, we can use sem_destroy.

sem_destoy(sem_t *mutex);

To declare a semaphore, the data type is sem_t.

#include < stdio.h> 
#include < pthread.h> 
#include < semaphore.h> 
#include < unistd.h> 
sem_t mutex; 
void* thread(void* arg) 
    printf("\nEntered thread\n"); 
    //critical section 
    printf("\n Exit thread\n"); 
int main() 
    sem_init(&mutex, 0, 1); 
    pthread_t t1,t2; 
    return 0; 

Compilation should be done with gcc a.c -lpthread -lrt

Explanation of above code

2 threads are being created, one 2 seconds after the first one.
The first thread will sleep for 4 seconds after acquiring the lock.
Thus the second thread will not enter immediately after it is called, it will enter 4 – 2 = 2 secs after it is called.

So the output is:

Entered thread
Exit thread

Entered thread
Exit thread

If we would not have used semaphore, the output would have been as follows due to context switching:

Entered thread
Entered thread
Exit thread
Exit thread
OpenGenus Tech Review Team

OpenGenus Tech Review Team

The official account of OpenGenus's Technical Review Team. This team review all technical articles and incorporates peer feedback. The team consist of experts in the leading domains of Computing.

Read More

Improved & Reviewed by:

Semaphore in C
Share this