pthread分配输出错误

我有一个赋值问题：

我在xyz空间中有一个10000点的数组坐标A和一个中心为0.5,0.5,0.5的起始立方体，每边有1个长度。立方体包含所有10k个点然后，立方体将分成8个相同的较小立方体，每个立方体将包含10k个点中的较小部分。

因此，主线程将生成8个线程，每个立方体一个，根据num_child找到每个立方体的中心（*见下面的解释），并计算它包含多少点。在每个线程中，我创建一个临时结构来进行计算，然后将该结构推送到全局向量。

（*例如，中心为0.5,0.5的二维长方体将分为4:a（0.25,0.25），b（0.75,0.25）、c（0.75,0.250）、b（0.750,0.75））

当我运行程序时，我得到的输出是"10000 240 240 240 240"，这是错误的。如果我在gdb中运行程序并逐步完成代码，结果是正确的。

有什么问题吗？如果你需要对代码的任何部分进行更多解释，请告诉我…

感谢您抽出时间

PS：编译时需要-std=c++11-pthread标志。我知道C++11有内置线程，但分配的重点是在pthreads中完成。

更新：我在代码中做了一些戳，发现所有的框都有相同的中心（0.75,0.75,0.75）。此外，我在gdb中的"case 0"上设置了一个断点，但它从未中断

#include <iostream>
#include <random>
#include <thread>
#include <vector>
#define N 10000
#define S 20
typedef struct Box{
    int level, child[8], n;
    float center[3];
}Box;
static double A[N][3]; //Coordinate array
std::vector<Box> box;
//initializing mutexes and a variable to hold the running threads
int running_threads;
pthread_mutex_t running_mutex = PTHREAD_MUTEX_INITIALIZER;
//arguments structer
 struct arg_struct{;
    int num_child,level;
};

void *create_child(void *arguments){
    Box temp;
    pthread_mutex_lock(&running_mutex);
    arg_struct *args=(arg_struct*)arguments;
    int num_child=args->num_child;
    temp.level=args->level;
    float akmi=1/pow(2,args->level);
    pthread_mutex_unlock(&running_mutex);
    float d=(0.5/pow(2,temp.level));
    switch (num_child){
    case 0:
        temp.center[0]=0.5-d;
        temp.center[1]=0.5-d;
        temp.center[2]=0.5-d;
        break;
    case 1:
        temp.center[0]=0.5+d;
        temp.center[1]=0.5-d;
        temp.center[2]=0.5-d;
        break;
    case 2:
        temp.center[0]=0.5-d;
        temp.center[1]=0.5+d;
        temp.center[2]=0.5-d;
        break;
    case 3:
        temp.center[0]=0.5+d;
        temp.center[1]=0.5+d;
        temp.center[2]=0.5-d;
        break;
    case 4:
        temp.center[0]=0.5-d;
        temp.center[1]=0.5-d;
        temp.center[2]=0.5+d;
        break;
    case 5:
        temp.center[0]=0.5+d;
        temp.center[1]=0.5-d;
        temp.center[2]=0.5+d;
        break;
    case 6:
        temp.center[0]=0.5-d;
        temp.center[1]=0.5+d;
        temp.center[2]=0.5+d;
        break;
    case 7:
        temp.center[0]=0.5+d;
        temp.center[1]=0.5+d;
        temp.center[2]=0.5+d;
        break;
    }
    int number=0;

    for(int i=0;i<N;i++){
        if ((A[i][0]>=(temp.center[0]-akmi/2)) && (A[i][0]<=(temp.center[0]+akmi/2))){
            if((A[i][1]>=temp.center[1]-akmi/2)&&(A[i][1]<=temp.center[1]+akmi/2)){
                if((A[i][2]>=temp.center[2]-akmi/2)&&(A[i][2]<=temp.center[2]+akmi/2)){
                        number++;
                    }
            }
        }
    }

    pthread_mutex_lock(&running_mutex);
    temp.n=number;
    box.push_back(temp);
    running_threads--;
    pthread_mutex_unlock(&running_mutex);
}
int main(){
    //Generate random A array
    const double pi = 3.14159265358979323846;
    std::default_random_engine rnd;
    std::uniform_real_distribution<double> dist(0.0, 1.0);
    for(int i=0; i<N; i++)
    {
        double z = dist(rnd);
        double t = (pi/2.0)*dist(rnd);
        double r = sqrt(1.0-z*z);
        A[i][0]=r*cos(t);
        A[i][1]=r*sin(t);
        A[i][2]=z;
    }
    std::cout<<"nCoordinates array completedn";
///////
    Box temp;
    arg_struct *args=new arg_struct;
    pthread_t threads[8];
    //Original Box
    temp.level=0;
    temp.n=N;
    temp.center[0]=0.5;
    temp.center[1]=0.5;
    temp.center[2]=0.5;
    box.push_back(temp);
    //Starting threads
    for (int i=0;i<8;i++){
        pthread_mutex_lock(&running_mutex);
        args->level=1;
        args->num_child=i;
        running_threads++;
        pthread_mutex_unlock(&running_mutex);
        pthread_create(&threads[i],NULL,create_child,(void*)args);
    }
    while(running_threads>0){
    }
    for (int i=0;i<9;i++){
        std::cout<<box[i].n<<"n";
    }
    return 0;}