Linux线程概述与线程操作

线程和进程区别

1. 进程间通信（IPC）的复杂性：

   • 进程之间不共享内存空间，所以它们之间的数据交换需要通过IPC机制，如信号量、共享内存、消息队列、管道等。这些机制往往比线程间的数据交换更为复杂和成本更高。

2. fork() 创建进程的成本：

   • fork() 系统调用被用于创建一个新进程，称为子进程，它是父进程的复制品。虽然现代操作系统通常使用写时复制（copy-on-write, COW）技术来优化内存的复制，只有在任一进程尝试修改内存时才真正复制内存页，但即使如此，创建进程的成本（如复制页表、文件描述符等）仍然相对较高。

3. 线程间的信息共享：

   • 线程之间共享同一进程内的内存空间，使得数据共享非常快速和方便。线程可以直接读写同一进程内的全局变量或堆内存，无需特殊的IPC机制。

4. 创建线程的效率：

   • 相比于创建进程，创建线程的开销要小得多。因为线程共享其父进程的大部分资源，如内存空间和文件描述符，所以创建线程不需要复制这些资源。这使得创建线程的速度可以快于创建进程10倍或更多。

线程之间共享和非共享资源

共享资源

1. 进程 ID 和父进程 ID：每个进程都有一个唯一的进程标识符（PID），以及一个指向其父进程的标识符（PPID）。这些标识符在进程的所有线程中都是共享的。

2. 进程组 ID 和会话 ID：进程组是一组相关进程的集合，通常用于信号传递等。会话ID用于标识一个会话，该会话中包括一个或多个进程组。

3. 用户 ID 和用户组 ID：这些ID定义了进程的所有权和权限，它们对于进程内的所有线程都是相同的。

4. 文件描述符表：文件描述符是指向打开文件的引用。在同一进程中的所有线程共享这些文件描述符，使得它们可以共同访问和操作相同的文件。

5. 信号处置：信号处理函数和信号处理的配置是在进程层面设置的，因此进程中的所有线程都将共享这些信号处理设置。

6. 文件系统相关信息：包括文件权限掩码（umask）和当前工作目录，这些也是进程层面共享的。

7. 虚拟地址空间：除了栈和程序代码段（.text），其余如堆、数据段等都是进程中所有线程共享的。

非共享资源

1. 线程 ID：每个线程有其唯一的线程标识符，这在管理线程时非常重要。

2. 信号掩码：虽然信号的处理是在进程级别共享的，但每个线程可以独立地阻塞某些信号，这是通过信号掩码来管理的。

3. 线程特有数据：这允许线程存储和访问其独特的数据副本，而不是共享数据。

4. Error 变量：如 errno，在每个线程中是独立存在的，用于处理特定于线程的错误。

5. 实时调度策略和优先级：每个线程可以有自己的调度策略和优先级设置，这影响线程执行的优先顺序。

6. 栈、本地变量和函数调用链接信息：每个线程有自己的栈，用于存储局部变量和跟踪函数调用链，这确保了线程执行的独立性。

理解这些资源的共享与非共享特性对于设计和调试多线程应用程序非常关键。如果你需要进一步的解释或示例，或者有具体的编程问题，我可以提供帮助！

NPTL（Native POSIX Thread Library）

Linux 线程的早期实现：LinuxThreads

在 Linux 系统的早期版本中，真正的线程支持是不存在的。LinuxThreads 是最初的线程实现，它通过 clone() 系统调用实现。clone() 是比 fork() 更为灵活的调用，允许调用进程创建一个子进程，这个子进程可以与父进程共享一些资源，如文件描述符、地址空间等。LinuxThreads 通过允许共享地址空间的方式，模拟出线程的行为。

然而，LinuxThreads 存在几个问题：

• 信号处理：LinuxThreads 在处理信号方面存在问题，因为信号处理设计并没有很好地适应多线程环境。
• 调度和同步：线程的调度和同步机制不够高效，经常导致性能问题。
• POSIX 标准：它不完全符合 POSIX 线程标准（POSIX Threads，简称 Pthreads），这影响了其跨平台的兼容性和可用性。

线程支持的改进：NPTL

由于 LinuxThreads 的限制，Linux 社区需要一个更好的线程支持库。这导致了两个主要的项目：NGPT（Next-Generation POSIX Threads）和 NPTL（Native POSIX Thread Library）。NGPT 最终在 2003 年被放弃，而 NPTL 成为了 Linux 的标准线程库。

NPTL 提供了以下改进：

• 更好的 POSIX 标准支持：NPTL 完全遵守 POSIX 线程标准，提高了其兼容性和可靠性。
• 性能和稳定性：NPTL 在多线程调度、同步和资源管理方面进行了优化，极大地提高了性能和稳定性。

查看当前 pthread 库版本

你提到了如何查看当前 Linux 系统中的 pthread 库版本。可以通过运行以下命令在终端中获取这一信息：

getconf GNU_LIBPTHREAD_VERSION

这个命令将输出当前系统使用的 GNU pthread 库的版本，通常是 NPTL 相关的版本信息。

daic@daic:~/Linux/linuxwebserver/part03Multithreading$ getconf GNU_LIBPTHREAD_VERSION
NPTL 2.27

线程操作

◼ int pthread_create(pthread_t *thread, const pthread_attr_t *attr,

void *(*start_routine) (void *), void *arg);

◼ pthread_t pthread_self(void);

◼ int pthread_equal(pthread_t t1, pthread_t t2);

◼ void pthread_exit(void *retval);

◼ int pthread_join(pthread_t thread, void **retval);

◼ int pthread_detach(pthread_t thread);

◼ int pthread_cancel(pthread_t thread);

创建线程

strerror

函数 strerror() 在 C 语言中用于将错误编号转换成人类可读的字符串。它是 C 标准库的一部分，包含在 <string.h> 头文件中。当你想根据各种库函数返回的错误代码输出描述性错误信息时，这个函数非常有用。

函数原型

#include <string.h>

char *strerror(int errnum);

参数说明

• errnum：错误编号，通常是 errno 变量或任何其他表示错误代码的整数。

返回值

• strerror() 返回一个指向描述错误代码的字符串的指针。这个字符串是静态分配的，程序不应修改它。同时，后续对 strerror() 的调用可能会覆盖相同的字符串。

使用示例

这里是一个如何在 C 程序中使用 strerror() 的示例：

#include <stdio.h>
#include <string.h>
#include <errno.h>

int main() {
    FILE *fp = fopen("nonexistentfile.txt", "r");
    if (fp == NULL) {
        int err = errno;
        printf("打开文件错误：%s\n", strerror(err));
    } else {
        // 文件处理代码
        fclose(fp);
    }
    return 0;
}

在这个示例中，如果 fopen() 函数无法打开指定的文件，它会将 errno 设置为一个错误代码。然后使用这个错误代码与 strerror() 一起打印一个人类可读的错误消息，解释为什么文件无法被打开。

注意事项

• strerror() 不是线程安全的，因为它返回一个指向静态分配字符串的指针，这个字符串可能会在多个线程之间共享。对于线程安全版本的 strerror()，你可以使用 strerror_r()，它被设计用来填充用户提供的缓冲区与错误消息。
• 在你的程序中优雅地处理错误是很重要的，strerror() 提供了一种方法，以更易于理解的方式通知用户出了什么问题。

pthread_create

函数 pthread_create() 是用于创建新线程的标准 POSIX 线程库函数。这个函数非常核心，几乎所有基于 POSIX 系统的多线程程序都会使用它来创建线程。以下是关于如何使用 pthread_create() 的一些详细信息：

函数原型

#include <pthread.h>

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
                   void *(*start_routine) (void *), void *arg);

参数说明

• thread: 指向 pthread_t 类型的指针，用于输出新创建的线程 ID。
• attr: 指向 pthread_attr_t 结构的指针，该结构用于指定线程属性。如果传入 NULL，则使用默认线程属性。
• start_routine: 指向函数的指针，该函数是线程启动时执行的，是子线程需要处理的逻辑代码。这个函数必须返回 void * 并接受一个 void * 参数。
• arg: 传递给 start_routine 函数的参数。

返回值

• 如果线程创建成功，pthread_create() 返回 0。
• 如果失败，返回一个错误码，不同的错误码代表不同的错误类型。

示例代码

下面是一个简单的例子，展示如何使用 pthread_create() 创建一个线程：

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

void *print_message(void *ptr) {
    char *message;
    message = (char *) ptr;
    printf("%s \n", message);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;
    char *message1 = "Thread 1";
    char *message2 = "Thread 2";
    
    // 创建线程1
    int iret1 = pthread_create(&thread1, NULL, print_message, (void*) message1);
    if (iret1) {
        fprintf(stderr, "Error - pthread_create() return code: %d\n", iret1);
        exit(EXIT_FAILURE);
    }

    // 创建线程2
    int iret2 = pthread_create(&thread2, NULL, print_message, (void*) message2);
    if (iret2) {
        fprintf(stderr, "Error - pthread_create() return code: %d\n", iret2);
        exit(EXIT_FAILURE);
    }

    // 等待线程结束
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    exit(EXIT_SUCCESS);
}

在这个示例中，我们创建了两个线程，每个线程分别打印一条消息。每个线程在执行完其任务后自动结束，主函数中的 pthread_join() 调用确保主线程（即执行 main() 函数的线程）会等待这两个线程完成任务后再继续执行，以避免程序过早结束。

如果你需要更多关于如何使用 pthread_create() 或其他多线程编程方面的帮助，随时告诉我！

案例

/*
    一般情况下,main函数所在的线程我们称之为主线程（main线程），其余创建的线程
    称之为子线程。
    程序中默认只有一个进程，fork()函数调用，2进行
    程序中默认只有一个线程，pthread_create()函数调用，2个线程。

    #include <pthread.h>
    int pthread_create(pthread_t *thread, const pthread_attr_t *attr, 
    void *(*start_routine) (void *), void *arg);

        - 功能：创建一个子线程
        - 参数：
            - thread：传出参数，线程创建成功后，子线程的线程ID被写到该变量中。
            - attr : 设置线程的属性，一般使用默认值，NULL
            - start_routine : 函数指针，这个函数是子线程需要处理的逻辑代码
            - arg : 给第三个参数使用，传参
        - 返回值：
            成功：0
            失败：返回错误号。这个错误号和之前errno不太一样。
            获取错误号的信息：  char * strerror(int errnum);

*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void * callback(void * arg) {
    printf("child thread...\n");
    printf("arg value: %d\n", *(int *)arg);
    return NULL;
}

int main() {

    pthread_t tid;

    int num = 10;

    // 创建一个子线程
    int ret = pthread_create(&tid, NULL, callback, (void *)&num);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\n", errstr);
    } 

    for(int i = 0; i < 5; i++) {
        printf("%d\n", i);
    }

    sleep(1);

    return 0;   // exit(0);
}

注意需要链接第三方库

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ gcc pthread_create.c -l pthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ ./a.out 
0
1
2
3
4
child thread...
arg value: 10

终止线程

pthread_exit

函数 pthread_exit() 用于在 POSIX 线程库中结束一个线程的执行。当线程完成其任务或需要提前终止时，可以调用此函数来退出线程。这是多线程编程中管理线程生命周期的一个重要方面。

函数原型

#include <pthread.h>

void pthread_exit(void *retval);

参数说明

• retval：指向任意类型的指针，用来返回线程的退出状态。这个值可以被其他线程通过 pthread_join() 捕获。

使用说明

调用 pthread_exit() 后，当前线程会结束其执行。该函数不会返回值，且一旦被调用，控制不会返回到调用线程的原始位置。

这个函数通常在线程函数的末尾使用，但也可以在线程函数的任意位置调用，以便在不需要完全运行完整个函数的情况下退出线程。

示例代码

下面是一个使用 pthread_exit() 的简单例子：

#include <pthread.h>
#include <stdio.h>

// 线程的运行函数
void *myThreadFun(void *vargp) {
    printf("Hello from new thread!\n");
    pthread_exit(NULL); // 线程正常退出
}

int main() {
    pthread_t thread_id;
    printf("Before Thread\n");
    pthread_create(&thread_id, NULL, myThreadFun, NULL);
    pthread_join(thread_id, NULL); // 等待线程结束
    printf("After Thread\n");
    return 0;
}

在这个例子中，主函数创建了一个线程，线程执行 myThreadFun 函数。在 myThreadFun 中，打印一条消息后，调用 pthread_exit() 来结束线程。主函数中的 pthread_join() 确保主程序等待新创建的线程结束，然后继续执行。

注意事项

• 调用 pthread_exit() 后，线程所占用的资源不会立即释放，直到其他线程对其进行了回收（例如，通过 pthread_join()）。
• 如果主线程调用 pthread_exit() 而不是 return，它不会影响其他线程的执行，即使主线程终止了，其他线程仍然可以继续执行。
• 使用 pthread_exit() 退出线程是线程安全的方式之一，它可以帮助维持程序的清洁退出逻辑。

如果你有任何关于 pthread_exit() 或多线程编程的其他问题，随时向我提出！

pthread_self

pthread_self() 函数是 POSIX 线程库中用于获取当前执行线程的唯一标识符的函数。这个标识符的类型是 pthread_t，在比较线程 ID 或者线程需要引用自身执行操作（如设置线程特定数据）时非常有用。

函数原型

#include <pthread.h>

pthread_t pthread_self(void);

描述

• pthread_self() 返回当前运行线程的 ID。这个 ID 在进程中的所有线程之间是唯一的。
• 返回类型 pthread_t 是用于唯一标识一个线程的数据类型。这种类型的实际实现可能在不同的操作系统中有所不同，但通常实现为整数或结构体。

用法

使用 pthread_self() 非常直接。它不需要参数，并返回线程 ID。以下是你可能使用它的方式：

示例代码

#include <pthread.h>
#include <stdio.h>

void *threadFunc(void *arg) {
    // 打印当前线程的 ID
    printf("线程 ID: %ld\n", (long) pthread_self());

    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    // 创建两个线程
    pthread_create(&thread1, NULL, threadFunc, NULL);
    pthread_create(&thread2, NULL, threadFunc, NULL);

    // 等待线程完成
    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

在这个示例中，每个线程在运行时打印出其自己的线程 ID。输出将显示每个线程的不同 ID，证明每个线程都有其唯一的标识符。

注意事项

• pthread_self() 函数非常高效，可以频繁调用而不会造成显著的性能问题。
• 它通常用于日志记录、调试以及需要识别或区分线程的场景中。
• 在比较线程 ID 时，总是应该使用适当的函数（如 pthread_equal()），而不是直接比较，因为 pthread_t 类型可能不是一个简单的基本类型。

如果你需要检查自己是否处于特定的线程或者进行线程管理的相关操作，pthread_self() 是一个非常有用的工具。

案例

#include <stdio.h>
#include <pthread.h>
#include <string.h>

void* callback(void* arg) {
    printf("child thread id: %ld\n", pthread_self());
    return NULL;
}


int main() {
    //创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);

    if(ret != 0) {
        char* errstr = strerror(ret);
        printf("error: %s", errstr);
    }
    //主线程
    for (int i = 0; i < 5; i++) {
        printf("%d\n", i);
    }
    printf ("tid: %ld, main thread id : %ld\n",tid, pthread_self());

    //让主线程退出,当主线程退出时，不会影响其他正常运行的线程
    pthread_exit(NULL);
    
    return 0;
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ ./a.out 
0
1
2
3
4
tid: 140195418404608, main thread id : 140195426928448
child thread id: 140195418404608

连接已经终止的线程

pthread_join

函数 pthread_join() 在 POSIX 线程库中用于等待一个指定的线程终止。当你创建了一个线程并希望在继续执行主线程之前确保该线程已经正确结束，你可以使用 pthread_join() 来实现这一点。这类似于在其他编程语言中的 join() 方法，它确保线程的资源得到正确释放且可以收集线程的退出状态。

函数原型

#include <pthread.h>

int pthread_join(pthread_t thread, void **retval);

参数说明

• thread：要等待的线程的标识符，这个标识符是由 pthread_create() 函数创建线程时返回的。
• retval：用于存储线程退出pthread_exit时返回的值的指针的地址。如果你不关心线程的返回值，可以设置为 NULL。

返回值

• 成功时，返回 0。
• 失败时，返回一个错误码，表示无法等待指定的线程。常见的错误码包括 EINVAL 表示无效的线程标识符，ESRCH 表示没有找到对应的线程，或 EDEADLK 表示试图等待自己的终止，导致死锁。

使用示例

以下是使用 pthread_join() 的简单示例，演示如何创建一个线程并等待其完成：

#include <pthread.h>
#include <stdio.h>

// 线程的工作函数
void *worker(void *arg) {
    printf("Hello from thread!\n");
    return (void*)42; // 假设返回 42 作为线程的退出值
}

int main() {
    pthread_t tid;
    void *ret;

    // 创建线程
    pthread_create(&tid, NULL, worker, NULL);

    // 等待线程结束
    pthread_join(tid, &ret);
    printf("Thread returned: %ld\n", (long)ret);

    return 0;
}

在这个示例中，主函数创建了一个线程，并通过 pthread_join() 等待这个线程结束。线程执行完毕后，它的返回值（在这个例子中是 42）被主线程通过 pthread_join() 函数的第二个参数 ret 捕获。

注意事项

• 使用 pthread_join() 需要注意，如果不等待线程终止，线程可能会成为僵尸线程，占用系统资源。
• 如果一个线程已经被其他线程等待（join），再次对其调用 pthread_join() 会导致错误返回。
• 正确使用 pthread_join() 可以帮助防止内存泄漏，因为它确保了线程结束后的资源回收。

案例

/*
    #include <pthread.h>
    int pthread_join(pthread_t thread, void **retval);
        - 功能：和一个已经终止的线程进行连接
                回收子线程的资源
                这个函数是阻塞函数，调用一次只能回收一个子线程
                一般在主线程中使用
        - 参数：
            - thread：需要回收的子线程的ID
            - retval: 接收子线程退出时的返回值
        - 返回值：
            0 : 成功
            非0 : 失败，返回的错误号
*/

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

int value = 10;

void * callback(void * arg) {
    printf("child thread id : %ld\n", pthread_self());
    // sleep(3);
    // return NULL; 
    // int value = 10; // 局部变量
    pthread_exit((void *)&value);   // return (void *)&value;
} 

int main() {

    // 创建一个子线程
    pthread_t tid;
    int ret = pthread_create(&tid, NULL, callback, NULL);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\n", errstr);
    }

    // 主线程
    for(int i = 0; i < 5; i++) {
        printf("%d\n", i);
    }

    printf("tid : %ld, main thread id : %ld\n", tid ,pthread_self());

    // 主线程调用pthread_join()回收子线程的资源
    int * thread_retval;
    ret = pthread_join(tid, (void **)&thread_retval);

    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error : %s\n", errstr);
    }

    printf("exit data : %d\n", *thread_retval);

    printf("回收子线程资源成功！\n");

    // 让主线程退出,当主线程退出时，不会影响其他正常运行的线程。
    pthread_exit(NULL);

    return 0; 
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ gcc pthread_join.c -lpthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ ./a.out 
0
1
2
3
4
tid : 140133687416576, main thread id : 140133695940416
child thread id : 140133687416576
exit data : 10
回收子线程资源成功！

线程的分离

pthread_detach

函数 pthread_detach() 在 POSIX 线程库中用于将指定的线程设置为“分离”状态。在分离状态的线程一旦完成，其资源会自动释放，而不需要其他线程通过 pthread_join() 来回收。这对于管理那些不需要其他线程等待其结束的线程非常有用。

函数原型

#include <pthread.h>

int pthread_detach(pthread_t thread);

参数说明

• thread: 要分离的线程的标识符，这个标识符是由 pthread_create() 函数创建线程时返回的。

返回值

• 成功时，返回 0。
• 失败时，返回一个错误码，常见的错误码包括 ESRCH 表示没有找到对应的线程，或 EINVAL 表示线程已经处于分离状态。

使用示例

以下是如何使用 pthread_detach() 的示例，演示了创建一个线程并立即将其设置为分离状态：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

void *worker(void *arg) {
    printf("Hello from thread\n");
    // 模拟工作
    sleep(1);
    return NULL;
}

int main() {
    pthread_t tid;
    int ret;

    // 创建线程
    ret = pthread_create(&tid, NULL, worker, NULL);
    if (ret != 0) {
        perror("pthread_create");
        return -1;
    }

    // 将线程设置为分离状态
    ret = pthread_detach(tid);
    if (ret != 0) {
        perror("pthread_detach");
        return -1;
    }

    // 做一些其他工作
    sleep(2); // 确保线程有足够时间运行并结束
    printf("Main thread is done\n");

    return 0;
}

在这个示例中，主函数创建了一个线程，并通过 pthread_detach() 将其设置为分离状态。这意味着一旦这个线程完成它的任务（在这里是打印一条消息并休眠一秒），它将自动释放所有资源，而不需要主线程等待它或者回收它的资源。

注意事项

• 一旦线程被设置为分离状态，就不能再使用 pthread_join() 来等待这个线程了。
• 分离线程在完成后会自动清理其占用的所有资源，包括线程描述符和堆栈。
• 如果不确定线程是否会在程序其他部分结束前完成，使用分离状态可以防止线程成为僵尸线程。

案例

/*
    #include <pthread.h>
    int pthread_detach(pthread_t thread);
        - 功能：分离一个线程。被分离的线程在终止的时候，会自动释放资源返回给系统。
          1.不能多次分离，会产生不可预料的行为。
          2.不能去连接一个已经分离的线程，会报错。
        - 参数：需要分离的线程的ID
        - 返回值：
            成功：0
            失败：返回错误号
*/
#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void * callback(void * arg) {
    printf("chid thread id : %ld\n", pthread_self());
    return NULL;
}

int main() {

    // 创建一个子线程
    pthread_t tid;

    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error1 : %s\n", errstr);
    }

    // 输出主线程和子线程的id
    printf("tid : %ld, main thread id : %ld\n", tid, pthread_self());

    // 设置子线程分离,子线程分离后，子线程结束时对应的资源就不需要主线程释放
    ret = pthread_detach(tid);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error2 : %s\n", errstr);
    }

    // 设置分离后，对分离的子线程进行连接 pthread_join()
    // ret = pthread_join(tid, NULL);
    // if(ret != 0) {
    //     char * errstr = strerror(ret);
    //     printf("error3 : %s\n", errstr);
    // }

    pthread_exit(NULL);

    return 0;
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ gcc pthread_detach.c -lpthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ ./a.out 
tid : 139746903410432, main thread id : 139746911934272
chid thread id : 139746903410432

线程取消

pthread_cancel

函数 pthread_cancel() 在 POSIX 线程库中用于请求取消某个线程。这个功能允许一个线程告诉另一个线程终止执行。被取消的线程可以忽略取消请求、延迟处理请求或立即终止，具体取决于线程的取消状态和类型设置。

函数原型

#include <pthread.h>

int pthread_cancel(pthread_t thread);

参数说明

• thread: 要取消的线程的标识符，这个标识符是由 pthread_create() 函数创建线程时返回的。

返回值

• 成功时，返回 0。
• 失败时，返回一个错误码，比如 ESRCH 表示没有找到对应的线程。

使用示例

以下是如何使用 pthread_cancel() 的示例，演示了创建一个线程并尝试取消它：

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>

void *worker(void *arg) {
    printf("Thread started and running\n");
    for (int i = 0; i < 5; i++) {
        sleep(1); // 模拟长时间运行的任务
        printf("Thread still running...\n");
    }
    return NULL;
}

int main() {
    pthread_t tid;
    int ret;

    // 创建线程
    ret = pthread_create(&tid, NULL, worker, NULL);
    if (ret != 0) {
        perror("pthread_create");
        return -1;
    }

    sleep(2); // 让线程运行一段时间

    // 尝试取消线程
    ret = pthread_cancel(tid);
    if (ret != 0) {
        perror("pthread_cancel");
        return -1;
    }

    // 等待线程结束
    pthread_join(tid, NULL);
    printf("Thread was cancelled\n");

    return 0;
}

在这个示例中，主函数创建了一个线程，并在它运行一段时间后尝试用 pthread_cancel() 取消它。如果线程响应取消请求，它将在 pthread_join() 调用中结束，并释放资源。

注意事项

• 线程取消是一个协作过程。线程需要检查取消点（一些系统调用或函数自动成为取消点，如 sleep(), read(), pthread_testcancel() 等）或显式调用 pthread_testcancel() 以响应取消请求。
• 线程可以通过设置其取消状态（启用或禁用）和取消类型（异步或延迟）来控制对取消请求的响应。
• 使用 pthread_cancel() 可能不会立即终止线程，它取决于线程的取消配置和当前执行的操作。

pthread_cancel() 提供了一种机制来控制线程的生命周期，但使用时需要小心，确保不会引起资源泄露或不一致的状态。如果你有更多关于线程管理或 pthread_cancel() 的问题，欢迎继续探讨！

案例

/*
    #include <pthread.h>
    int pthread_cancel(pthread_t thread);
        - 功能：取消线程（让线程终止）
            取消某个线程，可以终止某个线程的运行，
            但是并不是立马终止，而是当子线程执行到一个取消点，线程才会终止。
            取消点：系统规定好的一些系统调用，我们可以粗略的理解为从用户区到内核区的切换，这个位置称之为取消点。
*/

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <unistd.h>

void * callback(void * arg) {
    printf("chid thread id : %ld\n", pthread_self());
    for(int i = 0; i < 250; i++) {
        printf("child : %d\n", i);
    }
    return NULL;
}

int main() {
    
    // 创建一个子线程
    pthread_t tid;

    int ret = pthread_create(&tid, NULL, callback, NULL);
    if(ret != 0) {
        char * errstr = strerror(ret);
        printf("error1 : %s\n", errstr);
    }

    // 取消线程
    pthread_cancel(tid);

    for(int i = 0; i < 5; i++) {
        printf("%d\n", i);
    }

    // 输出主线程和子线程的id
    printf("tid : %ld, main thread id : %ld\n", tid, pthread_self());

    
    pthread_exit(NULL);

    return 0;
}

daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ gcc pthread_cancel.c -lpthread
daic@daic:~/Linux/linuxwebserver/part03Multithreading/lesson29$ ./a.out 
chid thread id : 139850754864896
child : 0
child : 1
child : 2
child : 3
child : 4
child : 5
child : 6
child : 7
child : 8
child : 9
child : 10
child : 11
child : 12
child : 13
child : 14
child : 15
child : 16
child : 17
child : 18
child : 19
child : 20
child : 21
child : 22
child : 23
child : 24
child : 25
child : 26
child : 27
child : 28
child : 29
child : 30
child : 31
child : 32
child : 33
child : 34
child : 35
child : 36
child : 37
child : 38
child : 39
child : 40
child : 41
child : 42
child : 43
child : 44
child : 45
child : 46
child : 47
child : 48
child : 49
child : 50
child : 51
child : 52
child : 53
child : 54
child : 55
child : 56
child : 57
child : 58
child : 59
child : 60
child : 61
0
1
2
3
4
tid : 139850754864896, main thread id : 139850763388736