Question

我正在做一个生产者 - 一个消费者问题，在c中有两个线程。我是使用共享链接列表完成的，其中生产者放置了一些东西，而消费者从同一个列表中获取它。我必须使用2个值N和B运行我的代码（N是要传输的数据的大小，B是共享链表的最大大小）。（./thread-a1 N B）此代码适用于小值。但是，对于N = 20,000和B = 16，它给出了分段故障：11 我无法弄清楚为什么会这样。请帮忙

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

struct job
{
    int data;
    struct job* next;
};

struct job* head;
int maxSize;
int n;
pthread_mutex_t m = PTHREAD_MUTEX_INITIALIZER;

int getCount()
{
    int count = 0;
    struct job* p = head;
    while(p != NULL)
    {
        p = p -> next;
        count++;
    }
    return count;
}

void Insert(int x)
{

    struct job* temp = (struct job*)malloc(sizeof(struct job));
    temp -> data = x;
    if (head == NULL)
    {
        temp -> next = NULL;
    }
    else
    {
        temp -> next = head;
    }
    head = temp;
}

void Delete()
{

    struct job *toDelete, *secondLastNode;

    if(head == NULL)
    {

    }
    else
    {
        toDelete = head;
        secondLastNode = head;


        while(toDelete->next != NULL)
        {

            secondLastNode = toDelete;
            toDelete = toDelete->next;
        }
        printf("%d, ", toDelete -> data);

        if(toDelete == head)
        {
            free(toDelete);
            head = NULL;
        }
        else
        {
            secondLastNode->next = NULL;
            free(toDelete);
        }

    }
}

void* producer(void* arg)
{
    pthread_mutex_lock(&m);
    head = NULL; 

    int i;
    for (i = 0; i<n; i++)
    {

        while(getCount() >= maxSize)
        {
            pthread_mutex_unlock(&m);
        }
        Insert(i);
    }

    return NULL;
}

void* consumer(void* arg)
{
    pthread_mutex_lock(&m);
    int i;
    for (i=0; i<n; i++)
    {
        while(getCount() <= 0)
        {
            pthread_mutex_unlock(&m);   
        }
        Delete();
    }


    return NULL;
}

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

    struct timeval start_init, end_init;
    gettimeofday(&start_init, NULL);
    n = atoi(argv[1]);
    maxSize = atoi(argv[2]);

    pthread_t thread1;
    pthread_t thread2;
    gettimeofday(&end_init, NULL);
    printf("Time elapsed for initialization is: %ld\n", 
        (long)(end_init.tv_sec*1000000 + end_init.tv_usec) -    (start_init.tv_sec*1000000 + start_init.tv_usec));

    struct timeval start_trans, end_trans;
    gettimeofday(&start_trans, NULL);
    pthread_create(&thread1, NULL, &producer, NULL);
    pthread_create(&thread2, NULL, &consumer, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);
    gettimeofday(&end_trans, NULL);
    printf("Time elapsed for transmission is: %ld\n", 
        (long)(end_trans.tv_sec*1000000 + end_trans.tv_usec) - (start_trans.tv_sec*1000000 + start_trans.tv_usec));


    return 0;
}

Answer 1

您需要重温锁定;你只能在每个制作人的开头获得锁。消费者，从那时起只能解锁它们（反复！），意味着不再发生进一步的同步。程序运行的时间越长，这种缺乏同步的可能性就会越大。

Answer 2

我认为你的锁定应该是：

void* producer(void* arg)
{
    int i;
    for (i = 0; i<n; i++)
    {
        pthread_mutex_lock(&m);
        while(getCount() >= maxSize)
        {
            pthread_mutex_unlock(&m);   // allow consumer to acquire lock
            pthread_mutex_lock(&m);     // re-acquire lock
        }
        Insert(i);
        pthread_mutex_lock(&m);
    }
    return NULL;
}

void* consumer(void* arg)
{
    int i;
    for (i=0; i<n; i++)
    {
        pthread_mutex_lock(&m);
        while(getCount() <= 0)
        {
            pthread_mutex_unlock(&m);   // allow producer to acquire lock  
            pthread_mutex_lock(&m);     // re-acquire lock
        }
        Delete();
        pthread_mutex_lock(&m);
    }
    return NULL;
}

请注意，所有操作（包括getCount）必须在获取锁定的情况下完成。（还考虑用全局变量替换getCount;仅在锁定时对其进行操作。）

生产者 - 消费者c - 更大值的分割错误

2 个答案: