Pthread introduction

Question

I'm a long time reader of stackoverflow and have decided to ask for assistance myself. Before I ask, this is a homework question as it seems it would be better to notify you all. The assignment is on multi-threading and I'm using C in a linux environment. My error is that once I run the ./crazy.out file the professor thread is created and the printF is shown, but nothing else. I'm uncertain if I am correctly using the mutex and conditional signals to make the student thread work along with it.

Professor function

void Professor()
{
//Initialize global variables
studentCondition = 0;
professorCondition = 0;
snack = 0;
wakeup = 0;
students = 0;

//Initialize pthread mutex
pthread_mutex_init(&lock_prof, NULL);
pthread_mutex_init(&lock_stud, NULL);
pthread_mutex_init(&lock_wait, NULL);
pthread_mutex_init(&lock_snack, NULL);
pthread_mutex_init(&lock_question, NULL);

//Initialize pthread conditions
pthread_cond_init(&professor, NULL);
pthread_cond_init(&student, NULL);

if( pthread_create(&pStack, NULL, professorThread(), NULL))
{
    perror("Thread creation failed!!");

}
}

The professor thread.

void * professorThread()
{

printf("Crazy professor's hours have started!\n");

if(students == 0)
{
    Nap();  
}
pthread_cond_wait(&professor, &lock_prof);
professorCondition = 1;
while(professorCondition)
{
    professorCondition = 0;
    if(stud != NULL)
    {
        AnswerStart();
        AnswerDone();
        //Increment snack counter
        snack++;

        //Since answer is finished, tell the student
        pthread_cond_signal(&student);

        //If 3 questions have been answered, snack time!
        if(snack == 3)
        {
            pthread_cond_wait(&professor, &lock_question);//Lock professor     while he snacks. No questions please.
            Snack();
            snack = 0;
        }
    }
}
return EXIT_SUCCESS;
}

Student function and thread.

void Student(int id, int numQuestions)
{
struct student * newStudent = malloc(sizeof(student));

newStudent->id = id + 1001;
newStudent->numQuestions = numQuestions;

pthread_t tStack;

if(pthread_create(&tStack, NULL, (void *) &studentThread, (void *) newStudent ) )
{
    perror("Creation of thread occurred.");
    exit(0);
}
}

void * studentThread(void * student)
{
struct student * s = student;

printf("Student %d is at professor's door and wants to ask %d questions\n", (*stud).id, (*stud).numQuestions);

//don't forget increment num of students
students++;
if(stud != NULL)
{
    data = (*data).next;
    (*data).next = s;
}else
     {
    data = stud;
    stud = s;
     }
//mutex lock students
pthread_mutex_lock(&lock_stud);
while(1){


    //wait for prof
    pthread_mutex_lock(&lock_prof);
    //ask q
    if(stud != NULL)
    {
        stud = NULL;
        pthread_cond_signal(&professor);
    }   

    if( stud != NULL)
    {
        QuestionStart();
        QuestionDone();
    }

    //mutex unlock
    pthread_mutex_unlock(&lock_prof);   
}
//run question loop until numstudents = 0
}

Answer 1

per the posted code:

1) the professor arrives at his office
2) if no students in a the crowd outside the office, then professor naps
3) professor lets one student, from crowd, into his office
4) the student asks a question
5) the professor answers the question
6) the student leaves the office
7) the professor leaves his office

So, the shared resource is the professor/office (needs a mutex)

So, the crowd is the students that want access to the professor

currently, the professor handles one student, then goes away.

Probably not what is wanted because it does not handle multiple students and does not handle any one student having multiple questions.

IMO:

there needs to be multiple student threads.   
Each student thread has a random number of questions. (which could be 0)
student loop:
    if number student questions is > 0
    then student pends on professor resource
    else student exits loop (exits student thread)

    When a student gets the professor resource, 
        the student locks the professor resource.(enters office)
        the student asks question
        the professor answers question
        the student unlocks the professor resource (exits office)
        the number of questions for that student is decremented
end loop

for the professor to be able to do other things,

the professor could let students know when they are available (perhaps via a condition signal)

the students could let the professor know they want to ask a question (perhaps via a condition signal)