Comment puis-je tuer un pthread qui est dans une boucle infinie, de l'extérieur de cette boucle?

Comme @ sarnold l'a souligné, par défaut, votre thread ne peut pas être annulé avec pthread_cancel() sans appeler de fonctions qui sont des points d'annulation... mais cela peut être changé en utilisant pthread_setcanceltype() pour définir le type d'annulation du thread sur asynchrone au lieu de différé. Pour ce faire, vous devez ajouter quelque chose comme pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS,NULL); près du début de votre fonction de thread, avant de commencer la boucle. Vous pourrez alors terminer le thread en appelant pthread_cancel(th) à partir de main().

Notez cependant que l'annulation les threads de cette façon (asynchrones ou non) ne nettoient aucune ressource allouée dans la fonction thread (comme indiqué par Kevin dans un commentaire). Pour ce faire proprement, vous pouvez:

• assurez - vous que le thread ne fait rien qu'il doit nettoyer avant la sortie (par exemple en utilisant malloc() pour allouer un tampon)
• assurez-vous que vous avez un moyen de nettoyer après le thread ailleurs, après la sortie du thread
• utilisez pthread_cleanup_push() et pthread_cleanup_pop() pour ajouter des gestionnaires de nettoyage à nettoyer ressources lorsque le thread est annulé. Notez que cela reste risqué si le type d'annulation est asynchrone, car le thread peut être annulé Entre l'allocation d'une ressource et l'ajout du gestionnaire de nettoyage.
• évitez d'utiliser pthread_cancel() et demandez au thread de vérifier une condition pour déterminer quand se terminer (ce qui serait vérifié dans les boucles de longue durée). Puisque votre thread vérifie alors la terminaison elle-même, il peut faire tout le nettoyage dont il a besoin après la vérification.

Un la façon d'implémenter la dernière option consiste à utiliser un mutex comme drapeau, et à le tester avec pthread_mutex_trylock() enveloppé dans une fonction à utiliser dans les tests de boucle:

#include <pthread.h>
#include <unistd.h>
#include <errno.h>

/* Returns 1 (true) if the mutex is unlocked, which is the
 * thread's signal to terminate. 
 */
int needQuit(pthread_mutex_t *mtx)
{
  switch(pthread_mutex_trylock(mtx)) {
    case 0: /* if we got the lock, unlock and return 1 (true) */
      pthread_mutex_unlock(mtx);
      return 1;
    case EBUSY: /* return 0 (false) if the mutex was locked */
      return 0;
  }
  return 1;
}

/* Thread function, containing a loop that's infinite except that it checks for
 * termination with needQuit() 
 */
void *thread_do(void *arg)
{
  pthread_mutex_t *mx = arg;
  while( !needQuit(mx) ) {}
  return NULL;
}

int main(int argc, char *argv[])
{
  pthread_t th;
  pthread_mutex_t mxq; /* mutex used as quit flag */

  /* init and lock the mutex before creating the thread.  As long as the
     mutex stays locked, the thread should keep running.  A pointer to the
     mutex is passed as the argument to the thread function. */
  pthread_mutex_init(&mxq,NULL);
  pthread_mutex_lock(&mxq);
  pthread_create(&th,NULL,thread_do,&mxq);

  sleep(2);

  /* unlock mxq to tell the thread to terminate, then join the thread */
  pthread_mutex_unlock(&mxq); 
  pthread_join(th,NULL);

  sleep(2);
  return 0;
}

Si le thread n'est pas détaché (il ne l'est généralement pas par défaut), vous devez appeler pthread_join() après avoir arrêté le thread. Si le thread est détaché, vous n'avez pas besoin de le joindre, mais vous ne saurez pas exactement quand il se termine (ou même approximativement, sauf si vous ajoutez une autre façon d'indiquer sa sortie).