Função pthread_cond_wait em c
Existe um tipo de sincronização que existe entre threads chamados bloqueios. Nesse caso, o thread precisa de exclusão mútua. Requer um tópico para executar de cada vez. Então, também um com o outro padrão comum necessário quando vários threads são interagidos. Eles são - esperando e sinalizando. Um tópico vai esperar até que outro tópico termine seu trabalho. Depois de concluir a execução deste tópico, o tópico de espera pode ser executado no processador. Para esse tipo de sincronização de threads, precisamos de outra técnica, chamada ocupada esperando algumas variáveis. Para isso, precisamos de um novo primitivo de sincronização chamado variáveis de condição.
Este conceito de tópico está disponível em diferentes sistemas operacionais. Mas iremos ao nome, variáveis de condição que são aplicadas como biblioteca PTHread no sistema operacional Linux
A função pthread_cond_wait () é um componente de espera. Esta função por padrão executa a ação de desbloqueio.
Exemplo de programação 1:
Neste exemplo de programação, veremos como essa função é executada:
#incluir#incluir
#incluir
#incluir
#incluir
pthread_mutex_t m = pthread_mutex_initializer; // declarando a variável de condição.
pthread_cond_t c = pthread_cond_initializer;
int done = 0;
void thr_exit ()
pthread_mutex_lock (& m);
feito = 1;
pthread_cond_signal (& c);
pthread_mutex_unlock (& m);
Void *Child (void *arg) // Processo Child Executa.
printf ("filho \ n");
thr_exit ();
retornar nulo;
void thr_join ()
pthread_mutex_lock (& m);
enquanto (feito == 0)
pthread_cond_wait (& c, & m); // Chame a função dentro da função Thr_join ().
pthread_mutex_unlock (& m);
int main (int argc, char* argv [])
printf ("Pai: Begin \ n");
pthread_tp;
pthread_create (& p, nulo, criança, nulo); // inicializando o tópico.
thr_join ();
printf ("pai: fim \ n");
retornar 0;
Saída:
Explicação
Neste exemplo de programação, existem dois processos chamados de tópico pai e um tópico infantil. Aqui, o pai quer esperar pela criança. Depois de concluir a execução do processo infantil, o pai inicia sua execução.
Para o interior do main (), criamos o tópico pai e filho. O encadeamento infantil executa a função denominada criança (). Então o painel pai chama a função de junção. Esta junção () basicamente verifica se a criança está feita. Caso contrário, ele esperará usando a função pthread_cond_wait (). Quando a criança corre, chama a saída (). Quando a execução da criança é feita, o valor da variável feito será 1. Em seguida, ele chama o sinal na variável de condição. Depois disso, a execução do thread dos pais começará.
Sintaxe de espera e sinal:
void thr_exit ()feito = 1;
pthread_cond_signal (& c);
void thr_join ()
se (feito == 0)
pthread_cond_wait (& c);
O que acontece se não conseguirmos uma trava? Isso ocorrerá uma condição de corrida - despertar perdido.
- O processo pai não tem nada para execução e ir à condição ociosa, pois esse caso a interrupção pode ocorrer.
- Quando a criança executa seu código e realizou sua execução, então sinaliza, mas ninguém dormindo ainda.
- Os pais agora reiniciaram sua execução de onde terminou e deve ser esperado por um período específico.
- Para esta função de espera, deve manter em sua mente que o tópico não está suspenso por um longo período de tempo. Tem que ser aberto sua fechadura.
Exemplo de programação 2:
Neste exemplo de programação, veremos outro uso de Pthread_cond_wait Fucking.
#incluir#incluir
#incluir
#incluir
#incluir
pthread_mutex_tmutexfuel;
pthread_cond_tcondfuel; // Criando a variável de condição.
int combustível = 0;
Void* abastecimento (vazio* arg)
para (int i = 0; i < 5; i++)
pthread_mutex_lock (& mutexfuel);
combustível += 15;
printf ("Obteve combustível ... %d \ n", combustível);
pthread_mutex_unlock (& mutexfuel);
pthread_cond_signal (& condfuel);
sono (1);
Void* veículo (vazio* arg)
pthread_mutex_lock (& mutexfuel);
enquanto (combustível < 40)
printf ("combustível zero. Esperando… \ n ");
pthread_cond_wait (& condfuel, & mutexfuel);
// Equivalente a:
// pthread_mutex_unlock (& mutexfuel);
// Aguarde o sinal no preservativo
// pthread_mutex_lock (& mutexfuel);
combustível -= 40;
printf ("combustível coletado agora à esquerda: %d \ n", combustível);
pthread_mutex_unlock (& mutexfuel);
int main (int argc, char* argv [])
pthread_ta [2];
pthread_mutex_init (& mutexfuel, nulo);
pthread_cond_init (& condfuel, nulo);
para (int i = 0; i < 2 ; i++ )
if (i == 1)
if (pthread_create (& a [i], null, & abuxering, null) != 0)
perror ("falhou em criar thread");
outro
if (pthread_create (& a [i], null, & veículo, nulo) != 0)
perror ("falhou em criar thread");
para (int i = 0; i < 2 ; i++ )
if (pthread_join (a [i], nulo) != 0)
Perror ("Falha ao ingressar no thread");
pthread_mutex_destroy (& mutexfuel);
pthread_cond_destroy (& condfuel); // Destruindo os fios.
retornar 0;
Saída:
Explicação
Aqui, veremos a aplicação da função pthread_cond_wait (). É como quando alguém quer encher o combustível dele. Ele tem que esperar até que seu carro seja preenchido com combustível. Para isso, criamos dois tópicos. Um para encher o combustível no carro e para o carro. Vamos definir duas funções. Um está abastecendo () função que determina quando encher o carro com combustível e outro é o veículo () função para obter combustível. O cara que quer encher o combustível em seu carro tem que esperar até que o combustível seja preenchido.
Dentro da função main (), criaremos dois threads para função () e para o veículo () função. Agora, criaremos uma variável de condição para aguardar a condição. Para isso, veremos a saída. Quando as funções completam sua execução, destruiremos esses tópicos.
Conclusão
A função pthread_cond_wait () notifica quando fizemos algum programa com a ajuda de vários threads. Esta função fará algumas variáveis de condição para lidar com esses threads. Na verdade, as características desta função dependem totalmente do princípio de Espere e sinalize teoria.