POSIX refers to the Portable Interface of the OS, which is an IEEE standard, developed to assist portability of different applications. POSIX is an effort to build a common standardized version of UNIX through a collaboration of vendors. It would make porting apps among hardware platforms easier if they are effective. Hewlett-Packard is integrating POSIX into its licensed MPE/iX OS version 5.0 and HP/UXX version 10.0, respectively (its UNIX).
The POSIX standard has much more than ten parts, however, two are easily obtainable. POSIX.1 describes C programming interfaces (i.e., a system call library) for files, procedures, and I/O terminals. The C POSIX package library for POSIX platforms is a framework of the C standard library. This is established at the very same time as standard ANSI C. To make POSIX compliant with standard C, several attempts have been made. POSIX provides additional features to those implemented in standard C.
POSIX Semaphores
A semaphore is a data structure often used for synchronizing the processes and assisting threads without their interaction with one another to operate together. The interface for semaphores is specified by the POSIX standard. It is not part of Pthreads. However, most UNIXes that support Pthreads even provide semaphores. In Unix-like frameworks, like Linux, semaphores are merged with message queues and common memory underneath the Interprocess Communication (IPC) services. The older framework V semaphores and the modern POSIX semaphores become two types of semaphores. POSIX Semaphore calling is so much easier than System V Semaphore calls. Although, System V semaphores are easier to obtain, especially on earlier Unix-like platforms. There is a need to connect programs using POSIX semaphores to the Pthread library. We’ll take a look at the POSIX semaphores in this article.
Why POSIX Semaphores?
There is a big issue around threads, which is “race condition”. It is a circumstance in which two threads seek to obtain and alter the same information, thereby making it conflicting. To avoid a race condition, we have been using semaphores for a very long time.
Semaphores are available in 2 kinds:
Binary Semaphore:
It is also recognized as a mutex lock. It would only have two possible values, 0 and 1. The value will be initialized as 1. It’s being used to enforce numerous processes to solve the serious section issue.
Counting Semaphore:
Its size can vary across an unrestricted domain. It’s being used to have authority over access to numerous-instance resources.
The Linux POSIX framework has its integrated Semaphore repository. To use it, we must:
- Add semaphore.h
- Pile up the code by connecting with -lpthread -lrt.
Almost all POSIX Semaphore methods and forms are prototyped or specified in ‘Semaphore.h’. We will be using the Semaphore to describe an entity or object as:
Here are different functions we would be using in POSIX Semaphore.
Sem_init
To initialize a semaphore, you have to use the sem_init method. In this function, sem corresponds to an initialized semaphore object. Pshared is a banner or flag that specifies whether the semaphore can be shared with a forked() procedure or not. Shared semaphores are not presently braced by LinuxThreads. The argument value is the starting value at which the semaphore is fixed to.
Sem_wait
We will be using the sem-wait method to hold/lock a semaphore or make it wait. If the semaphore has been provided with a negative value, then the call cycle will be automatically blocked. Whenever any other thread calls sem_post, one of the already clogged processes awakes.
Sem_post
We will be using the sem_post method to increase the value of a semaphore. Upon calling, sem_post will increment the value, and one of the already clogged or waiting processes awakes.
Sem_getvalue
If you want to know about the value of a semaphore, you have to use the below sem_getvalue function. It will obtain the present value of the semaphore and be placed in the valp-pointed destination.
Sem_destroy
You should be using the sem_destroy method if you want to destroy the semaphore. If the demise of the semaphore is to proceed, no thread will be waiting in the semaphore.
Install the GCC Utility
To compile the POSIX Semaphore C code, you must have the gcc utility installed in your Linux system. For this purpose, open your command terminal and try the below command.
Affirm your action by hitting Y.
Implementation of POSIX Semaphore with C programming in Ubuntu
At the very start, you have to create a new file with a .cpp extension on Ubuntu 20.04 system. For this, you have to navigate towards your Home Directory and create a new empty file named new.cpp. You can also create it using the touch command in your command terminal.
You can see that the new.cpp file has been created in the Home Directory.
After the creation of the .cpp file, open it as a Text Editor in your Linux system and write the below code in this file as it is. After that, save and close it.
Execute the POSIX Semaphore C Program In Ubuntu 20.04
Open your terminal In Ubuntu 20.04 and execute the below gcc command followed by the filename.
There are 2 threads formed, one is formed after 2 seconds of the other. After receiving the bolt, the very first thread sleeps for 4 seconds. So, after it has been called, the second thread wouldn’t join directly, and this will appear 4-2=2 seconds after it has been called. Here is the output:
If we had not used semaphore, according to context switching, the result might have been as observes:
Conclusion
In this guide, a detailed overview of the use of POSIXSemaphore with C programming in Ubuntu 20 has been given. By merely using the POSIX or Pthread library throughout certain C code, the POSIX Semaphore can be quite easily used to prevent race conditions during coding.
