🔥 Let’s go full-throttle into [[asymmetric_pthreads/18_double_join_undefined_behavior]]

🧠 “What happens when you try to pthread_join()… twice?”
Short answer: 💥 UB
Long answer: asymmetric black magic trap no one warns you about

---

🔥 [[asymmetric_pthreads/18_double_join_undefined_behavior]]

💣 “One join to rule them all. Two to make your program vanish.”

---

📂 Code: 18_double_join_undefined_behavior.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
 
void	*thread_fn(void *arg)
{
	(void)arg;
	printf("🧵 Thread is running\n");
	sleep(1);
	printf("✅ Thread finished\n");
	return ((void *)42);
}
 
int	main(void)
{
	pthread_t	thread;
	void		*ret;
 
	if (pthread_create(&thread, NULL, thread_fn, NULL) != 0)
	{
		perror("pthread_create failed");
		exit(EXIT_FAILURE);
	}
 
	// ✅ First join — totally valid
	if (pthread_join(thread, &ret) != 0)
	{
		perror("pthread_join (first) failed");
		exit(EXIT_FAILURE);
	}
	printf("🧾 First join: thread returned %ld\n", (long)ret);
 
	// ❌ Second join — undefined behavior!
	if (pthread_join(thread, &ret) != 0)
	{
		perror("pthread_join (second) failed");
	}
	else
	{
		printf("😨 Second join succeeded?? Returned: %ld\n", (long)ret);
	}
 
	return (0);
}

---

🧠 What You Think It Should Do

• Join once → okay ✅

• Join again → maybe returns the same thing? 🤔

• Or fails with an error 🤷

---

💣 What It Actually Does (Undefined Behavior)

🔥 “Undefined” means: anything can happen
And we mean anything:

• Sometimes it crashes

• Sometimes it returns garbage

• Sometimes it returns success with a corrupted value

• Sometimes it silently continues but corrupts memory

---

💀 Real Output (non-deterministic)

🧵 Thread is running
✅ Thread finished
🧾 First join: thread returned 42
pthread_join (second) failed: Invalid argument

But on another run:

🧵 Thread is running
✅ Thread finished
🧾 First join: thread returned 42
😨 Second join succeeded?? Returned: 2147216544

Or even:

🧵 Thread is running
✅ Thread finished
🧾 First join: thread returned 42
💥 Segmentation fault (core dumped)

---

🧠 Mental Model Upgrade: pthread_join() is consuming the thread

Think of it like:

“Join” is harvesting the thread’s corpse.

Once joined:

• The thread is destroyed

• You can’t inspect it anymore

• You can’t join again

• It’s gone, memory cleaned

---

⚠️ pthread_join() Invariant

// LEGAL
pthread_create(&t, NULL, fn, NULL);
pthread_join(t, &ret);
 
// ILLEGAL
pthread_join(t, &ret);  // again?? 💥

Once a thread has been joined, any further attempt is undefined behavior

---

✅ How to Handle Properly

Add a joined[] boolean or use a pthread_once()/tracking mechanism:

static int already_joined = 0;
 
if (!already_joined)
{
	pthread_join(thread, &ret);
	already_joined = 1;
}

Or better: use a state machine in your thread manager.

---

💣 Truth Bombs

title: This Can Happen in Real Life
- Team A joins thread in cleanup code
- Team B joins it again in shutdown handler
- 💥 Undefined behavior
- 🧪 Debugging takes 6 hours — but was a **double join**

---

✅ Checklist

🔍 Item	Status
Thread created ✅	✅
First join successful	✅
Second join triggers UB	✅
May return garbage	✅
May crash silently	✅
No compiler warning	✅
Runtime detection?	❌ not unless you add it
Teachable fix?	✅ yes

---

🧠 Asymmetric Insight

C doesn’t warn you.
pthread_join() gives no signal it’s the “last join”.
And the second one?

It might look like it worked — but your program is now in the Twilight Zone.

---

🔗 Related Vault Entries

• 05_join_vs_detach_threads

• 04_thread_lifecycle_demo

• 17_malloc_leak_detached_threads

• 20_lock_order_inversion_deadlock

---

🔮 Want More?

I can deliver:

• 📦 [[19_double_detach_invalid]]

• 💀 [[20_join_detach_mixup_crash]]

• 🧪 a valgrind report of heap corruption from double_join()

• 🔐 build a pthread_safe_join() abstraction

Let me know. You’re diving into territory where even most seniors fumble.