Is data shared between threads always updated? - c

Question

the following sample code shares the global variable "unit" between two threads. The struct is not marked volatile and I also don't use any memory barriers / mutex when accessing it's members.
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <stdbool.h>
#include <time.h>
#include <semaphore.h>
struct unit
{
int data;
bool initialized:1;
};
static struct unit unit;
static sem_t semaphore;
void *thread1(void *arg)
{
(void)arg;
if (!unit.initialized)
{
unit.data = 5;
unit.initialized = true;
}
return NULL;
}
void *thread2(void *arg)
{
(void)arg;
struct timespec ts = { .tv_sec = 1 };
while (!unit.initialized)
{
(void)clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);
}
unit.data = unit.data * 2;
return NULL;
}
static void signal_handler(int signal)
{
(void)signal;
(void)sem_post(&semaphore);
}
int main(void)
{
pthread_t t1;
pthread_t t2;
struct sigaction sa = { 0 };
sigemptyset(&sa.sa_mask);
sa.sa_handler = signal_handler;
(void)sigaction(SIGINT, &sa, NULL);
(void)sigaction(SIGTERM, &sa, NULL);
(void)sem_init(&semaphore, 0, 0);
(void)pthread_create(&t2, NULL, thread2, NULL);
(void)pthread_create(&t1, NULL, thread1, NULL);
(void)sem_wait(&semaphore);
printf("unit.data = %d\n", unit.data);
(void)pthread_join(t1, NULL);
(void)pthread_join(t2, NULL);
(void)sem_destroy(&semaphore);
return 0;
}
I compiled the code with and without optimization. It worked as intended in both situations, printing unit.data = 10 on the terminal.
gcc -Wall -Wextra main.c -lrt -o prog
//and
gcc -O3 -Wall -Wextra main.c -lrt -o prog
Is it guaranteed that the compiler won't optimize the code in thread2 to something like while(!unit.initialized) to while(!0) or unit.data = unit.data * 2; to unit.data = 0 * 2; because I don't use mutex / volatile? I ask because in code like below, I encountered that the loop will run forever if I use optimizations and don't specify the stop variable with volatile.
#include <signal.h>
static sig_atomic_t stop;
void signal_handler(int signal)
{
stop = 1;
}
int main(void)
{
//setup signal handler
while (!stop)
{
//do something
}
return 0;
}
So is data shared between threads at runtime always updated in the end? I am aware that not using mutexes will probably cause race conditions.