C中的pthread问题

Question

I have a problem with the compiling of my program, when I test something like "./philo -p 3 -e 4" I get the error philo: tpp.c:62: __pthread_tpp_change_priority: Assertion `new_prio == -1 || (new_prio >= __sched_fifo_min_prio && new_prio <= __sched_fifo_max_prio)' failed. Aborted

But I don't understand where it does come from, as it's working sometimes, for exemple if I test "./philo -p 2 -e 4" it doesn't crash.

The two .h

#ifndef                 _PHILO_H_
# define                _PHILO_H_
#include                <pthread.h>

typedef struct          s_philosop
{
  pthread_t             philosophers;
  pthread_mutex_t       *chopsticks1;
  pthread_mutex_t       *chopsticks2;
  int                   nbr_occ;
}                       t_philosop;

int                     parse_arg(char **argv, int *philo, int *occ);
int                     create_threads_mutex(int nbr_philo, int occurences);
void                    *start_routine(void *arg);
void                    philosoph_eating_chopsticks(t_philosop *philosop);

#endif                  /* !_PHILO_H_ */


#ifndef __LIBRICEFEREE_EXTERN__
# define __LIBRICEFEREE_EXTERN__

#include <pthread.h>
int     RCFStartup(int ac, char **av);
void    RCFCleanup();
int     lphilo_eat();
int     lphilo_sleep();
int     lphilo_think();
int     lphilo_take_chopstick(const pthread_mutex_t *mutex_id);
int     lphilo_release_chopstick(const pthread_mutex_t *mutex_id);

#endif  /* __LIBRICEFEREE_EXTERN__ */

And this is my .c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include "philo.h"
#include "extern.h"

void                    philosoph_comportement(t_philosop *philosop)
{
  int                   i = 0;
  if ((pthread_mutex_lock(philosop->chopsticks1)) == 0)
    {
      printf("%s\n", "Taking left stick");
      lphilo_take_chopstick(philosop->chopsticks1);
      i++;
    }
  if ((pthread_mutex_lock(philosop->chopsticks2)) == 0)
    {
      printf("%s\n", "Taking right stick");
      lphilo_take_chopstick(philosop->chopsticks2);
      i++;
    }
  if (i == 2)
    {
      printf("%s\n", "Eat");
      lphilo_eat();
      sleep(1);
      printf("%s\n", "Sleep");
      pthread_mutex_unlock(philosop->chopsticks1);
      pthread_mutex_unlock(philosop->chopsticks2);
      lphilo_release_chopstick(philosop->chopsticks1);
      lphilo_release_chopstick(philosop->chopsticks2);
      lphilo_sleep();
    }
}

void                    *start_routine(void *arg)
{
  t_philosop            *philosop;
  int                   i;

  i = 0;
  philosop = (t_philosop *)arg;
  while (i != philosop->nbr_occ)
    {
      philosoph_comportement(philosop);
      i++;
    }
  return (0);
}

int                     create_threads_mutex(int nbr_philo, int occurences)
{
  int                   i;
  t_philosop            *philosop;
  pthread_mutex_t       *chopsticks;

  i = -1;
  if ((chopsticks = malloc(sizeof(pthread_mutex_t) * nbr_philo)) == NULL)
    return (2);
  if ((philosop = malloc(sizeof(t_philosop) * nbr_philo)) == NULL)
    return (2);
  while (++i != nbr_philo)
    {
      philosop[i].nbr_occ = occurences;
      philosop[i].chopsticks1 = &chopsticks[i];
      if (i - 1 < 0)
        philosop[i].chopsticks2 = &chopsticks[nbr_philo];
      else
        philosop[i].chopsticks2 = &chopsticks[i - 1];
    }
  i = -1;
  while (++i != nbr_philo)
    pthread_create(&philosop[i].philosophers, NULL, start_routine, &philosop[i]);
  i = -1;
  while (++i != nbr_philo)
    {
      printf("Philo number : %d\n", i);
      pthread_join(philosop[i].philosophers, NULL);
    }
  return (0);
}

int                     parse_arg(char **argv, int *philo, int *occ)
{
  if (strcmp(argv[1], "-p") == 0 && strcmp(argv[3], "-e") == 0 &&
      argv[2] != NULL && argv[4] != NULL)
    {
      *philo = atoi(argv[2]);
      *occ = atoi(argv[4]);
    }
  else if (strcmp(argv[1], "-e") == 0 && strcmp(argv[3], "-p") == 0 &&
           argv[2] != NULL && argv[4] != NULL)
    {
      *philo = atoi(argv[4]);
      *occ = atoi(argv[2]);
    }
  else
    return (2);
  return (0);
}

int                     main(int argc, char **argv)
{
  int                   philo;
  int                   occurences;

  philo = 0;
  occurences = 0;
  if (argc != 5)
    return (2);
  if ((parse_arg(argv, &philo, &occurences)) == 2)
    return (2);
  RCFStartup(argc, argv);
  if ((create_threads_mutex(philo, occurences)) == 2)
    return (2);
  RCFCleanup();
  return (0);
}

Answer 1

You don't initialize any of your mutexes with pthread_mutex_init .

And assuming lphilo_release_chopstick does nothing but unlock a mutex, this code is wrong as it will try to unlock each mutex twice:

  pthread_mutex_unlock(philosop->chopsticks1);
  pthread_mutex_unlock(philosop->chopsticks2);
  lphilo_release_chopstick(philosop->chopsticks1);
  lphilo_release_chopstick(philosop->chopsticks2);