Thread Issues

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// How errno is typically implemented (conceptual)
// In <errno.h>, you'll often see something like:
 
// Old single-threaded model (WRONG for threads)
int errno;  // Would be shared - data race!
 
// Modern TLS model
// Option 1: Compiler-supported TLS
__thread int errno;  // Each thread gets its own errno
 
// Option 2: Function-based access (POSIX style)
// errno is actually a macro:
#define errno (*__errno_location())
 
// Where __errno_location returns a pointer to
// the current thread's errno value
int *__errno_location(void) {
    // Returns TLS pointer for current thread
    // Implementation uses architecture-specific TLS access
    return &__thread_local_errno;
}
 
// This is why code like:
//   if (result < 0) perror("error");
// Works correctly in multithreaded programs
 
// Each thread's path through the code sees its own errno
void *thread_func(void *arg) {
    int result = some_syscall();
    if (result < 0) {
        // errno here is THIS thread's errno
        // Other threads making concurrent calls don't affect it
        printf("This thread's error: %d (%s)\n", 
               errno, strerror(errno));
    }
    return NULL;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

#include <pthread.h>
#include <stdio.h>
 
// Static TLS variable - each thread has its own copy
static __thread int thread_counter = 0;
static __thread const char *thread_name = NULL;
 
// TLS with complex initialization
static __thread struct {
    int operations;
    double total_time;
    void *context;
} thread_stats = {0, 0.0, NULL};
 
void increment_counter(void) {
    // No synchronization needed!
    // Each thread accesses its own copy
    thread_counter++;
}
 
int get_counter(void) {
    return thread_counter;
}
 
void set_thread_name(const char *name) {
    thread_name = name;
}
 
void *worker_thread(void *arg) {
    int id = *(int *)arg;
    char name_buf[32];
    snprintf(name_buf, sizeof(name_buf), "Worker-%d", id);
    
    // Set this thread's name (thread-local)
    set_thread_name(name_buf);
    
    // Each thread has its own counter starting at 0
    for (int i = 0; i < 1000; i++) {
        increment_counter();
    }
    
    printf("Thread %s: counter = %d\n", thread_name, get_counter());
    
    return NULL;
}
 
int main() {
    pthread_t threads[4];
    int ids[4] = {0, 1, 2, 3};
    
    for (int i = 0; i < 4; i++) {
        pthread_create(&threads[i], NULL, worker_thread, &ids[i]);
    }
    
    // Main thread's TLS is separate
    set_thread_name("Main");
    increment_counter();
    printf("Thread %s: counter = %d\n", thread_name, get_counter());
    
    for (int i = 0; i < 4; i++) {
        pthread_join(threads[i], NULL);
    }
    
    // Output (order may vary):
    // Thread Main: counter = 1
    // Thread Worker-0: counter = 1000
    // Thread Worker-1: counter = 1000
    // Thread Worker-2: counter = 1000
    // Thread Worker-3: counter = 1000
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
// Key for thread-local buffer
static pthread_key_t buffer_key;
static pthread_once_t key_once = PTHREAD_ONCE_INIT;
 
// Destructor - called automatically when thread exits
void buffer_destructor(void *ptr) {
    printf("Thread exiting: freeing buffer %p\n", ptr);
    free(ptr);
}
 
// One-time initialization of the key
void make_key(void) {
    pthread_key_create(&buffer_key, buffer_destructor);
}
 
// Get this thread's buffer, creating if needed
char *get_thread_buffer(void) {
    // Ensure key is created (thread-safe, runs once across all threads)
    pthread_once(&key_once, make_key);
    
    // Get this thread's value
    char *buffer = pthread_getspecific(buffer_key);
    
    if (buffer == NULL) {
        // First access in this thread - allocate
        buffer = malloc(1024);
        if (buffer == NULL) return NULL;
        
        // Associate with this thread
        pthread_setspecific(buffer_key, buffer);
        
        printf("Thread %lu: allocated buffer %p\n",
               (unsigned long)pthread_self(), buffer);
    }
    
    return buffer;
}
 
void *worker(void *arg) {
    int id = *(int *)arg;
    
    // Get this thread's private buffer
    char *buf = get_thread_buffer();
    
    // Use the buffer - no synchronization needed!
    snprintf(buf, 1024, "Thread %d was here", id);
    printf("Buffer says: %s\n", buf);
    
    // When thread exits, destructor frees the buffer automatically
    return NULL;
}
 
int main() {
    pthread_t threads[3];
    int ids[3] = {1, 2, 3};
    
    for (int i = 0; i < 3; i++) {
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }
    
    for (int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }
    
    // Key can be deleted after all threads are done
    pthread_key_delete(buffer_key);
    
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// What the compiler generates for TLS access
// Source:
__thread int counter;
 
void increment() {
    counter++;
}
 
// Compiler output (x86-64, simplified):
// 
// increment:
//     mov  eax, fs:[counter@tpoff]   ; Load from FS-based TLS
//     add  eax, 1
//     mov  fs:[counter@tpoff], eax   ; Store back
//     ret
//
// Where @tpoff is the offset from the thread pointer (FS base)
 
// The fs: prefix accesses memory relative to the FS segment register
// which points to the current thread's TLS block
 
// Compare to global variable access:
int global_counter;
 
void increment_global() {
    global_counter++;
}
 
// Compiler output for global (simplified):
//
// increment_global:
//     mov  eax, [rip + global_counter]  ; RIP-relative addressing
//     add  eax, 1
//     mov  [rip + global_counter], eax
//     ret
 
// The difference is minimal - just the segment override
// TLS access is nearly as fast as global access

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

#include <iostream>
#include <thread>
#include <string>
 
// Thread-local with constructor/destructor
class ThreadContext {
public:
    std::string thread_name;
    int operation_count = 0;
    
    ThreadContext() {
        std::cout << "ThreadContext constructed for thread " 
                  << std::this_thread::get_id() << std::endl;
    }
    
    ~ThreadContext() {
        std::cout << "ThreadContext destroyed for " << thread_name
                  << " (ops: " << operation_count << ")" << std::endl;
    }
    
    void record_operation() {
        operation_count++;
    }
};
 
// Thread-local instance - each thread gets its own
thread_local ThreadContext ctx;
 
void worker(int id) {
    // First access constructs this thread's instance
    ctx.thread_name = "Worker-" + std::to_string(id);
    
    for (int i = 0; i < 100; i++) {
        ctx.record_operation();
    }
    
    std::cout << ctx.thread_name << " completed" << std::endl;
    
    // When thread exits, destructor is called automatically
}
 
int main() {
    ctx.thread_name = "Main";
    
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);
    
    t1.join();
    t2.join();
    
    ctx.record_operation();
    
    return 0;
    // Main's ctx is destroyed here
}
 
// Thread-local with lazy initialization
thread_local std::vector<int> thread_cache = []() {
    std::cout << "Initializing cache for thread " 
              << std::this_thread::get_id() << std::endl;
    return std::vector<int>(100, 0);
}();
 
// Beware: this lambda runs ONCE per thread, 
// first time thread_cache is accessed

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// PITFALL: Destruction order with dependencies
thread_local Logger logger;           // Might be destroyed first
thread_local Connection conn;         // Uses logger in destructor?
 
// If logger is destroyed before conn, conn's destructor crashes
 
// SOLUTION: Use explicit cleanup, or careful ordering
thread_local std::unique_ptr<Logger> logger;
thread_local std::unique_ptr<Connection> conn;
 
void init_thread_resources() {
    logger = std::make_unique<Logger>();
    conn = std::make_unique<Connection>(logger.get());
}
 
void cleanup_thread_resources() {
    // Explicit order: conn first (uses logger), then logger
    conn.reset();
    logger.reset();
}
 
// PITFALL: Static thread_local in block scope
void problematic() {
    static thread_local Expensive obj;  // Constructed once per thread
    // But when? First time this function is called in each thread
    // And destroyed when thread exits
}
 
// Each thread that calls problematic() constructs obj once
// But order relative to other TLS is unpredictable
 
// BETTER: Explicit initialization pattern
class ThreadResources {
    thread_local static std::unique_ptr<Resources> instance_;
    
public:
    static Resources& get() {
        if (!instance_) {
            instance_ = std::make_unique<Resources>();
        }
        return *instance_;
    }
    
    static void cleanup() {
        instance_.reset();
    }
};
 
thread_local std::unique_ptr<Resources> ThreadResources::instance_;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

// Pattern 1: Consolidated TLS struct
typedef struct {
    int request_id;
    char user_name[64];
    LogLevel log_level;
    void *transaction;
    struct timespec start_time;
    // Add more as needed
} ThreadContext;
 
static __thread ThreadContext thread_ctx = {0};
 
ThreadContext *get_thread_context(void) {
    return &thread_ctx;
}
 
void reset_thread_context(void) {
    memset(&thread_ctx, 0, sizeof(thread_ctx));
}
 
// Pattern 2: Lazy initialization with flag
static __thread int tls_initialized = 0;
static __thread ExpensiveResource resource;
 
ExpensiveResource *get_resource(void) {
    if (!tls_initialized) {
        initialize_resource(&resource);
        tls_initialized = 1;
    }
    return &resource;
}
 
// Pattern 3: Thread pool-safe TLS
void begin_task(TaskContext *task) {
    // Reset ALL TLS at start of each task
    reset_thread_context();
    
    // Set up for this task
    ThreadContext *ctx = get_thread_context();
    ctx->request_id = task->request_id;
    strncpy(ctx->user_name, task->user_name, sizeof(ctx->user_name));
    clock_gettime(CLOCK_MONOTONIC, &ctx->start_time);
}
 
void end_task(void) {
    // Log task completion using TLS context
    ThreadContext *ctx = get_thread_context();
    struct timespec end_time;
    clock_gettime(CLOCK_MONOTONIC, &end_time);
    
    log_task_metrics(ctx->request_id, 
                    time_diff_ms(&ctx->start_time, &end_time));
    
    // Clear sensitive data
    reset_thread_context();
}
 
// Pattern 4: TLS with cleanup registration
static pthread_key_t cleanup_key;
static pthread_once_t key_once = PTHREAD_ONCE_INIT;
 
void cleanup_handler(void *ptr) {
    ResourceList *list = ptr;
    while (list) {
        list->cleanup(list->resource);
        ResourceList *next = list->next;
        free(list);
        list = next;
    }
}
 
void init_cleanup_key(void) {
    pthread_key_create(&cleanup_key, cleanup_handler);
}
 
void register_for_cleanup(void *resource, void (*cleanup)(void *)) {
    pthread_once(&key_once, init_cleanup_key);
    
    ResourceList *entry = malloc(sizeof(ResourceList));
    entry->resource = resource;
    entry->cleanup = cleanup;
    entry->next = pthread_getspecific(cleanup_key);
    
    pthread_setspecific(cleanup_key, entry);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// Portable TLS macro header
 
#ifndef PORTABLE_TLS_H
#define PORTABLE_TLS_H
 
// Static TLS declaration
#if defined(_MSC_VER)
    #define THREAD_LOCAL __declspec(thread)
#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
    #define THREAD_LOCAL _Thread_local
#elif defined(__GNUC__) || defined(__clang__)
    #define THREAD_LOCAL __thread
#else
    #error "No TLS support detected"
#endif
 
// Usage:
// static THREAD_LOCAL int my_var;
 
// For C++11 and later, prefer:
// #if __cplusplus >= 201103L
//     #define THREAD_LOCAL thread_local
// #endif
 
// Dynamic TLS (POSIX vs Windows)
#ifdef _WIN32
    #include <windows.h>
    typedef DWORD tls_key_t;
    
    static inline int tls_create(tls_key_t *key, void (*destructor)(void *)) {
        *key = TlsAlloc();
        // Note: Windows TLS doesn't natively support destructors
        // Would need DllMain or manual tracking
        return (*key == TLS_OUT_OF_INDEXES) ? -1 : 0;
    }
    
    static inline void *tls_get(tls_key_t key) {
        return TlsGetValue(key);
    }
    
    static inline int tls_set(tls_key_t key, void *value) {
        return TlsSetValue(key, value) ? 0 : -1;
    }
    
    static inline int tls_delete(tls_key_t key) {
        return TlsFree(key) ? 0 : -1;
    }
#else
    #include <pthread.h>
    typedef pthread_key_t tls_key_t;
    
    static inline int tls_create(tls_key_t *key, void (*destructor)(void *)) {
        return pthread_key_create(key, destructor);
    }
    
    static inline void *tls_get(tls_key_t key) {
        return pthread_getspecific(key);
    }
    
    static inline int tls_set(tls_key_t key, void *value) {
        return pthread_setspecific(key, value);
    }
    
    static inline int tls_delete(tls_key_t key) {
        return pthread_key_delete(key);
    }
#endif
 
#endif // PORTABLE_TLS_H