Unexpected results printing array of int pointers in C - c

Question

I have a simple C program which uses a varying number of pthreads to find the first N prime numbers, adding candidates found to be prime to an array. The array is passed as an arg to each thread, with each thread executing nearly all of its code in a critical section. I have no issue with the prime checking, and the printing to screen of prime numbers and the result_number variable as they are found works. However, when N primes are found, and the array is printed, I find that (roughly) every second time the program executes, some (variably from 1 to 5) of the early prime number array elements (generally restricted to those < 17) are printed out as extremely large or negative numbers, with the majority of primes printing fine. Only the code of the thread function is below (not checkPrime or main), as everything else seems to work fine.
Also, if the program is executed with a single thread (i.e. no sharing of the array between multiple threads for updating), this peculiarity never occurs.
result_number, candidate, N are all global vars.
void *primeNums(void *arg) {
pthread_mutex_lock(&mutex);
int *array = (int *) arg;
int is_prime = 0;
int j = 0;
while (result_number <= N) {
candidate++;
is_prime = checkPrime(candidate);
if (is_prime == 1) {
array[result_number] = candidate;
if (result_number == N) {
while (j < N) {
printf("%d\n", array[j]);
j++;
}
}
/* Test verification output; always accurate */
printf("Result number: %d = %d\n", result_number, candidate);
result_number++;
}
}
pthread_mutex_unlock(&mutex);
}
I genuinely do not believe other Qs cover this, as I have looked (and would have preferred finding an answer to writing my own question). There is a chance that I am not searching properly, admittedly.
EDIT: Example unwanted output:
-386877696
3
-395270400
32605
11
13
...
Continues on fine from here.

Answer 1

I have a hunch that if, instead of passing in array and using the global result_number, you pass in array + result_number and loop on a local variable: i = 0; while(i < N) {...}, you may solve your problem. (assuming array + result_number + N - 1 doesn't go out of bounds).
The problem with using global variables to hold the range information for each thread is that the thread function primeNums() modifies some of them. So if you start your first thread (thread #1) with result_number set to the start of the range you want thread #1 to process, thread #1 will keep changing its value while you reset it to give to thread #2. So thread #2 won't be processing the range you want it to process.
I assume you want each thread to process a separate range of indexes in your array? Currently you are passing a pointer to the beginning of the array to the function and using a global variable to hold the index into the array of the chunk you want to have processed by that thread.
To avoid using that global index all you have to do is pass a pointer to an offset into the middle of your array where you want processing to begin. So rather than pass in the value that points to the beginning element (array) pass in a value that points to the element you want to start processing from (array + result_number).
If you do that, inside your function primeNums() it acts as if the pointer you passed in is the beginning of an array (even though its somewhere in the middle) and you can run your loop from 0 to N because you have already added result_number before you called the function.
Having said all that I suspect you are still not going to be able to process this array in parallel (if that's is indeed what you are trying to do) because each thread relies on the candidate being set to the largest value from the previous thread...
To protect 'candidate` from being simultaneously changed by the code that launches the other threads (if you do that) you can take a copy of that variable after you synchronize on your mutex (lock). But, to be honest, I am not sure if this algorithm is going to let you parallelise this processing.