C sem_init Uso da função

A função sem_init () funciona para inicializar um semáforo sem nome. Agora aqui surge a pergunta: o que é um semáforo? Semáfore é um conceito que lida com um processo ou sincronização de threads. Um semáforo é uma estrutura de dados usada para sincronizar o processo e ajudar os threads sem interagir com os outros threads para continuar sua operação juntos. O tipo de semáforo que o Linux suporta é o semáforo Posix. O POSIX é usado como uma interface portátil do sistema operacional. C Posix tem uma biblioteca de pacotes construída com padrão C. Posix adiciona alguns recursos adicionais aos programas usados ​​em padrões C.

Por que os semáforos são usados?

Ao usar tópicos, encontramos vários problemas condicionais envolvendo condições de corrida. Isso ocorre quando dois ou mais threads precisam dos mesmos dados ou informações ao mesmo tempo que causando conflitos. Então, para evitar esse tipo de situação conflitante, usamos semáforos. Existem três tipos principais de semáforos. Um é um semáforo binário, e outro é um semáforo de contagem.

Utilizamos funções diferentes na faixa de semáforo como sem_wait, sem_post e sem_init. Sem_init é o tópico em consideração mais adiante neste artigo.

Sem_init

Como discutimos acima, para inicializar o semáforo em threads, usamos a função sem_init. Aqui usamos uma bandeira ou um banner que identifica o compartilhamento de semáforo com o procedimento Fork ().

Sintaxe

# sem_init (SEM *SEM, int Pshared, int Value (não assinado));

SEM: Este recurso auxilia o semáforo a estar em um estado pronto.

Pshared: Este argumento de parâmetro é fundamental na declaração de semáforo. Como determina o status do semáforo recém -inicializado. Se deve ou não ser compartilhado entre os processos ou threads. Se o valor for diferente de zero, significa que o semáforo é compartilhado entre dois ou mais processos e, se o valor for zero, isso significa que o semáforo será compartilhado entre os threads.

Valor: Especifica o valor que deve ser atribuído ao semáforo recém -criado que é atribuído inicialmente.

Implementação de sem_init

Para executar semáforos no programa C, precisamos de um compilador GCC. Mas isso não é suficiente. "-LpThread" é ​​usado para executar o código. 'a.C 'é o nome do arquivo. Outra coisa é que aqui usamos '.fora 'com o nome do arquivo em vez de usar o arquivo de forma independente.

Exemplo 1

Primeiro, adicionamos duas bibliotecas com semáforos e pThread para satisfazer o uso de pacotes C. Como sem_init, outros semáforos são usados ​​neste programa; Aqui, vamos discuti -los.

Sem_wait ()

Esta função é usada para manter um semáforo ou continuar esperando. Se o valor fornecido ao semáforo for negativo, o chamado será bloqueado e o ciclo será fechado. Enquanto qualquer outro tópico, quando chamado, os semáforos bloqueados são despertados.

Sem_post ()

O método SEM_Post é usado para aumentar o valor de semáforo. O valor é incrementado por sem_post quando é chamado.

Sem_destroy ()

Se queremos destruir o semáforo, usamos o método sem_destroy. Agora, novamente, concentre -se no código -fonte fornecido aqui. Primeiro, a função "aguardar" é usada aqui. Isso fará com que o tópico espere primeiro para que outros possam executar uma tarefa. É exibida uma mensagem de que o tópico é inserido em chamando a função. Depois disso, uma função de "sono" é chamada por 5 segundos.

Dois threads são criados de acordo com as principais funções, 2 threads são criados, mas o primeiro dorme por 5 segundos após a adquirir a fechadura. Portanto, o segundo tópico não é inserido quando é chamado. Ele entrará após 5-2 segundos quando for chamado.

Sem_post funcionará após a função do sono; sem_post funcionará e mostrará uma mensagem de status completa. No programa principal, o semáforo é inicializado primeiro e, em seguida, os dois threads são criados usando o pThread. Usamos a função pthread_join para ingressar nos threads. E no final, os semáforos são destruídos.

Salvar o arquivo com a extensão de .c; O código será compilado e a execução será feita. Na execução, você verá que a primeira mensagem é exibida e, em seguida, leva alguns segundos para ser concluído, pois fornecemos a função de sono com 5 segundos; portanto, após esse período, a segunda mensagem para o primeiro thread é exibida.

Freqüentemente a primeira mensagem para o segundo tópico é exibida.

A segunda mensagem levará novamente tempo para prosseguir.

Exemplo 2

Antes de avançar em direção ao segundo exemplo, primeiro, precisamos entender o conceito do problema do escritor do leitor. Suponha que um banco de dados que você deseja compartilhar entre os processos é executado simultaneamente. Alguns desses processos ou tópicos podem ler apenas o banco de dados. Ao mesmo tempo, outros podem gostar de modificar o banco de dados. Discriminamos entre esses dois declarando o primeiro como leitor e o segundo como escritor. Se dois leitores acessarem os dados compartilhados, isso não causará efeito.

Para minimizar a ocorrência desses tipos de dificuldades, precisamos ajudar os escritores a acessar o banco de dados compartilhado para escrever nele. Este problema é sincronizado e conhecido como problema dos leitores-escritores.

Existem muitas variações neste problema. O primeiro lida com a questão que nenhum leitor estará esperando, a menos que um escritor use objetos compartilhados.

Este programa fornece a solução para o primeiro problema do leitor-escritor. Neste código -fonte C, usamos 10 leitores e 5 procedimentos para demonstrar a solução. Os dois primeiros contadores são referidos como zero. O não -lerente identifica o número do leitor. Movendo -se em direção à função do escritor, duas funções de semáforo são usadas aqui, a primeira é a espera, e o último é o post. Isso exibirá o número do escritor.

Após a função do escritor, a função do leitor é declarada aqui. O escritor modificará o banco de dados para que o leitor não possa entrar ou alterar qualquer coisa adquirida por um bloqueio.

# Pthread_mutex_lock (& ​​mutex);

A contagem de não -leitores é então incrementada. Aqui é aplicado um cheque de IF-Statement. Se o valor for 1, significa que é o primeiro leitor para que o escritor seja bloqueado. Se o não leitor for 0, depois de verificar, significa que é o último leitor, então agora permitiremos ao escritor da modificação.

# Pthread_mutex_unlock (& ​​mutex);

Vamos nos mudar em direção ao programa principal depois que o leitor e a função do escritor. Aqui nós inicializamos 10 leitores e 5 escritores. A função sem_init inicializará o semáforo. Pois loops são usados ​​aqui separadamente para os leitores e escritores. Pthread_create criará as funções de leitura e gravação. Além disso, Pthread_join se juntará aos tópicos. Cada um para loop usará esta junta 5 vezes para fins de escritor e depois 10 vezes para o propósito do leitor.

E no final, o semáforo é destruído, respectivamente, após o uso. Compilar o código e depois executá -lo. Você verá que números aleatórios para o leitor são gerados dentro de 10 tamanhos de matriz com a contagem 1. E para o escritor, 5 números são modificados.

Conclusão

O artigo 'Sem_init' é uma função usada pelas semáforos no processo de leitura multithithing para priorizar as tarefas que ocorrem simultaneamente. Existem muitas outras funções relacionadas a semáforos, também discutidas aqui. Explicamos dois exemplos elementares para elaborar o uso de sem_init nas funções e outros recursos.