Question

我通常不熟悉C，所以我有很多语法错误和引用问题。我写了prodcons.c，这是一个Struct，它将创建大小为50的有限缓冲区和一些辅助变量。在main中，我创建此数据结构的变量并对其进行初始化。我正在尝试接受任意数量的参数（例如，IE {1..1000}），然后说几千个参数，然后将其推入缓冲区，而与此同时，另一个C文件生产者c正在尝试从相同的缓冲区中弹出我通过线程调用与之共享。 PUSH和POP都具有互斥锁，以同时停止对关键部分的任何更改。生产者线程然后将初始化另一个数据结构，从其共享缓冲区中的main获取每个参数的素数，并与线程中的Consumer.c函数调用共享新的初始化数据结构。消费者只需打印数字及其主要因素。我相信我必须在所有文件中都包含#include prodcons.h才能使用其功能，但是如果我错了，请更正我。另外，我正在尝试创建BUSY WAITNG，主要和生产者都尝试通过while循环调用POP和PUSH到达关键部分，但这很可能是错误的。请帮助，建议，语法。一切。

老实说，我只是尝试编译代码，但是我的引用和指针以及C中共享文件和对数据结构的指针调用的任何正确方法均已关闭。我想我只需要进行很多更正。例如在使用结构指针时，我是否使用pc-> function（）或pc.function（）？这些小的语法错误使我陷入困境。我将由Consumer.h和Consumer.c共享所有内容，因为找出主要和生产者的问题，然后找出消费者。

'''prodcons.h
#include <pthread.h>
#define BUFFER_SIZE (50)

struct prodcons {
        int buffer[BUFFER_SIZE];
        int count;
        int top;
        int next;
        pthread_mutex_t count_lock;
};

void pc_init(struct prodcons *pc);
int pc_pop(struct prodcons *pc);
void pc_push(struct prodcons *pc, int val);
'''

'''prodcons.c

void pc_init(struct prodcons *pc)
{ 
        count = 0;
        top = 0;
        next = 0;
}

int pc_pop(struct prodcons *pc)
{
        int val;
        pthread_mutex_lock(&pc.count_lock);

        if (counter > top)
        {
                val = pc.buffer[count];
                pc.buffer[count] = 0;
                pc.count--;
        }

        pthread_mutex_unlock(&pc.count_lock);
        return val;
}

void pc_push(struct prodcons *pc, int val)
{
        pthread_mutex_lock(&pc.count_lock);

        if (count < BUFFER_SIZE)
        {
                pc.buffer[count] = val;
                pc.count++;
        }

        pthread_mutex_unlock(&pc.count_lock);
}



'''main.c file

#include <pthread.h>
#include <stdlib.h>
#include <math.h>
#include "producer.h"
#include "prodcons.h"

int main(int argc, char *argv[])

{
        int index = 1;
        int num;
        struct prodcons pc_nums;



        //pthread_t tid[argc - 1];
        pthread_t tid;
        pthread_attr_t attr;

        if (argc <  2) {
                fprintf(stderr, "usage: No arguments\n");
                return -1;
        }
        if (atoi(argv[1]) <= 0)
        {
                fprintf(stderr, "%d not > 0 or you must provide a positive integer.\n", atoi(argv[1]));
                return -1;
        }

        /*get the default attributes */
        pthread_attr_init(&attr);

        //init the data structure
        pc_init(&pc_nums);


        //create producer thread
        pthread_create(&tid, &attr, *producer, &pc_nums);

        while (index < argc)
        {
                num = atoi(argv[index]);
                pc_push(&pc_nums, num);
                index++;
        }
}

'''producer.h
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <math.h>
#include "consumer.h"


void factor2pc(struct prodcons *pc, int number);
void *producer(void *data);

'''producer.c
#include <math.h>
#include <pthread.h>

void factor2pc(struct prodcons *pc, int number) {

        pthread_t tid;
        pthread_attr_t attr;
        //int counter = 0;

        //Add original value to int* primeNumbers for return printing
        pc->pc_push(&pc, number);

        //Print twos that divide argument
        while (number % 2 == 0)
        {
                pc->pc_push(&pc, 2);
                number = number/2;
        }

        //Argument is odd. Check using i + 2
        for (int i = 3; i <= sqrt(number); i = i + 2)
        {
                while (number % i == 0)
                {
                        pc->pc_push(&pc, i);
                        number = number/i;
                }
        }

        //When n is a prime number greater than 2
        if (number > 2)
        {
                pc->pc_push(&pc, number);
        }

        //add -1 to end of number prime factors to sign
        pc->pc_push(&pc, number);
}

void *producer(void *data) {

        int number;
        struct prodcons primeNums;
        pc_init(&primeNums);

        //call consumer thread
        pthread_t tid;
        pthread_attr_t attr;
        pthread_create(&tid, attr, *consumer, &primeNums);

        while (data.count < BUFFER_SIZE)
        {
                number = data.pc_pop(data);
                factor2pc(&primeNums, number);
        }
}

我希望每个数字及其质数都输出。

2个绑定缓冲区与pthread调用，互斥锁和繁忙等待共享

0 个答案: