C语言中是否有类似Java isAlive的方法检测pthread线程状态？

Hey there! Great question—since POSIX threads (pthreads) don’t come with a built-in equivalent to Java’s isAlive() method, we need to roll our own solution. Let’s walk through a few reliable approaches, each with tradeoffs to fit different use cases:

1. Custom Thread State Flag (Simple & Straightforward) #

The easiest way is to track the thread’s status with a shared boolean flag, protected by a mutex to avoid race conditions. Update the flag when the thread starts and right before it exits.

#include <pthread.h>
#include <stdbool.h>

// Shared state and mutex for thread safety
bool thread_is_running = false;
pthread_mutex_t thread_state_mutex = PTHREAD_MUTEX_INITIALIZER;

void* worker_thread(void* arg) {
    // Mark thread as running once it starts
    pthread_mutex_lock(&thread_state_mutex);
    thread_is_running = true;
    pthread_mutex_unlock(&thread_state_mutex);

    // Your thread's actual work goes here
    // ...

    // Mark thread as stopped before exiting
    pthread_mutex_lock(&thread_state_mutex);
    thread_is_running = false;
    pthread_mutex_unlock(&thread_state_mutex);

    return NULL;
}

// Our custom "is alive" check
bool is_thread_alive(pthread_t thread) {
    pthread_mutex_lock(&thread_state_mutex);
    bool alive = thread_is_running;
    pthread_mutex_unlock(&thread_state_mutex);
    return alive;
}

Pros: Super simple to implement and understand.
Cons: Fails if the thread crashes or gets killed by a signal (it won’t have a chance to update the flag, leading to a false "alive" result).

2. Use pthread_kill() with a Null Signal (System-Level Check) #

The pthread_kill() function can send a signal to a thread, but sending signal 0 doesn’t actually kill the thread—it just checks if the thread exists. This is a more reliable system-level check.

#include <pthread.h>
#include <errno.h>

bool is_thread_alive(pthread_t thread) {
    int status = pthread_kill(thread, 0);
    if (status == 0) {
        // Thread exists and is alive
        return true;
    } else if (status == ESRCH) {
        // Thread doesn't exist (it's terminated)
        return false;
    } else {
        // Other error (e.g., permission issues)
        // Handle this based on your app's needs
        return false;
    }
}

Pros: Works even if the thread exits unexpectedly, since it queries the OS directly.
Cons: If the thread was detached (pthread_detach()) or already joined with pthread_join(), the pthread_t handle becomes invalid, and pthread_kill() will return ESRCH even if the thread was alive recently. So this works best for joinable threads that haven’t been joined yet.

3. Non-Blocking pthread_join() (Check + Resource Cleanup) #

If you need to both check the thread’s status and clean up its resources when it exits, you can use a non-blocking join. On Linux, pthread_tryjoin_np() lets you attempt to join a thread without blocking; alternatively, pthread_timedjoin_np() with a zero timeout works similarly.

#include <pthread.h>
#include <time.h>

bool is_thread_alive(pthread_t thread) {
    struct timespec immediate_timeout = {0, 0}; // No wait time
    int status = pthread_timedjoin_np(thread, NULL, &immediate_timeout);
    
    if (status == 0) {
        // Thread terminated, and we successfully joined it
        return false;
    } else if (status == ETIMEDOUT) {
        // Thread is still running (join timed out immediately)
        return true;
    } else if (status == EINVAL) {
        // Thread is detached or invalid—can't join it
        return false;
    }
    return false;
}

Pros: Combines status checking with resource cleanup (no zombie threads left behind).
Cons: Non-portable—pthread_tryjoin_np and pthread_timedjoin_np are POSIX extensions, not available on all systems (like some BSD variants). Also doesn’t work for detached threads.

Which One Should You Choose? #

• Go with the custom flag if you control the thread’s full lifecycle and can guarantee it exits cleanly.
• Use pthread_kill() for the most reliable, portable check (just be mindful of detached/joined threads).
• Pick the non-blocking join if you need to clean up thread resources while checking status, and your target system supports the extensions.

内容的提问来源于stack exchange，提问作者user6793527