为什么我的线程函数中的局部变量会被其他线程中断？

Question

我创建了几个线程并行执行以下线程函数，线程函数的输入参数是一个整数。 不同的线程得到不同的整数。在 thread 函数中，我定义了一个局部变量 thread_index 来接受这个将在计算中使用的整数。我的问题是这些局部变量会与其他线程的变量混淆，我认为这不应该发生。事实上，每个线程函数中都有一个循环，第一次尝试循环对所有线程都可以，但之后，局部变量“thread_index”就搞砸了。我使用信号量屏障来保护计算过程，但这不应该是我当前的问题。 所有未声明的变量都是在主函数中预定义的。我不明白为什么局部变量会被其他人打断。

以下是线程创建过程，其中N为整数，控制线程数，pthread_t t[N/2]。 for(long thread_index = 0;thread_index

void *exchange_swap(void *ptharg){
    // cout<<"num_phases "<<num_phases<<endl;
    long thread_index = (long) ptharg;
    for (phase = 1; phase <= num_phases;)
    {

        int num_groups = pow(2, (phase-1) % num_stages);
        // cout<<num_groups<<endl;
        int group_size = N / num_groups;
        int gindex = (thread_index) / (group_size / 2);
        int mindex = (thread_index) % (group_size / 2);

        int group_start = gindex * group_size;
        int group_end = (gindex + 1) * group_size - 1;

        int data1 = group_start + mindex;
        int data2 = group_end - mindex;
        // swap
        int temp;
        if (sortArray[data1]>sortArray[data2])
        {
            temp = sortArray[data1];
            sortArray[data1] = sortArray[data2];
            sortArray[data2] = temp;
        }

        sem_wait(&s);
        cout<<"Thread "<<thread_index+1<<" finished stage "<<(phase - 1) / num_stages + 1<<" phase "<<(phase-1) % num_stages + 1<<endl;
        finished_job++;
        if (finished_job == N/2){
            finished_job = 0;
            phase++;
            for (int i = 0; i < N; ++i)
            {
                cout<<sortArray[i]<<" ";
            }
            cout<<endl;
            sem_post(&barrier);
        }
        sem_post(&s);
        sem_wait(&barrier);
        sem_post(&barrier);
    }
    return NULL;
}

Answer 1

使用std::thread 传递值会更容易、更“自然”：

std::vector<std::thread> threads(N / 2);  // Create a vector of N/2 threads

// For each thread in the vector
for (unsigned thread_index = 0; thread_index < threads.size(); ++thread_index)
{
    // Create the thread
    threads[thread_index] = std::thread(exchange_swap, thread_index);
}

// Possibly do other work...

// Again for each thread (thread index no longer needed)
for (auto& thread : threads)
{
    // Wait for it to end
    thread.join();
}

那么线程函数就是一个简单的函数，按值取索引，不返回值：

void exchange_swap(unsigned thread_index){
    ...
}

---

正如我在评论中所说，在这种情况下，像你一样（通过强制转换）传递值是可以的。