我正在尝试学习如何为学校项目创建多线程程序。我在调试我的项目时遇到了问题。它可能看起来像一堆垃圾，所以我提前道歉。我的编程技能不是很强，这就是我很难找到问题的原因。任何方向都很感激！
午餐c：

#include "mytime.h"
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>

#define MAX 50

int ticketCounter = 1;
int maxCustomer, maxServer, nowServing, currServer;
sem_t empty, full; // for buffer
sem_t servers;
pthread_mutex_t getTicketLock, waitTurnLock, waitCustomerLock, buffLock;

typedef struct LUNCH {
    long int TID;
    int ticketNum;
    int numServers;
    unsigned int takeALooksy;
    sem_t ready;
    pthread_mutex_t lock;
} lunch;

lunch *orderList;
int listCount = 0, producer = 0, consumer = 0;

void lunch_init();
int lunch_get_ticket(lunch *cust);
void lunch_wait_turn(lunch *cust);
void lunch_wait_customer(lunch *cust); // server waits for a cust to appear
void ordersUp(lunch cust); // add customer to orderList
void consume();
void show_serving(int num);
void *customer(void *threadId);
void *server(void *threadId);

int main(int argc, char **argv) {
    if (argc != 3) {
        fprintf(stderr, "Usage: %s <total number of servers> <total number of customers>\n", argv[0]);
        exit(1);
    }

    srand(time(NULL)); // for random number seed
    maxServer = atoi(argv[1]);
    maxCustomer = atoi(argv[2]);
    currServer = maxServer;

    lunch_init();
    lunch Lunch;
    pthread_t custThreads[maxCustomer], serverThreads[maxServer];

    for (int i = 0; i < maxCustomer; i++) {
        if ((pthread_create(&(custThreads[i]), NULL, customer, &Lunch)) != 0) {
            perror("customer pthread_create() error\n");
            exit(1);
        }
    }

    for (int i = 0; i < maxServer; i++) {
        if ((pthread_create(&(serverThreads[i]), NULL, server, &Lunch)) != 0) {
            perror("server pthread_create() error\n");
            exit(1);
        }
    }

    for (int i = 0; i < maxCustomer; i++) {
        pthread_join(custThreads[i], NULL);
    }    

    for (int i = 0; i < maxServer; i++) {
        pthread_cancel(serverThreads[i]);
    }

    return 0;
}

void lunch_init() {
    orderList = (lunch *)malloc(MAX * sizeof(lunch));
    if (orderList == NULL) {printf("orderList allocation error!\n"); exit(1);}

    for (int i = 0; i < MAX; i++) {
        orderList[i].ticketNum = -1;
        orderList[i].TID = -1;
        orderList[i].numServers = maxServer;
        orderList[i].takeALooksy = 0;
        sem_init(&(orderList[i].ready), 0, 1); // bin semaphore
        pthread_mutex_init(&(orderList[i].lock), NULL);
    }

        sem_init(&servers, 0, maxServer);
        sem_init(&empty, 0, MAX);
        sem_init(&full, 0, 0);
        pthread_mutex_init(&getTicketLock, NULL);
        pthread_mutex_init(&waitTurnLock, NULL);
        pthread_mutex_init(&waitCustomerLock, NULL);
        pthread_mutex_init(&buffLock, NULL);
}

int lunch_get_ticket(lunch *cust) {
    printf("<%ld> enter <lunch_get_ticket>\n", pthread_self());

    //critical section begins
    pthread_mutex_lock(&getTicketLock);
    cust->ticketNum = ticketCounter++;
    printf("<%ld> get ticket <%d>\n", pthread_self(), cust->ticketNum);
    //critical section ends
    pthread_mutex_unlock(&getTicketLock);

    printf("<%ld> leave <lunch_get_ticket>\n", pthread_self());

    return cust->ticketNum;
}

void lunch_wait_turn(lunch *cust) { // customer gets stuck
    printf("<%ld> enter <lunch_wait_turn>\n", pthread_self());
    pthread_mutex_lock(&waitTurnLock);
    // wait for turn without busy waiting
    sem_wait(&servers);
    pthread_mutex_unlock(&waitTurnLock);

    printf("<%ld> leave <lunch_wait_turn> after ticket <%d> served\n", pthread_self(), orderList[consumer - 1].ticketNum);  
}

void lunch_wait_customer(lunch *cust) {
    printf("<%ld> enter <lunch_wait_customer>\n", pthread_self());
    pthread_mutex_lock(&cust->lock);
    if (currServer > 0) {
        nowServing++;
        currServer--;
        sem_wait(&(cust->ready));
        show_serving(nowServing);
        sem_post(&(servers)); // changed to servers from cust->ready
        printf("<%ld> after served ticket <%d>\n", pthread_self(), orderList[consumer].ticketNum);
    }
    // sem_wait(&(cust->ready));
    pthread_mutex_unlock(&(cust->lock));

    printf("<%ld> leave <lunch_wait_customer>\n", pthread_self());
    if (currServer > 0) consume();
}

void ordersUp(lunch customer){
    while(1) {
        sem_wait(&empty); // wait for an empty slot in the buffer
        pthread_mutex_lock(&buffLock); // only one can add to the buffer at a time
        orderList[producer] = customer;
        listCount++;
        producer = (producer + listCount) % MAX; // circ array
        pthread_mutex_unlock(&buffLock);
        sem_post(&full);
    }
}

void consume() {
    pthread_mutex_lock(&buffLock);
    sem_wait(&full); // wait for something to consume
    listCount--;
    consumer = (consumer + listCount) % MAX;
    pthread_mutex_unlock(&buffLock);
    sem_post(&empty);
}

void show_serving(int num) { printf("Serving <%d>\n", num); }

void *customer(void *threadId) {
    lunch *temp = (lunch *)threadId;
    temp->TID = (long int)pthread_self();
    temp->ticketNum = lunch_get_ticket(temp);
    temp->takeALooksy = mytime(1, (rand() % 10) + 1);
    printf("Sleeping Time: %d sec; Thread Id = %ld\n", temp->takeALooksy, pthread_self());
    ordersUp(*temp); // ??
    sleep(temp->takeALooksy);
    sem_post(&temp->ready);
    lunch_wait_turn(temp);
    return NULL;
}

void *server(void *threadId) {
    lunch *temp = (lunch *)threadId;
    sem_post(&servers);
    while (1) { // is this busy-waiting?
        lunch_wait_customer(temp);
        sleep(rand() % 5 + 1);
    }

    return NULL;
}

mytime文件是由我的导师提供的。
mytime.c：

#include <stdio.h>
#include <stdlib.h>
 
int mytime (int left, int right)
{
    int time = 0;
    time = left + rand()%(right - left);
    // printf("random time is %d sec\n", time);
    return time;
}

mytime.h：

int mytime (int left, int right);  // return a random time in the range of [left, right]. Default values are [left, right].

整个错误：__pthread_tpp_change_priority：Assert`new_prio == -1||（new_prio〉= fifo_min_prio && new_prio〈= fifo_max_prio）'失败。
以下是项目描述：你去你最喜欢的餐馆吃午饭。在等待的过程中，你观察了他们的服务流程，并认为你可以编写一个程序来模拟它。你观察到的过程是这样的：一位顾客先拿了一张票，在随机环顾四周一段时间后，客户准备订购，并且票号显示在显示“正在服务”的屏幕上。订单由正在添加的新服务器处理（参见附加要求）。否则，客户等待订单被处理。另一方面，当没有客户时，服务器必须等待。
注意：在本项目中，您将编写代码来使用锁和信号量的同步原语模拟上述过程。它们在C中的pthread库中可用。仅使用锁和信号量，即不允许使用条件变量或其他同步原语。
为了运行模拟器，客户和服务器的总数应该从命令行输入。如果输入错误，提示重试的格式要正确，随机时间的睡眠功能要用来模拟客户取票后四处张望的时间。随机时间的睡眠函数也应该用来模拟服务器等待服务当前客户的时间。
提示：你可以定义一个结构struct lunch，加上下面描述的四个函数。struct lunch应该包含每个客户端所需的信息，如TID，ticket #，并在函数中用于传递信息。你可以使用一个地球仪ticket #计数器。此外，应该使用一个顺序列表来存储提交的ticket。这样，订单将按照先到先得的原则处理，您可以根据自己的喜好来实现列表，如果您使用循环数组来实现，则缓冲区大小可以固定为50作为MAX。
(1)结构午餐的初始化函数，调用一次，从没有客户和服务器开始。

void lunch_init(struct lunch *lunch)

(2)当一个新客户到来时，他调用该函数

int lunch_get_ticket(struct lunch *lunch)

这个函数将返回客户的票号，这个票号同样也在lunch变量中，它是没有返回给任何以前的客户的最小正整数（第一个客户为1，第二个客户为2，以此类推）.没有两个客户会收到相同的票号.队列可以在struct lunch内.拿到一张票后客户可以随意查看（通过随机睡眠模拟）。2此功能需要以下输出。

<ThreadId Customer> enter <function name>
 <ThreadId Customer> get ticket <ticket number>
 <ThreadId Customer> leave <function name>

(3)最终，客户将调用该函数
lunch_wait_turn（struct lunch *lunch）该函数必须在有可用的服务器并且“Now Serving”屏幕显示客户端的票号后才能返回。一旦lunch_wait_turn返回，客户端将由服务器提供服务（无需实现此机制）。以下输出将被打印出来。

<ThreadId Customer> enter <function name> with <ticket number>
 <ThreadId Customer> leave <function name> after ticket < ticket number> served.

(4)当一个新的服务器到达时，他将调用该函数

lunch_wait_customer(struct lunch *lunch)

在有客户需要服务之前，它不能返回。顺序列表有助于确保客户端以先到先服务的方式获得服务。一旦此函数返回，服务器将为客户提供服务（您不需要实现该机制）。该函数的输出是：

<ThreadId server > enter <function name>
<ThreadId server > after served ticket < ticket number>
<ThreadId server > leave <function name>

要求：（i）别忘了写一个函数Show_serving（int number），它会使number显示在“正在上菜”屏幕中。在代码中根据需要调用这个函数。输出格式：“服务“
(ii)你的解决方案不能使用busy-waiting，例如，在while循环中等待。
附加要求：（a）从命令行读取服务器的数量和客户端的数量。一台服务器只服务一次。在主程序中，不要忘记加入客户端和服务器。
(b)每种类型的线程使用一个数组，也是一个循环，用一个随机数睡眠。客户端只有在得到票后才睡眠。服务器在服务客户端之前先睡眠。确保在使用随机睡眠持续时间时，设置一个短的睡眠时间。在睡眠之前，打印出“睡眠时间：X秒;线程ID = ThreadId”。
(c)需要调用特定的函数mytime（）（参见文件mytime. c，mytime. h）来获取一个随机时间作为sleep函数的输入。
(d)您可以在任何合适的地方使用更多的函数。打印输出应遵循相同的格式。

(e)启动多个线程的例子在早期的帖子中给出，文件名：PC-inputs-main.c