C 当我运行程序时，线程在N次发送后停止发送消息

源线程的send（）方法向滑行线程发送消息，滑行线程通过receive（）方法接收消息。 这些方法在共享内存中进行了大量访问，我注意到共享内存中的访问越多，执行的发送和接收就越少

    #include "header.h"
//pthread_cond_wait e pthread_cond_signal per bloccare i processi e sbloccarli dopo il piazzamento
int main() {
    // Inizializza la maschera dei messaggi
    sa.sa_handler = handle_signal;
    sa.sa_flags = 0;
    sigemptyset(&my_mask);
    sa.sa_mask = my_mask;

    // Inizializzazione roba
    init();

    // Creazione dei segmenti di memoria condivisa
    shm_cells_id = shmget(IPC_PRIVATE, sizeof(*cells)*SO_WIDTH*SO_HEIGHT, IPC_CREAT | 0666);
    cells = shmat(shm_cells_id, 0, 0);

    shm_taxi_id = shmget(IPC_PRIVATE, sizeof(*taxis)*SO_TAXI, IPC_CREAT | 0666);
    taxis = shmat(shm_taxi_id, 0, 0);

    shm_sources_id = shmget(IPC_PRIVATE, sizeof(*sources)*SO_SOURCES, IPC_CREAT | 0666);
    sources = shmat(shm_sources_id, 0, 0);

    // Creazione della coda di messaggi
    msg1_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0600);
    msg2_id = msgget(IPC_PRIVATE, IPC_CREAT | IPC_EXCL | 0600);

    // Crazione dei semafori
    //sem_init(&mutex, 0, 1);

    // Piazzamento delle celle vuote
    int n_holes = SO_HOLES;
    while (n_holes > 0) {
        int x = random_num(0, SO_WIDTH - 1);
        int y = random_num(0, SO_HEIGHT - 1);
        while (strcmp(cells[y*SO_WIDTH+x].content, "-H-") == 0 || is_around_hole(x,y)) {
            x = random_num(0, SO_WIDTH - 1);
            y = random_num(0, SO_HEIGHT - 1);
        }
        strcpy(cells[y*SO_WIDTH+x].content, "-H-");
        n_holes--;
    }

    // settaggio della griglia
    for (int i = 0; i < SO_HEIGHT; i++) {
        for (int j = 0; j < SO_WIDTH; j++) {
            if (strcmp(cells[i*SO_WIDTH+j].content, "-H-") != 0) {
                cells[i*SO_WIDTH+j].x = j;
                cells[i*SO_WIDTH+j].y = i;
                cells[i*SO_WIDTH+j].crossing_time = random_num(SO_TIMENSEC_MIN, SO_TIMENSEC_MAX);
                cells[i*SO_WIDTH+j].capacity = random_num(SO_CAP_MIN, SO_CAP_MAX);
                cells[i*SO_WIDTH+j].caught = false;
                strcpy(cells[i*SO_WIDTH+j].content, "---");
            }
        }
    }

    // creazione dei sources
    pthread_t sources_t[SO_SOURCES];
    int sources_t_args[SO_SOURCES];
    for (int i = 0; i < SO_SOURCES; i++) {
        sources_t[i] = i;
        sources_t_args[i] = i;
        pthread_create(&sources_t[i], NULL, make_sources, &sources_t_args[i]);
    }
    sleep(1);
    // creazione dei taxi
    pthread_t taxi_t[SO_TAXI];
    int taxi_t_args[SO_TAXI];
    for (int i = 0; i < SO_TAXI; i++) {
        taxi_t[i] = i;
        taxi_t_args[i] = i;
        pthread_create(&taxi_t[i], NULL, make_taxi, &taxi_t_args[i]);
    }
    sleep(1);
    pthread_cond_broadcast(&cond);

    /*for(int i = 0; i < SO_SOURCES; i++)
        pthread_join(sources_t[i], NULL);
    for(int i = 0; i < SO_TAXI; i++)
        pthread_join(taxi_t[i], NULL);*/

    // inizio simulazione
    endgame = false;
    start_timer(SO_DURATION);
    sleep(SO_DURATION);
    //sblocco taxi e sources

    //ciclo che genera la griglia ogni secondo

    // blocco il master fino alla fine della simulazione
}
void *make_sources(void *arg){
    int i =*((int *) arg);
    //printf("s_i: %d\n", i);
    pthread_mutex_lock(&lock);
    place_sources(i);
    pthread_mutex_unlock(&lock);

    pthread_mutex_lock(&lock2);
    pthread_cond_wait(&cond, &lock2);
    pthread_mutex_unlock(&lock2);

    while(!endgame){
        pthread_mutex_lock(&lock4);
        send_request(i);
        pthread_mutex_unlock(&lock4);
        sleep(1);
    }
}

// Fork per creare i processi taxi
void *make_taxi(void *arg){
    int i =*((int *) arg);
    //printf("t_i: %d\n", i);
    pthread_mutex_lock(&lock);
    place_taxi(i);
    pthread_mutex_unlock(&lock);

    pthread_mutex_lock(&lock2);
    pthread_cond_wait(&cond, &lock2);
    pthread_mutex_unlock(&lock2);

    while(!endgame) {
        pthread_mutex_lock(&lock5);
        receive_request(i);
        pthread_mutex_unlock(&lock5);
    }
}

int send_request(int i) {
    int d_x = random_num(0, SO_WIDTH - 1);
    int d_y = random_num(0, SO_HEIGHT - 1);
    int capacity = cells[d_y*SO_WIDTH+d_x].capacity;
    while (!is_capable(capacity, d_x, d_y) || cells[d_y*SO_WIDTH+d_x].content[1] == 'H' || cells[d_y*SO_WIDTH+d_x].caught == true) {
        d_x = random_num(0, SO_WIDTH - 1);
        d_y = random_num(0, SO_HEIGHT - 1);
    }
    cells[d_y*SO_WIDTH+d_x].caught = true;
    int x = sources->sources[i].x;
    int y = sources->sources[i].y;

#包括“header.h”
//pthread_cond_wait e pthread_cond_信号每个bloccare i processi e sbloccarli dopo il piazzamento
int main（）{
//马斯切拉德梅萨吉酒店
sa.sa_handler=处理_信号；
sa.sa_标志=0；
sigemptyset（&my_mask）；
sa.sa_mask=我的_mask；
//罗巴锡安酒店
init（）；
//第二记忆节段
shm_cells_id=shmget（IPC_PRIVATE，sizeof（*cells）*SO_WIDTH*SO_HEIGHT，IPC_create | 0666）；
cells=shmat（shm_cells_id，0,0）；
shm_出租车id=shmget（IPC_私人，sizeof（*出租车）*SO_出租车，IPC_创建| 0666）；
出租车=shmat（shm_出租车id，0,0）；
shm_sources_id=shmget（IPC_PRIVATE，sizeof（*sources）*SO_sources，IPC_create | 0666）；
sources=shmat（shm_sources_id，0,0）；
//梅萨吉尾波综合征
msg1_id=msgget（IPC_PRIVATE，IPC_CREAT | IPC_EXCL | 0600）；
msg2_id=msgget（IPC_PRIVATE，IPC_CREAT | IPC_EXCL | 0600）；
//塞马福里酒店
//sem_init（&mutex，0,1）；
//塞勒维奥特广场
int n_孔=SO_孔；
而（n_孔>0）{
int x=随机数（0，所以宽度为-1）；
int y=随机数（0，所以高度为-1）；
而（strcmp（单元格[y*SO_WIDTH+x].content，“-H-”==0 | |是_孔（x，y）周围的_））{
x=随机数（0，所以宽度为-1）；
y=随机数（0，所以高度为-1）；
}
strcpy（单元格[y*SO_宽度+x]。内容，“-H-”；
n_洞--；
}
//塞塔吉奥德拉格里利亚酒店
对于（int i=0；i源[i].x；
int y=源->源[i].y；

我省略了一些方法，因为它们与问题无关。 我希望我说得很清楚。

仔细阅读：条件变量不是“状态”。它们只是一种信号机制。如果您发现自己使用条件变量来检测谓词状态数据中可能发生的变化（这是互斥锁真正保护的，而不是cvar本身），那么您就没有正确使用它们。