Question

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>

pthread_mutex_t mutex_lock;

/* semaphore declarations */
sem_t students_sem; /* ta waits for a student to show up, student notifies ta his/her arrival */
sem_t ta_sem;       /* students waits for ta to help, ta notifies student he/she is ready to help */

/* the number of waiting students */
int waiting_students;

/* ta sleeping status indicator */
int ta_sleep = 1;
/* the maximum time (in seconds) to sleep */
#define MAX_SLEEP_TIME 3 

/* number of potential students */
#define NUM_OF_STUDENTS 4

#define NUM_OF_HELPS 2

/* number of available seats */
#define NUM_OF_SEATS 2

/* Student IDs */
int stud_id[NUM_OF_STUDENTS];

/* TA and student threads */
pthread_t students_thread[NUM_OF_STUDENTS];
pthread_t ta_thread;

/* function prototype */
void* ta_check(void* p);
void* student_check(void* p);

int main (void) 
{
    /* local variable declaration */
    int i;

    /* initialize mutex and semaphore */
    pthread_mutex_init(&mutex_lock, NULL);
    sem_init(&ta_sem, 0, 0);
    sem_init(&students_sem,0,0);

    /* create ta thread */
    pthread_create(&ta_thread, 0, ta_check,0);

    /* create student threads */
    for (i = 0; i < NUM_OF_STUDENTS; i++)
        pthread_create(&students_thread[i], 0, student_check,(void*)&stud_id[i]);

    /* join student threads */
    for (i = 0; i < NUM_OF_STUDENTS; i++)
        pthread_join(students_thread[i], NULL);

    /* cancel ta thread when all student threads terminate */
    pthread_cancel(ta_thread);
    printf("The TA finished helping all students.\n");

    return 0;
}

void* ta_check(void* p)
{
    /* invoke random number generator */
    rand_r(time(NULL));
    while (1)
    {
        pthread_mutex_lock(&mutex_lock);
        ta_sleep = 1;
        pthread_mutex_unlock(&mutex_lock);
        sem_wait(&students_sem);
        // help a student 
        printf("Helping a student for %d seconds, # of waiting students = %d", MAX_SLEEP_TIME, waiting_students);
        sleep(MAX_SLEEP_TIME);
        // check if there are more student to help
        while (waiting_students > 0)
        {
            sem_post(&ta_sem);
            pthread_mutex_lock(&mutex_lock);
            waiting_students--;
            pthread_mutex_unlock(&mutex_lock);
            // help student
            printf("Helping a student for %d seconds, # of waiting students = %d", MAX_SLEEP_TIME, waiting_students);
            sleep(MAX_SLEEP_TIME);
        }
    }
    return NULL;
}

void* student_check(void* p)
{
    /* invoke random number generator */
    rand_r((unsigned*)1);
    int num_help = 0;
    int seat_taken = 0;

    while (num_help <= NUM_OF_HELPS)
    {
        // check if ta is not sleeping 
        if (!ta_sleep)
        {
            if (!seat_taken)
            {
                if (waiting_students < NUM_OF_SEATS)
                {
                    // student take a seat
                    seat_taken = 1;
                    pthread_mutex_lock(&mutex_lock);
                    waiting_students++;
                    pthread_mutex_unlock(&mutex_lock);
                    printf("Stdudent %d takes a seat, # of waiting student = %d", *(int*)p, waiting_students);
                    sem_wait(&ta_sem); 
                    seat_taken = 0;
                    num_help++;
                }
                else
                {
                    printf("\tStudent %d programming for %d seconds\n",*(int*)p,MAX_SLEEP_TIME);
                    sleep(MAX_SLEEP_TIME);
                    printf("\tStudent %d will try later\n",*(int*)p);
                }
            }
        }
        // check if ta is sleeping
        else if (ta_sleep)
        {
            pthread_mutex_lock(&mutex_lock);
            ta_sleep = 0;
            pthread_mutex_unlock(&mutex_lock);
            sem_post(&students_sem);
            sem_wait(&ta_sem);
            num_help++;
        }
    }
    printf("Student %d is receiving help", *(int*)p);
    return NULL;
}

在我完成修复此程序的所有错误和警告消息后，我第一次遇到此错误消息segmentation fault(core dumped)。它在我调试这个程序之前从未出现过。我可以帮助找到发生此错误的位置。非常感谢您的帮助。

Answer 1

rand_r函数需要一个指向unsigned int的指针（与rand不同的用法。

所以你应该这样做：

unsigned int myrand = (unsigned int)time(NULL);
rand_r(&myrand);

Answer 2

当我在gdb中运行时，我看到有关rand_r()的投诉：

Program received signal SIGSEGV, Segmentation fault.
[Switching to Thread 0x7ffff77f6700 (LWP 6018)]
rand_r (seed=0x5639d757) at rand_r.c:31
31  rand_r.c: No such file or directory.
(gdb) bt 
#0  rand_r (seed=0x5639d757) at rand_r.c:31
#1  0x0000000000400af7 in ta_check (p=0x0) at foo.c:71
#2  0x00007ffff7bc4182 in start_thread (arg=0x7ffff77f6700) at pthread_create.c:312
#3  0x00007ffff78f147d in clone () at ../sysdeps/unix/sysv/linux/x86_64/clone.S:111

Answer 3

这是你的问题：rand_r（（unsigned *）1）（还有rand_r（time（NULL））

每当你发现自己将一个文字投射到一个指针（并且你没有进行深度嵌入式编程）时，你应该怀疑（当你在编写驱动程序时，你应该是偏执狂）。

在这个例子中，rand_r写入指针指向的内存，因此这需要是每个线程int，而不是文字。

rand_r（time（NULL）不会出现段错误，但也不会像你期望的那样工作，因为你每次调用时都会使用当前时间重新播种RNG（我希望RNG输出能够准确地改变一次在这种情况下的第二个）。

最容易的事情可能是让学生和TA小结构并且每个都包含一个int rand_state，您可以在开始线程（初始种子）之前使用随机值初始化，然后调用rand_r（＆amp; student-＆gt; rand_state ）会给你你期望的结果。这些结构也可以包含学生或TA的pthread。

问候，丹。

分段错误（核心转储）错误消息

3 个答案: