Posix mutex em C

“O uso do mutex é o método para prevenir situações de raça que é mais frequentemente usada. Mutex, que se refere à exclusão mútua, nos dá essencialmente uma trava de morto que impede vários usuários de acessar e modificar os dados cruciais. Sempre que múltiplos ou mais processos empregam o mesmo processo que seu meio para terminar seu processamento, o impasse deve ser evitado. O assunto principal da discussão de hoje será usar a função Posix Mutex para evitar o impasse com diferentes métodos com a linguagem C no Ubuntu 20.04 Sistema. Antes de fazer qualquer coisa com seus trechos de código, devemos instalar o compilador "GCC".”

Exemplo 01

Vamos começar nossa primeira ilustração de funções Posix Mutex com os cabeçalhos necessários. Sem esses cabeçalhos, nosso script de C não será operacional da maneira que queremos. O primeiro stdio.H cabeçalho é responsável pela utilização de entradas e saídas regulares no código. O cabeçalho padrão "stdlib" é responsável pelo uso suave das funções da biblioteca padrão no snippet de código. O unistd.h cabeçalho é uma obrigação para encontrar questões relacionadas a unicodes. Aí vem a biblioteca para utilizar variáveis ​​e funções de string relacionadas à string na linguagem C, eu.e., corda.h.

Finalmente, a biblioteca é o “pThread.H ”Cabeçalho, o que é uma obrigação quando você deseja usar multithreading em seus trechos. Esta biblioteca inclui criação de threads, junção de threads, bloqueio de threads, desbloqueio de threads e muitas outras funções relacionadas ao multithreading.

#incluir
#incluir
#incluir
#incluir
#incluir

Depois de expulsar os cabeçalhos necessários, vamos inicializar 2 threads usando o objeto "pthread_t" da biblioteca do thread. O valor "T" será usado como ID do thread em um futuro próximo. Em seguida, uma variável inteira “i” é inicializada para 0 e a variável “C” foi declarada por contar os threads. O objeto de bloqueio mutex “ML” foi gerado usando o objeto Pthread_mutex_t. Aí vem a função de thread "t", que vai travar e desbloquear o tópico. Para bloquear o segmento de chamada, estamos usando a função pthread_mutex_lock () usando a trava "ML" enquanto conta o número do thread.

As declarações printf () estão aqui para nos contar sobre a inicialização e o fim de um tópico específico. Dentro da inicialização e final, a função de thread “t” é bloqueada e não pode ser acessada por outros threads. No final, a função pthread_mutex_unlock () é usada para desbloquear o fio específico e dar acesso a outros threads.

pthread_t t [2];
int i = 0;
int c;
pthread_mutex_lock (& ​​ml);
não assinado long i = 0;
c += 1;
printf ("thread %d iniciado… \ n", c);
para (i = 0; i<(0xFFFFFFFF); i++)
;
sono (5);
printf ("Terminou %d Thread… \ n", c);
sono (5);
pthread_mutex_unlock (& ​​ml);
retornar nulo;

A função principal () começa a partir da declaração "se" que está checando alguma condição. Ele usa a função pthread_mutex_init (), passando o objeto de trava “ml” e o valor nulo para inicializar o bloqueio mutex. Se o valor retornado da função init () não for igual a 0, a instrução printf () exibirá que o bloqueio mutex não foi inicializado devido a algum problema. Enquanto isso, o loop do tempo () usa a condição para variável "i", que deve ser menor que 2. Se for menor que 2, a função Thread_create () será chamada passando o ID do thread "t" como ponteiro e ponteiro em direção à função de thread "T". Se o tópico fosse criado com sucesso, ele retornaria "0" à variável "e".

No caso de retornar além de 0, será imprimir um, eu.e., Usando a função strerror e incrementar o valor de uma variável "eu". Esta função é responsável por chamar a função do thread para dois threads diferentes. A função pthread_join () usa o ID do thread para se juntar a eles com a função Main (), e a função pthread_mutex_destroy () está aqui para destruir a trava depois que todas as funções foram executadas. A mensagem de volta para uma mensagem principal () será exibida no final deste programa após execuções de threads.

int main ()
if (pthread_mutex_init (& ml, null) != 0)
printf ("Falha ao inicializar o bloqueio mutex… \ n");
retornar 1;

enquanto eu<2)
int e = pthread_create (& t [i], null, & t, null);
se (e != 0)
printf ("Falha ao criar thread: [%s]", strerror (e));
i ++;

pthread_join (t [0], nulo);
pthread_join (t [1], nulo);
pthread_mutex_destroy (& ml);
printf ("Olá! Estamos de volta ao método principal… \ n ");
retornar 0;

Estamos compilando o teste.Arquivo C com o compilador "gcc" e a opção -lpthread for threads execução. A execução mostra que o primeiro tópico obteve acesso à função "T" e bloqueado.

Depois que o bloqueio foi liberado do primeiro tópico, o acesso à função T foi dado ao segundo fio, e ela foi travada e destrancada também.

No final, ambos os threads foram executados e a função principal () recuperou o controle.

Exemplo 02

Aí vem outra maneira de demonstrar o uso do Posix Mutex para travar e desbloquear os threads. Dentro deste exemplo, não exigimos o unistd.h cabeçalho, então não vamos usá -lo. Caso contrário, todos os cabeçalhos estão aqui, que usamos no exemplo acima. O objeto pthread_mutex_t é usado para criar um bloqueio mutex "ml". O método Main () começa inicializando dois threads, T1 e T2, usando o objeto pthread_t. Ele usa a função pthread_create () duas vezes para criar threads chamando as funções T1 e T2, passando por IDs de inicialização de threads como ponteiros, eu.e., T1 e T2. Na criação de threads, a função T1 e T2 foi executada uma após a outra. Cada uma dessas funções é chamada de função test () passando 2 valores de string como parâmetros.

A função de teste é usada aqui para travar e desbloquear tópicos específicos que o chamam, eu.e., T1 e T2. Para bloquear os threads, a função pthread_mutex_lock () é usada e, para desbloquear, a função pthread_mutex_unlock () é usada, i.e., Ambos estão utilizando a trava “ML” Mutex. Dentro do processo de trava e desbloqueio, as instruções PRINTF são usadas com sono de 5 segundos após cada. O método Printf () PrintF () exibirá o primeiro argumento passado para a função de teste, e o método Printf () exibirá o segundo argumento da sequência passada para a função de teste.

#incluir
#incluir
#incluir
#incluir
pthread_mutex_t ml;
Void* teste (char* p, char* q)
pthread_mutex_lock (& ​​ml);
printf ("%s… \ n", p);
sono (5);
printf ("%s… \ n", q);
sono (5);
pthread_mutex_unlock (& ​​ml);

void* t1 (void* z)
Teste ("iniciado", "1º thread");
void* T2 (void* z)
Teste ("iniciado", "thread 2º");
int main ()
pthread_t t1, t2;
pthread_create (& t1, null, & t1, null);
pthread_create (& t2, null, & t2, null);
enquanto (1)
saída (0);

Ao compilar, ele mostrará um aviso, mas você pode ignorá -lo por um momento.

A execução do código compilado mostra que o primeiro tópico foi iniciado e obteve todos os recursos da função de teste.

Depois disso, o bloqueio foi liberado e o segundo tópico obteve os recursos. Após o segundo tópico, temos que sair da execução com força.

Conclusão

O conceito Posix Mutex é explicado brevemente para evitar o impasse em programação C C. Portanto, empregamos as funções pthread_mutex_lock e pthread_mutex_unlock para executar isso. Usando essas funções em nossos trechos de código, garantimos o uso de recursos para um tópico de cada vez.