Кроме того, вы должны быть свободны () со всеми этими локальными NODE *, возможно, в цикле join ().

ема: я создал связанный список дочерних потоков TIDS и хочу дождаться завершения всех дочерних потоков, прежде чем продолжить основной поток. В основном у меня есть обратный путь в каталогах (каталог определяется членами данногоstruct). Каждый раз, когда я вижу каталог или файл, я создаю новый поток и помещаю егоthreadID в связанный список. Однако, когда я пересекаю связанный список и звонюpthread_join Я получаю ошибку сегментации (ядро сброшено) - я не могу понять, почему. Я верю в то, что, возможно, связано с состоянием гонки, но я не уверен. Когда я удаляюpthread_join Я больше не segfault, однако я не получаю полный обход каталогов внутри каталогов.

Программа:

void *handy(void *arguments)
{
    static pthread_t threadA;
    threadA=pthread_self();
    handarg *thestruct=(handarg*)arguments; 
    DIR *dp=opendir(thestruct->directory);  
    DIR *outExist=opendir(thestruct->outputdirectory);
    if(outExist==NULL)
    {
        if((thestruct->outputdirectory = ""))
        {
            ;
        }
        else
        {
            printf("The outputdirectory doesnt exist, program terminated\n");
            exit(1);
        }
    }

    struct dirent *entry;  // has two important members (d-type)-tells me if its a directory (d-name) tells me current file name
    if(dp==NULL)
    {
        printf("directory doesnt exist: %s\n", thestruct->directory);
        exit(1);
    }
    NODE *head=NULL; //linked list
    NODE *ptr=(NODE*)malloc(sizeof(NODE));//node POINTER
    int count;

    while((entry=readdir(dp))!=NULL)
    {
        if(strcmp(entry->d_name,"..")==0||strcmp(entry->d_name,".")==0)
        {
            continue;
        }

        if((entry->d_type==DT_DIR))
        {
            unsigned int const sz1 = strlen(thestruct->directory);
            unsigned int const sz2 = strlen(entry->d_name);

            char *dnewname=(char *)malloc((sz1+sz2+2)*sizeof(char));

            memcpy(dnewname,thestruct->directory,sz1);
            memcpy(dnewname+sz1,"/",sizeof(char));
            memcpy(dnewname+sz1+1,entry->d_name,sz2);
            dnewname[strlen(dnewname)]='\0';

            pthread_t tid;

            handarg *current=(handarg*)malloc(sizeof(handarg));//malloc
            current->directory=dnewname;
            current->outputdirectory=thestruct->outputdirectory;
            current->column=thestruct->column;
            pthread_create(&tid,NULL,&handy,current);

            threadA=pthread_self();
            printf("The Filepath is: %s, The Parent TID = %ld, THE peer TID = %ld\n",dnewname, threadA, tid);
            NODE *newNode=(NODE*)malloc(sizeof(NODE));
            newNode->peerTid=tid;
            newNode->next=NULL;
            if(head==NULL)
            {
                head=newNode;
                ptr=n,ewNode;
                //printf("THE TID I PUT INTO THIS NODE IS FUCK YOU FUCK YOU FUCK YOU %ld\n",ptr->peerTid);
            }
            else
            {
                ptr->next=newNode;
                ptr=newNode;
                //printf("THE TID I PUT INTO THIS NODE IS YAMAKA %ld\n",ptr->peerTid);

            }
            //and call wait on each of tids  for loop only exit if last tid is waiting on 
        }

        if((entry->d_type==DT_REG))
        {
            char *filename = entry->d_name;
            int len = strlen(filename);
            const char *last_four = &filename[len-4]; //need to account for if filename is less than 4 characters   
            if(strcmp(last_four,".csv")==0)
            {
                char *dnewname = (char*)malloc(sizeof(char)*(strlen(thestruct->directory)+strlen(entry->d_name)+2));
                char *slash = (char*)malloc(sizeof(char));
                strcpy(dnewname, thestruct->directory);
                strcpy(slash, "/");
                strcat(dnewname, slash);
                strcat(dnewname, entry->d_name);
                dnewname[strlen(dnewname)]='\0';

                pthread_t tid;
                handarg *current=(handarg*)malloc(sizeof(handarg));
                current->directory=dnewname;
                current->outputdirectory=thestruct->outputdirectory;
                current->column=thestruct->column;
                pthread_create(&tid,NULL,&handleFile,current);
                //count++;
                threadA=pthread_self();
                printf("The Filepath is: %s, The Parent TID = %ld, THE peer TID = %ld\n",dnewname, threadA, tid);
                NODE *newNode=(NODE*)malloc(sizeof(NODE));
                newNode->peerTid=tid;
                newNode->next=NULL;
                if(head==NULL)
                {
                    head=newNode;
                    ptr=newNode;

                //printf("THE TID I PUT INTO THIS NODE IS %ld\n",ptr->peerTid);
                }
                else
                {
                    ptr->next=newNode;
                    ptr=newNode;
                    //printf("THE TID I PUT INTO THIS NODE IS %ld\n",ptr->peerTid);
                }
            }
        }   
    }

    printf("the thread produced %d threads\n", count);
    if(head==NULL)      
    {
        printf("no child threads\n");
    }
    ptr=head;
    printf("\nthese are the items from the linkedlist\n\n");
    while (ptr!=NULL)
    {
        printf("%ld\n",ptr->peerTid);           
        ptr=ptr->next;
    }
    printf("\n");
    ptr=head;
    while (ptr!=NULL)
    {
        threadA=pthread_self();
        printf("THE PEER THREAD %ld --------I AM THE THREAD %ld\n",ptr->peerTid,threadA);
        pthread_join(ptr->peerTid,NULL);
        printf("got here");
        ptr=ptr->next;
    }
    printf("\n");
    //return NULL;
}
 Martin James29 нояб. 2017 г., 06:03
Кроме того, вы должны быть свободны () со всеми этими локальными NODE *, возможно, в цикле join ().
 Martin James29 нояб. 2017 г., 05:56
Ой, что это: 'static pthread_t threadA;' и 'threadA = pthread_self ();' везде? Я надеюсь, что это некритическая помощь для отладки ... Всякий раз, когда я вижу "статичный", я начинаю нервничать
 Martin James29 нояб. 2017 г., 06:01
Где-то вы должны быть свободны () от всех тех неправильных размещений, которые были предоставлены «родительским» потоком через handarg *
 Martin James29 нояб. 2017 г., 05:45
Ну, во-первых, подумайте об этом как о способе добавления терминатора NUL к массиву символов :: 'dnewname [strlen (dnewname)] =' \ 0 ';'. Вы видите проблему?
 Martin James29 нояб. 2017 г., 05:51
Вы до сих пор так хорошо работали, если бы вы только что скопировали NUL с конца имени, например: 'memcpy (dnewname + sz1 + 1, entry-> d_name, sz2 + 1);', вы были бы в порядке , Думаю. Тем не менее, я бы использовал strcpy () для добавления dir и strcat () для добавления косой черты и имени, чтобы избежать явной загрузки NUL в конце.

Ответы на вопрос(0)

Ваш ответ на вопрос