Question

我正在尝试使用pthreads和信号量解决生产者消费者问题。目前，这两个线程似乎都没有执行，甚至主要没有打印出printf，似乎进程正在等待输入。（所以这一切都是，闪烁光标，然后按ctrl + c结束进程，因为没有发生任何事情）。我已经测试了get_rand_num并且有效。我正在用clang编译-Wall -std = c99 -lpthread -o randnumgen randnumgen.c

这是我的代码：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h> 
#include <stdint.h>
#include "sema.c"

typedef struct buffer {
    uint64_t *buffer;
    int max_size;
    int min_fill_lvl;
    uint64_t *first;
    uint64_t *last;
    int size;
    semaphore produce; 
    semaphore consume;
} buffer;

void *producer();
void *consumer();
uint64_t get_rand_num();
void init_buffer();
void cleanup_buffer();
void put_buffer();
uint64_t get_buffer();
int exit1=0;
buffer buf;

int main(){

    initialize(&buf.produce, 0);
    initialize(&buf.consume, 0);

    pthread_t producerThread;
    pthread_t consumerThread;
    printf("test");
    pthread_create(&producerThread, NULL, producer, (void *) &buf);
    pthread_create(&consumerThread, NULL, consumer, (void *) &buf);

    vacate(&buf.produce);

    pthread_join(producerThread, NULL);
    pthread_join(consumerThread, NULL);

    return 1;

}

void *producer(buffer *buf){
    printf("in producer");
    init_buffer(&buf, 2, 1); 

    while (1){
        procure(&buf->produce);
        uint64_t ret = get_rand_num();
        put_buffer(&buf, ret);

        vacate(&buf->consume);
    }

    cleanup_buffer(&buf);
    pthread_exit(NULL); 
}

void *consumer(buffer *buf){
    printf("in consumer");

    while (1){
        procure(&buf->consume);
        uint64_t ret = get_buffer(&buf);
        printf("%i", (int) ret);

        vacate(&buf->produce);
    }
    pthread_exit(NULL); 
}

uint64_t get_rand_num(){

    FILE *rand = NULL;

    rand = fopen("/dev/random", "r");

    uint64_t num;

    //static const size_t size = sizeof(uint64_t);

    fread(&num, sizeof(num), 1, rand); //returns -1 if fails i believe

    //printf("%i\n", (int) num);

    return num;

}

void init_buffer(buffer *buf, int max, int min){
    buf->buffer = malloc(sizeof(uint64_t) * max);

    buf->size = 0;
    buf->min_fill_lvl = min;
    buf->max_size = max;
}

void cleanup_buffer(buffer *buf){
    free(&buf->buffer);
}

void put_buffer(buffer *buf, uint64_t *num){

    if (buf->size < buf->max_size){
        *(buf->last++) = *num;
        buf->size++;
    }
    printf("successfully placed num in buffer");


}

uint64_t get_buffer(buffer *buf){

    if ((buf->size - 1) <= buf->min_fill_lvl){
        buf->size--;
        int ret = *buf->first;
        buf->first++;
        return ret;
    }
    return 0;
}

这是我的信号量代码：

// semaphore setup
void initialize(semaphore *sp, int startVal){
    pthread_mutex_init(&sp->lock, NULL);
    sp->vacancy = startVal; //starting value for semaphore
    pthread_cond_init(&sp->condition, NULL);
}

//destroys semaphore
void destruct(semaphore *sp){
    pthread_mutex_destroy(&sp->lock);
    pthread_cond_destroy(&sp->condition);
}

//waits until semaphore is available
void procure(semaphore *sp){
    pthread_mutex_lock(&sp->lock);
    while(sp->vacancy <= 0){
        pthread_cond_wait(&sp->condition, &sp->lock);
    }
    sp->vacancy--;
    pthread_mutex_unlock(&sp->lock);
}

//increments vacancy value signalling that a position has been freed
void vacate(semaphore *sp){
    pthread_mutex_lock(&sp->lock);
    sp->vacancy++;
    pthread_cond_signal(&sp->condition);
    pthread_mutex_unlock(&sp->lock);
}

没有线程似乎正在执行

0 个答案: