Comment implémenter la programmation multithread Linux

Introduction
Les variables conditionnelles sont un mécanisme qui utilise des variables globales partagées entre les threads pour la synchronisation. Elle comprend principalement deux actions : un thread attend que la condition de la variable de condition soit établie et raccroche (n'occupant plus le CPU à ce moment) ; l'autre thread utilise La condition est établie (donne un signal indiquant que la condition est établie). Pour éviter les conflits, l'utilisation de variables de condition est toujours combinée avec un verrou mutex.

Prototype de fonction
1. Définir les variables de condition

#include <pthread.h>

/* 定义两个条件变量 */
pthread_cond_t cond_pro, cond_con;

2. Initialiser et détruire les variables de condition

#include <pthread.h>

int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);int pthread_cond_destroy(pthread_cond_t *cond); /* 初始化条件变量 */
pthread_cond_init(&cond_pro, null);
pthread_cond_init(&cond_con, null);
/* 销毁条件变量 */
pthread_cond_destroy(&cond_pro);
pthread_cond_destroy(&cond_pro);

3 Conditions d'attente et de déclenchement

#include <pthread.h>

int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);

int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
/* 等待条件 */
/* 注意：pthread_cond_wait为阻塞函数。解开锁，再等待。等条件满足时，需要抢到锁，才可以被唤醒*/  
pthread_cond_wait(&cond_pro,&mutex); 

/* 激发条件 */
/* 所有因为不满足条件的线程都会阻塞在条件变量cond_pro中的一个队列中 */
/* 以广播方式，通知所有被阻塞的所有线程 */
pthread_cond_broadcast(&cond_pro);
/* 以signal方式，只通知排在最前面的线程 */
pthread_cond_signal(&cond_pro);

Code

/*************************************************************************
  > file name: my_con.c
  > author: krischou
  > mail:zhoujx0219@163.com 
  > created time: tue 26 aug 2014 10:24:29 am cst
 ************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <unistd.h>
#define cell 10
#define flore 0

 

int i = 0; /* 所有线程共享的全局变量，此处假定至多递增至10，最小减到0 */

pthread_mutex_t mutex;       /* 定义互斥锁 */
pthread_cond_t cond_pro, cond_con; /* 定义两个条件变量 */

/* 生产者线程 */
void* pro_handler(void *arg)
{
  pthread_detach(pthread_self());  /* 由系统回收线程资源，而非主线程回收资源 ，此类情况主线程是个服务器，永久不会退出 */
  
  while(1)
  {
    pthread_mutex_lock(&mutex);
    while(i >= cell)
    {
      pthread_cond_wait(&cond_pro,&mutex); 
      /* continue是轮询，此处是阻塞 */
      /* 把锁放开再等 ，第一个参数是结构体指针，其中有成员存放被阻塞的函数 */
      /*不占cpu*/
      /* 不满足条件时才会等 ，需要别人告诉它，才能唤醒它*//* 当它返回时，锁也要回来了*/
    }
    i++;
    if(i == 1)
    {
      /* 由空到不空，唤醒消费者 */
      pthread_cond_signal(&cond_con);  /*不会立马signal被阻塞的消费者线程，因为其还要等锁抢回来*/
    }
    printf("add i: %d \n", i);
    pthread_mutex_unlock(&mutex);
    sleep(rand() % 5 + 1);
  }
}

/* 消费者线程 */
void* con_handler(void *arg)
{
  pthread_detach(pthread_self());
  while(1)
  {
    pthread_mutex_lock(&mutex);
    while(i <= flore)
    {
      pthread_cond_wait(&cond_cno,&mutex);
    }
    i--;
    if(i == 9) /* 由满到不满，要告诉生产者,以便将其唤醒 *//*此处，直接signal也可以，我们是为了更加精确*/
    {
      pthread_cond_signal(&cond_pro);
    }
    printf("con i: %d \n", i);
    pthread_mutex_unlock(&mutex);
    sleep(rand() % 5 + 1);
  }
}

int main(int argc, char *argv[]) // exe +num -num
{
  srand(getpid());
  int con_cnt, pro_cnt;
  pro_cnt = atoi(argv[1]);
  con_cnt = atoi(argv[2]);
  pthread_mutex_init(&mutex,null);
  pthread_cond_init(&cond_pro,null);
  pthread_cond_init(&cond_con,null);
  pthread_t *arr = (pthread_t*)calloc(con_cnt + pro_cnt , sizeof(pthread_t));
  int index = 0;
  while(pro_cnt > 0)
  {
    pthread_create(arr + index, null, pro_handler, null);
    index++;
    pro_cnt--;
  }
  while(con_cnt > 0)
  {
    pthread_create(arr + index, null, con_handler, null);
    index++;
    con_cnt--;
  }
  while(1);
  pthread_mutex_destroy(&mutex);
  pthread_cond_destroy(&cond_pro);
  pthread_cond_destroy(&cond_con);
  return 0;
}

Remarque
Que ce soit dans le thread producteur ou au milieu du thread consommateur. . La condition de jugement marquée en jaune doit utiliser while. En prenant le thread producteur comme exemple, lorsque i>=cell, c'est-à-dire lorsque i est plein, pthread_cond_wait(&cond_cno,&mutex); Il faut attendre que le thread consommateur pthread_cond_signal(&cond_pro); Mais il ne suffit pas que le consommateur le signale. Le thread producteur suspendu doit à nouveau obtenir le verrou avant de pouvoir être activé. Cependant, comme le producteur ne peut pas immédiatement saisir le verrou lorsque le consommateur le signale, la valeur i peut devenir supérieure ou égale à 10 à ce moment-là. Vous devez donc utiliser while. Sinon, un résultat i>10 pourrait en résulter.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!