Why is the value of this global variable different between threads?

In this program I declare some global variables and I create several threads that interact with them.

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <getopt.h>
#include <fcntl.h>
#include <assert.h>
#include <pthread.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/sysinfo.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/syscall.h>
typedef struct zip_seg zip_seg_t;
typedef struct stat stat_t;
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
char **file_ptr;
char *segment_ptr;
stat_t *stat_buf;
struct zip_seg {
char *data;
size_t size;
};
int index_cur_file = 0, index_cur_segment = 0;
int n_segments;
int total_segments_cur_file = 0;
int segment_size = 100;
zip_seg_t *zip_list;
void* segment_handler() {	
int size;
pid_t x = syscall(__NR_gettid);
//printf("ID %d getting in...\n", x);
while(1) {
pthread_mutex_lock(&lock);
if(index_cur_segment >= n_segments) {
pthread_mutex_unlock(&lock);
break;
}
if((total_segments_cur_file * segment_size) < stat_buf[index_cur_file].st_size) {
size = stat_buf[index_cur_file].st_size - (total_segments_cur_file * segment_size);
index_cur_file++;
total_segments_cur_file = 0;
segment_ptr = file_ptr[index_cur_file];
}
else {
size = segment_size;
total_segments_cur_file++;
segment_ptr += size;
}
int i = index_cur_segment++;
pthread_mutex_unlock(&lock);
zip_list[i] = wzip(segment_ptr, size);
//index_cur_segment++;
}
//printf("ID %d getting out...\n", x);
}
int main(int argc, char *argv[])
{
char c;
int dummy;
while((c = getopt(argc, argv, "s:")) != -1) {
switch(c) {
case 's':
dummy = atoi(optarg);
break;
}
}
int n_segments = 0;
int n_files = argc - optind;
int n_threads = get_nprocs();
int fd[n_files];
file_ptr = malloc(n_files * sizeof(*file_ptr));
stat_buf = malloc(n_files * sizeof(*stat_buf));
pthread_t *workers = malloc(n_threads * sizeof(*workers));
if(!file_ptr || !stat_buf || !workers) {
printf("Memory allocation error.\n");
return -1;
}
for (int i = 0; i < n_files; i++)
{
char *file_name = argv[optind];
fd[i] = open(file_name, O_RDONLY);
fstat(fd[i], &stat_buf[i]);
file_ptr[i] = mmap(NULL, stat_buf[i].st_size, PROT_READ, MAP_PRIVATE, fd[i], 0);
int extra_segment = (segment_size % stat_buf[i].st_size) > 0 ? 1 : 0;
n_segments += (stat_buf[i].st_size / segment_size) + extra_segment;
}
zip_list = malloc(n_segments * sizeof(*zip_list));
if(!zip_list) {
printf("Memory allocation error.\n");
return -1;
}
for (int i = 0; i < n_threads; ++i)
{
pthread_create(&workers[i], NULL, segment_handler, NULL);		
}
for (int i = 0; i < n_threads; ++i)
{		
pthread_join(workers[i], NULL);
}
join();
for (int i = 0; i < n_files; i++)
{
munmap(file_ptr[i], stat_buf[i].st_size);
}
free(file_ptr);
free(stat_buf);
free(workers);
free(zip_list);
return 0;
}

The one that is causing problems is n_segments, to which I assign a value before starting the child threads. The problem is that in segment_handler when I check it's value in these threads is 0, which is not what was assigned in the main thread.


If global variables are supposed to be shared across threads, why is the value of n_segments different in this case?

I had two variables named n_segment. One was global, the other was local to main.

This assignment only had effect on the local one in main.

n_segments += (stat_buf[i].st_size / segment_size) + extra_segment;

The global n_segment was always 0.

> If global variables are supposed to be shared across threads...

There's two things wrong with that statement:

(1) Get rid of the word "global." Global variables are no more special than any other kind of variable when it comes to sharing between threads.

(2) Variables are not automatically shared between threads. If you want one thread in your program to see a value that was written to some variable by some other thread, then your program must take explicit action to synchronize the threads.

The simplest way* to synchronize them is to use a mutex. If you have some collection of variables; v, w, x, and y that you want to share between the threads, then things will work out pretty much the way you want if you also have some mutex, m, and you never let any of your threads access v, w, x, or y except when the thread has m locked.

If you obey that rule, then whenever some thread A locks the mutex, it will see the same values for the variables that they had in thread B at the moment when thread B released the mutex where thread B is whichever thread was the last one to release it.

Sharing variables without any synchronization leads to Undefined Behavior (a.k.a., "UB"). You don't want UB in your program. Ever. If your program has UB, then there's simply no point in even talking about what else might be wrong with it or, about possible reasons for why it behaves the way it does.

* There are other ways to synchronize variable values across threads, but using them correctly is more of an advanced topic. Learn to do it with mutexes first.