TechCodeview

De acordo com a terminologia do sistema operacional, mutex e semáforos são recursos do kernel que fornecem serviços de sincronização, também chamados primitivas de sincronização . A sincronização de processos desempenha um papel importante na manutenção da consistência dos dados compartilhados. Ambas as soluções de software e hardware estão presentes para lidar com problemas de seções críticas. Mas soluções de hardware para problemas de seções críticas são bastante difíceis de implementar. Mutex e semáforo fornecem serviços de sincronização, mas não são a mesma coisa.

O que é mutex?

Mutex é um objeto de exclusão mútua que sincroniza o acesso a um recurso. Ele é criado com um nome exclusivo no início de um programa. O mecanismo de bloqueio mutex garante que apenas um thread possa adquirir o mutex e entrar na seção crítica. Este thread só libera o mutex quando sai da seção crítica.

É um tipo especial de semáforo binário usado para controlar o acesso ao recurso compartilhado. Inclui um mecanismo de herança de prioridade para evitar problemas estendidos de inversão de prioridade. Ele permite que as tarefas atuais de maior prioridade sejam mantidas no estado bloqueado pelo menor tempo possível. No entanto, a herança de prioridade não corrige a inversão de prioridade, mas apenas minimiza o seu efeito.

Exemplo

Isso é mostrado com a ajuda do exemplo a seguir,

 wait (mutex); ..... Critical Section ..... signal (mutex); 

Uso de Mutex

Um mutex proporciona exclusão mútua, seja produtor ou consumidor que pode ter a chave (mutex) e prosseguir com seu trabalho. Enquanto o produtor preencher o buffer, o usuário precisará esperar e vice-versa. No bloqueio Mutex, o tempo todo, apenas um único thread pode funcionar com todo o buffer.

Quando um programa é iniciado, ele solicita ao sistema que crie um objeto mutex para um determinado recurso. O sistema cria o objeto mutex com um nome ou ID exclusivo. Sempre que o thread do programa deseja utilizar o recurso, ele ocupa o bloqueio do objeto mutex, utiliza o recurso e após o uso libera o bloqueio do objeto mutex. Em seguida, o próximo processo pode adquirir o bloqueio no objeto mutex.

Enquanto isso, um processo adquiriu o bloqueio no objeto mutex e nenhum outro thread ou processo pode acessar esse recurso. Se o objeto mutex já estiver bloqueado, o processo que deseja adquirir o bloqueio no objeto mutex terá que esperar e será colocado na fila do sistema até que o objeto mutex seja desbloqueado.

Vantagens do Mutex

Aqui estão as seguintes vantagens do mutex, como:

• Mutex são apenas bloqueios simples obtidos antes de entrar em sua seção crítica e depois liberá-la.
• Como apenas um thread está em sua seção crítica a qualquer momento, não há condições de corrida e os dados sempre permanecem consistentes.

Desvantagens do Mutex

Mutex também tem algumas desvantagens, como:

• Se um thread obtiver um bloqueio e entrar em suspensão ou for preemptado, o outro thread poderá não avançar. Isto pode levar à fome.
• Não pode ser bloqueado ou desbloqueado a partir de um contexto diferente daquele que o adquiriu.
• Apenas um thread deve ser permitido na seção crítica por vez.
• A implementação normal pode levar a um estado de espera ocupado, o que desperdiça tempo de CPU.

O que é semáforo?

Semáforo é simplesmente uma variável não negativa e compartilhada entre threads. Um semáforo é um mecanismo de sinalização e outro thread pode sinalizar um thread que está aguardando um semáforo.

Um semáforo usa duas operações atômicas,

1. Espere: A operação de espera diminui o valor do seu argumento S se for positivo. Se S for negativo ou zero, nenhuma operação será executada.

 wait(S) { while (S<=0); s--; } < pre> <p> <strong>2. Signal for the process synchronization:</strong> The signal operation increments the value of its argument S.</p> <pre> signal(S) { S++; } </pre> <p>A semaphore either allows or reject access to the resource, depending on how it is set up.</p> <h3>Use of Semaphore</h3> <p>In the case of a single buffer, we can separate the 4 KB buffer into four buffers of 1 KB. Semaphore can be associated with these four buffers, allowing users and producers to work on different buffers simultaneously.</p> <h3>Types of Semaphore</h3> <p>Semaphore is distinguished by the operating system in two categories <strong>Counting semaphore</strong> and <strong>Binary semaphore</strong> .</p> <p> <strong>1. Counting Semaphore:</strong> The semaphore S value is initialized to the <strong>number of resources</strong> present in the system. Whenever a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and <strong>decrements</strong> the semaphore value by one. When it releases the resource, it performs <strong>the signal()</strong> operation on the semaphore and <strong>increments</strong> the semaphore value by one.</p> <p>When the semaphore count goes to 0, it means the processes occupy all resources. A process needs to use a resource when the semaphore count is 0. It executes the <strong>wait()</strong> operation and gets <strong>blocked</strong> until the semaphore value becomes greater than 0.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-3.webp" alt="Mutex vs Semaphore"> <p> <strong>2. Binary semaphore:</strong> The value of a semaphore ranges between <strong>0</strong> and <strong>1</strong> . It is similar to mutex lock, but mutex is a locking mechanism, whereas the semaphore is a signaling mechanism. In binary semaphore, if a process wants to access the resource, it performs <strong>the wait()</strong> operation on the semaphore and decrements the value of the semaphore from 1 to 0. When it releases the resource, it performs a <strong>signal</strong> <strong>()</strong> operation on the semaphore and increments its value to 1. Suppose the value of the semaphore is 0 and a process wants to access the resource. In that case, it performs <strong>wait()</strong> operation and block itself till the current process utilizing the resources releases the resource.</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-4.webp" alt="Mutex vs Semaphore"> <h3>Advantages of Semaphore</h3> <p>Here are the following advantages of semaphore, such as:</p> <ul> <li>It allows more than one thread to access the critical section.</li> <li>Semaphores are machine-independent.</li> <li>Semaphores are implemented in the machine-independent code of the microkernel.</li> <li>They do not allow multiple processes to enter the critical section.</li> <li>As there is busy and waiting in semaphore, there is never wastage of process time and resources.</li> <li>They are machine-independent, which should be run in the machine-independent code of the microkernel.</li> <li>They allow flexible management of resources.</li> </ul> <h3>Disadvantage of Semaphores</h3> <p>Semaphores also have some disadvantages, such as:</p> <ul> <li>One of the biggest limitations of a semaphore is priority inversion.</li> <li>The operating system has to keep track of all calls to wait and signal semaphore.</li> <li>Their use is never enforced, but it is by convention only.</li> <li>The Wait and Signal operations require to be executed in the correct order to avoid deadlocks in semaphore.</li> <li>Semaphore programming is a complex method, so there are chances of not achieving mutual exclusion.</li> <li>It is also not a practical method for large scale use as their use leads to loss of modularity.</li> <li>Semaphore is more prone to programmer error</li> <li>, and it may cause deadlock or violation of mutual exclusion due to programmer error.</li> </ul> <h3>Difference between Mutex and Semaphore</h3> <p>The basic difference between semaphore and mutex is that semaphore is a signalling mechanism, i.e. processes perform wait() and signal() operation to indicate whether they are acquiring or releasing the resource. In contrast, a mutex is a locking mechanism, and the process has to acquire the lock on a mutex object if it wants to acquire the resource. Here are some more differences between semaphore and mutex, such as:</p> <img src="//techcodeview.com/img/operating-system/67/mutex-vs-semaphore-5.webp" alt="Mutex vs Semaphore"> <br> <table class="table"> <tr> <th>Terms</th> <th>Mutex</th> <th>Semaphore</th> </tr> <tr> <td>Definition</td> <td>The mutex is a locking mechanism, as to acquire a resource, a process needs to lock the mutex object, and while releasing a resource process has to unlock the mutex object.</td> <td>Semaphore is a signalling mechanism as wait() and signal() operations performed on the semaphore variable indicate whether a process is acquiring or releasing the resource.</td> </tr> <tr> <td>Existence</td> <td>A mutex is an object.</td> <td>Semaphore is an integer variable.</td> </tr> <tr> <td>Function</td> <td>Mutex allows multiple program threads to access a single resource but not simultaneously.</td> <td>Semaphore allows multiple program threads to access a finite instance of resources.</td> </tr> <tr> <td>Ownership</td> <td>Mutex object lock is released only by the process that has acquired the lock on the mutex object.</td> <td>Semaphore value can be changed by any process acquiring or releasing the resource by performing wait() and signal() operation.</td> </tr> <tr> <td>Categorize</td> <td>Mutex is not categorized further.</td> <td>The semaphore can be categorized into counting semaphore and binary semaphore.</td> </tr> <tr> <td>Operation</td> <td>The mutex object is locked or unlocked by the process of requesting or releasing the resource.</td> <td>Semaphore value is modified using wait() and signal() operation apart from initialization.</td> </tr> <tr> <td>Resources Occupied</td> <td>If a mutex object is already locked, then the process desiring to acquire resource waits and get queued by the system till the resource is released and the mutex object gets unlocked.</td> <td>Suppose the process acquires all the resources, and no resource is free. In that case, the process desiring to acquire resource performs wait() operation on semaphore variable and blocks itself till the count of semaphore become greater than 0.</td> </tr> </table> <hr></=0);>

Um semáforo permite ou rejeita o acesso ao recurso, dependendo de como ele está configurado.

Uso de Semáforo

No caso de um buffer único, podemos separar o buffer de 4 KB em quatro buffers de 1 KB. O semáforo pode ser associado a esses quatro buffers, permitindo que usuários e produtores trabalhem em diferentes buffers simultaneamente.

Tipos de semáforo

O Semaphore é diferenciado pelo sistema operacional em duas categorias Contando semáforo e Semáforo binário .

1. Semáforo de contagem: O valor do semáforo S é inicializado para o número de recursos presente no sistema. Sempre que um processo deseja acessar o recurso, ele realiza a espera() operação no semáforo e diminuições o valor do semáforo em um. Ao liberar o recurso, ele executa o sinal() operação no semáforo e incrementos o valor do semáforo em um.

Quando a contagem do semáforo chega a 0, significa que os processos ocupam todos os recursos. Um processo precisa usar um recurso quando a contagem do semáforo é 0. Ele executa o espere() operação e obtém bloqueado até que o valor do semáforo se torne maior que 0.

2. Semáforo binário: O valor de um semáforo varia entre 0 e 1 . É semelhante ao bloqueio mutex, mas o mutex é um mecanismo de bloqueio, enquanto o semáforo é um mecanismo de sinalização. No semáforo binário, se um processo quiser acessar o recurso, ele executa a espera() operação no semáforo e decrementa o valor do semáforo de 1 para 0. Ao liberar o recurso, ele executa uma sinal () operação no semáforo e incrementa seu valor para 1. Suponha que o valor do semáforo seja 0 e um processo queira acessar o recurso. Nesse caso, ele realiza espere() operação e bloquear-se até que o processo atual que utiliza os recursos libere o recurso.

Vantagens do Semáforo

Aqui estão as seguintes vantagens do semáforo, como:

• Permite que mais de um thread acesse a seção crítica.
• Os semáforos são independentes de máquina.
• Os semáforos são implementados no código independente de máquina do microkernel.
• Eles não permitem que vários processos entrem na seção crítica.
• Como há ocupação e espera no semáforo, nunca há desperdício de tempo e recursos de processo.
• Eles são independentes de máquina, e devem ser executados no código independente de máquina do microkernel.
• Eles permitem um gerenciamento flexível de recursos.

Desvantagem dos Semáforos

Os semáforos também apresentam algumas desvantagens, como:

• Uma das maiores limitações de um semáforo é a inversão de prioridade.
• O sistema operacional deve acompanhar todas as chamadas de espera e sinalizar o semáforo.
• Seu uso nunca é obrigatório, mas é apenas por convenção.
• As operações Wait e Signal precisam ser executadas na ordem correta para evitar deadlocks no semáforo.
• A programação semáfora é um método complexo, portanto há chances de não se alcançar a exclusão mútua.
• Também não é um método prático para utilização em larga escala, uma vez que a sua utilização conduz à perda de modularidade.
• O semáforo é mais sujeito a erros do programador
• , e pode causar impasse ou violação de exclusão mútua devido a erro do programador.

Diferença entre Mutex e Semáforo

A diferença básica entre semáforo e mutex é que semáforo é um mecanismo de sinalização, ou seja, os processos realizam operações wait() e signal() para indicar se estão adquirindo ou liberando o recurso. Por outro lado, um mutex é um mecanismo de bloqueio e o processo precisa adquirir o bloqueio em um objeto mutex se quiser adquirir o recurso. Aqui estão mais algumas diferenças entre semáforo e mutex, como: