不知道互斥锁是否启动？

Question

I'm working on a college assignment and have been tasked with showing a basic mutex lock example. I've never worked with threads in any form, so I'm a total beginner working with POSIX threads in C++.

What I'm trying to get the program to do is create 1000 threads that increment a global integer by 1000.

#include        <iostream>
#include    <stdlib.h>
#include    <pthread.h>
#include    <sys/types.h>
#include    <unistd.h>
#include    <thread>

pthread_t   threadArr[1000];
pthread_mutex_t lock;

// Global int to increment
int numberToInc = 0;

void* incByTwo(void*)
{
    pthread_mutex_lock(&lock);
    for(int j = 0; j < 1000; j++){
        numberToInc += 1;
    }
    pthread_mutex_unlock(&lock);
    return NULL;
}

int main()
{
    //Creates 1000 threads with incByTwo func
    for(int i = 0; i < 1000; i++){
        pthread_create(&threadArr[i], NULL, incByTwo, NULL);
    }


    std::cout << "\n" << numberToInc << "\n";

    

    return 0;
}

The following produces a series of different results, obviously because the threads are executing concurrently, right?

Now, I've gotten it to work correctly by inserting

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

After the thread creation loop, but then removing the mutex locks, it still works. I've been trying to piece out how pthread_join works but I'm a little lost. Any advice?

Answer 1

Sorted a way to show the mutex lock in action. So when I output the global var in the function, without mutex locks it has the potential to show the results out of order.

Running the number range with mutex locks, out looks like:

1000
2000
3000
... (etc)
10000

With mutex locks removed, the output can vary in the order.

Eg

1000
2000
4000
6000
3000
5000
7000
8000
9000
10000

While the final result of the three threads is correct, the sequence is out of order. In the context of this program it doesn't really matter but I'd imagine if it's passing inconsistently sequenced values it messes things up?

pthread_t   threadArr[10];
pthread_mutex_t lock;

int numberToInc = 0;


void* incByTwo(void*)
{

    pthread_mutex_lock(&lock);
    for(int j = 0; j < 1000; j++){
        numberToInc += 1;
    }

    std::cout << numberToInc << "\n";
    pthread_mutex_unlock(&lock); 
    return NULL;
}

int main()
{

    if (pthread_mutex_init(&lock, NULL) != 0)
    {
            printf("\n mutex init failed\n");
            return 1;
        }

    for(int i = 0; i < 10; i++){
        pthread_create(&threadArr[i], NULL, incByTwo, NULL);
    }
    
    pthread_join(threadArr[0], NULL);

    return 0;
}