Почему pthread_join не работает на последней итерации (что приводит к ошибке сегментации)?

Ваша main функция запускается:

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

    pthread_t *threadID = malloc(nThreads * sizeof(pthread_t));

Поскольку nThreads - глобальная переменная без явного инициализатора, ее значение равно нулю - вы не выделили память, которую можно законно использовать. Доступ к этой памяти приводит к неопределенному поведению.

Отложите это выделение памяти до тех пор, пока не узнаете, сколько потоков вам понадобится.

Неопределенное поведение означает, что может произойти все, что угодно, в том числе кажется работающим до тех пор, пока оно больше не перестанет работать.

Вам также необходимо переписать код присоединения к потоку как цикл, чтобы он соответствовал циклу, который создает потоки.

Есть МНОГО проблем с опубликованным кодом.

Вместо того, чтобы перечислять их все, я просто представлю рабочую версию кода. Вы можете выполнить сравнение, чтобы увидеть изменения.

Примечание. Я предоставил некоторые значения параметров по умолчанию, если пользователь не указал параметры командной строки. В противном случае деление на nIterations приведет к исключению "деление на 0".

Я использовал функцию массива переменной длины языка C для объявления массива pThread_t вместо использования динамического распределения памяти.

В общем, включение файлов заголовков, содержимое которых не используется, является плохой практикой программирования.

Обратите внимание, что в функции: add() это 1) обновление значения общего счетчика не защищено pthread_mutex_t, поэтому счетчик может / будет поврежден другими потоками. Также вызов sched_yield() между обновлением локальной переменной sum и обновлением глобальной counter означает, что результаты других потоков могут / будут уничтожены.

#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
//#include <unistd.h>
#include <pthread.h>
//#include <stdint.h>
//#include <errno.h>
//#include <string.h>
#include <getopt.h>
#include <time.h>

int opt_threads;
int opt_iterations;
long nThreads;
long nIterations;
int opt_yield;
long long counter;

void add(long long *pointer, long long value) 
{
    long long sum = *pointer + value;
    if (opt_yield)
    {
        sched_yield();
    }
    *pointer = sum;
}

void *thread_worker(void * arg) 
{
    void(arg);
    //long i;
    for ( long i=0; i<nIterations; i++) 
    {
        add(&counter, 1);
        add(&counter, -1);
    }

    //return arg;
    pthread_exit( NULL );
}

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

    static struct option long_options[] =
    {
        {"threads", required_argument, 0, 't'},
        {"iterations", required_argument, 0, 'i'},
        {"yield", no_argument, 0, 'y'},
        {0,0,0,0}
    };

    while ( (c = getopt_long(argc, argv, "", long_options, NULL)) != -1 )
    {
        switch(c) 
        {
            case 't':
                opt_threads = 1;
                nThreads = atoi(optarg);
                break;

            case 'i':
                opt_iterations = 1;
                nIterations = atoi(optarg);
                break;

            case 'y':
                opt_yield = 1;
                break;

            default:
                fprintf(stderr, "Bad argument!\n");
                exit( EXIT_FAILURE );
                break;
        }
    }

    if( nIterations == 0 )
    {
        nIterations = 1;
        opt_iterations = 1;
    }

    if( nThreads == 0 )
    {
        nThreads = 5;
        opt_threads = 1;
    }

    pthread_t threadID[ nThreads ];

    counter = 0;
    struct timespec start, finish;
    //int i;

    //start clock
    clock_gettime(CLOCK_MONOTONIC, &start);

    //create
    for ( int i=0; i < nThreads; i++) 
    {
        if( pthread_create(&threadID[i], NULL, &thread_worker, NULL) < 0 )
        {
            perror( "pthread_create failed" );
            exit( EXIT_FAILURE );
        }
        printf("Created thread[%d]\n", i);
    }

    for( int i = 0; i<nThreads; i++ )
    {
        pthread_join(threadID[i], NULL);
    }

    printf("about to end clock\n");
    //finish clock
    clock_gettime(CLOCK_MONOTONIC, &finish);

    printf("finished clock\n");

    //long seconds = finish.tv_sec - start.tv_sec;
    //long ns = finish.tv_nsec - start.tv_nsec;
    //long run_Time = seconds * 1000000000L + ns;
    long nOperations = nThreads * nIterations * 2;
    //long avgOperations = run_Time / nOperations;
    long run_duration = 1000000000L * (finish.tv_sec - start.tv_sec) + finish.tv_nsec - start.tv_nsec;

    //Print
    if (opt_yield == 0)
    fprintf(stdout, "add-none, %ld, %ld, %ld, %ld, %ld, %lld\n", 
        nThreads, 
        nIterations, 
        nOperations, 
        run_duration, 
        run_duration/nOperations, 
        counter);

    else 
    {
        fprintf(stdout, "add-yield-none, %ld, %ld, %ld, %ld, %ld, %lld\n",
            nThreads, 
            nIterations, 
            nOperations, 
            run_duration, 
            run_duration/nOperations, 
            counter);
    }

    exit(0);
}

Приведенный выше код без параметров командной строки дает следующий результат.

Created thread[0]
Created thread[1]
Created thread[2]
Created thread[3]
Created thread[4]
about to end clock
finished clock
add-none, 5, 1, 10, 3544641, 354464, 0