线程#

线程是参与系统调度的最小单位。它被包含在进程之中，是进程中的实际运行单位。一个线程指的是进程中一个单一顺序的控制流（或者说是执行路线、执行流），一个进程中可以创建多个线程，多个线程实现并发运行，每个线程执行不同的任务。譬如某应用程序设计了两个需要并发运行的任务 task1 和 task2，可将两个不同的任务分别放置在两个线程中。RTOS中的任务就是线程的一种表现形式。

线程是程序最基本的运行单位，而进程不能运行，真正运行的是进程中的线程。当启动应用程序后，系统就创建了一个进程，可以认为进程仅仅是一个容器，它包含了线程运行所需的数据结构、环境变量等信息。

同一进程中的多个线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等。但同一进程中的多个线程有各自的调用栈（call stack，我们称为线程栈），自己的寄存器环境（register context）、自己的线程本地存储（thread-local storage）。

在多线程应用程序中，通常一个进程中包括了多个线程，每个线程都可以参与系统调度、被 CPU 执行，线程具有以下一些特点：

• 不单独存在，包含在进程中
• 线程是参与系统调度的基本单位
• 同一进程的多线程可并发执行，宏观上实现同时运行的效果
• 同一进程的各个线程共享该进程拥有的资源：
  • 所有线程具有相同的地址空间
  • 线程可访问该地址空间的每一个虚地址
  • 可访问进程所拥有的已打开文件、定时器和信号量

线程与进程的优劣#

多进程编程的劣势：

• 内存空间不共享：每个进程有独立的虚拟地址空间，数据共享麻烦，必须通过 IPC（如管道、共享内存、消息队列等）
• 创建开销大：使用 fork() 创建新进程代价高（复制页表、上下文等）。频繁创建/销毁进程会显著降低性能
• 通信复杂：不同进程间通信（IPC）机制种类多、实现复杂，尤其是同步控制（例如多个进程同时写共享内存）容易出错
• 切换成本高：进程上下文切换比线程慢很多，因为需要切换整个地址空间、页表等
• 资源管理复杂：每个进程资源独立，协调管理（如关闭文件描述符、回收子进程）更复杂

多线程编程的优势：

• 共享地址空间：线程共享进程的内存，通信和共享数据非常方便，比如共享变量、缓冲区
• 创建/销毁成本小：创建线程用 pthread_create() 等，比 fork() 快很多，开销更小
• 上下文切换快：线程切换只需切换寄存器、栈等，不涉及页表等操作，切换代价低
• 通信简单：直接通过全局变量或堆内存通信，不需要复杂的 IPC 机制
• 适合高并发任务：在 Web 服务器、实时系统中常见，用来处理高并发连接更高效

多线程编程的劣势：

• 数据竞争：线程共享数据，必须使用互斥锁、读写锁等手段保护，稍不注意就出 bug
• 调试困难：多线程问题（死锁、竞态条件）很难重现和排查
• 一个线程崩溃可能导致整个进程崩溃

并发和并行#

• 串行：一件事、一件事接着做
  • 只用一口锅，先做完第一碗面，再做第二碗，最后做第三碗
• 并发：交替做不同的事
  • 烧水的时候准备下碗；水烧着时你不闲着；一会煮面，一会加料；只要锅没闲着，切来切去地忙
• 并行：同时做不同的事
  • 3个厨师 + 3口锅，每人煮一碗面，互不干扰

对于单核处理器，只有一个执行单元，因此同时只能执行一条指令；对于多核处理器，可并行执行多条指令，譬如8核处理器可并行执行8条不同的指令。

线程ID#

1
#include <pthread.h>
2

3
pthread_t pthread_self(void);

该函数返回当前线程的线程ID。

还可以使用pthread_equal()函数检查两个线程ID是否相等：

1
#include <pthread.h>
2

3
int pthread_equal(pthread_t t1, pthread_t t2);

如果相等，返回非零值；否则返回0.

创建线程#

1
#include <pthread.h>
2

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

形参：

• thread：函数成功返回时，创建成功的线程ID会保存在thread指向的内存中
• attr：定义了线程的各种属性，如果设置为NULL，表示所有属性设为默认值
• start_routine：新创建的线程从start_routine()函数开始执行
• arg：要传递给start_routine()函数的参数，一般情况下需要将arg指向一个全局或堆变量，即需要保证线程的生命周期中arg指向的对象必须存在，否则会出现段错误。如果设置为NULL，表示不需要传入参数。

和进程创建时相同，一旦线程创建成功，新线程就会立即被加入到系统调度队列并开始执行，通常无法确定系统会首先调度哪一个线程来使用CPU资源（主线程或新创建的线程）。如果程序对不同线程的执行顺序有要求，就必须采用一些同步技术来实现。

简单的创建线程的例子：

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <pthread.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/types.h>
7
#include <unistd.h>
8

9
static void *new_theard_start(void *arg)
10
{
11
    printf("新线程：进程ID<%d>，线程ID<%lu>\n", getpid(), pthread_self());
12
    return (void *)0;
13
}
14

15
int main(void)
16
{
17
    pthread_t tid;
18
    int ret;
19

20
    ret = pthread_create(&tid, NULL, new_theard_start, NULL);
21
    if (ret){
22
        fprintf(stderr, "Error:%s\n", strerror(ret));
23
        exit(-1);
24
    }
25

26
    printf("主线程：进程ID<%d>，线程ID<%lu>\n", getpid(), pthread_self());
27
    sleep(1);
28
    exit(0);
29
}

终止线程#

线程可以通过以下方式终止：

• 线程的start函数执行return并返回指定值，返回值就是线程的退出码
• 线程调用pthread_exit()函数
• 调用pthread_cancel()取消线程

pthread_exit()将终止调用它的线程：

1
#include <pthread.h>
2

3
void pthread_exit(void *retval);

形参retval指定了线程的返回值，也就是线程的退出码。retval指向的内容不应分配在线程栈中，因为线程终止后将无法确认线程栈中的内存还是否有效。

回收线程#

可调用pthread_join()函数来阻塞等待线程的终止，并获取线程的退出码，回收线程资源：

1
#include <pthread.h>
2

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

• retval：如果不为NULL，函数将目标线程的退出状态复制到*retval；如果目标线程被cancel，则将PTHREAD_CANCELED放在*retval中；如果对目标线程的终止状态不感兴趣，可设置为NULL

pthread_join()类似于针对进程的waitpid()，但是：

• 线程之间关系是平等的。同一进程中的任意线程均可调用pthread_join()来等待另一个线程的终止
• 不能以非阻塞的方式调用pthread_join()。pthread_join()一旦被调用，对应线程即阻塞。

例子：

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <pthread.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/types.h>
7
#include <unistd.h>
8

9
static void *new_theard_start(void *arg)
10
{
11
    /* 线程创建2秒后即终止 */
12
    printf("New thread start\n");
13
    sleep(2);
14
    printf("New thread end\n");
15
    pthread_exit((void *)10);
16
}
17

18
int main(void)
19
{
20
    pthread_t tid;
21
    void *tret;
22
    int ret;
23

24
    ret = pthread_create(&tid, NULL, new_theard_start, NULL);
25
    if (ret){
26
        fprintf(stderr, "Error:%s\n", strerror(ret));
27
        exit(-1);
28
    }
29

30
    /* 阻塞等待tid结束 */
31
    ret = pthread_join(tid, &tret);
32
    if (ret){
33
        fprintf(stderr, "pthread join error: %s\n", strerror(ret));
34
        exit(-1);
35
    }
36
    printf("New thread end, code = %ld\n", (long)tret);
37

38
    exit(0);
39
}

取消线程#

取消线程特指某一个线程向另一个线程发送请求，要求其立即退出的操作。

1
#include <pthread.h>
2

3
int pthread_cancel(pthread_t thread);

1
#include <pthread.h>
2

3
int pthread_setcancelstate(int state, int *oldstate);
4
int pthread_setcanceltype(int type, int *oldtype);

1
static void *new_theard_start(void *arg)
2
{
3
    /* 设置线程为不可取消 */
4
    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
5

6
    for (; ;)
7
    {
8
        printf("new thread is running\r\n");
9
        sleep(2);
10
    }
11
    return (void *) 0;
12
}

1
#include <pthread.h>
2

3
void pthread_testcancel(void);

1
static void *new_theard_start(void *arg)
2
{
3
    printf("new thread is running\r\n");
4
    for (; ;){
5
        /* 人为产生取消点 */
6
        pthread_testcancel();
7
    }
8
    return (void *) 0;
9
}

分离线程#

默认情况下，当线程终止时，其它线程可以通过调用pthread_join()获取其返回状态、回收线程资源。有时，代码并不关心线程的返回状态，也不打算join它，只是希望系统在线程终止时能够自动回收线程资源并将其移除。在这种情况下，可以调用pthread_detach()将指定线程进行分离，也就是分离线程：

1
#include <pthread.h>
2

3
int pthread_detach(pthread_t thread);

一个线程可以将另一个线程分离，也可以将自己分离：pthread_detach(pthread_self())

分离之后的线程无法通过pthread_join获取终止状态，该过程不可逆，分离之后就无法恢复到之前的状态。处于分离状态的线程终止后能够自动回收线程资源。

线程的分离状态通过pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)设置，参数可选为：

• PTHREAD_CREATE_DETACHED：分离线程
• PTHREAD _CREATE_JOINABLE：非分离线程

注意：如果一个线程被设置为分离线程，而该线程运行又非常快，很有可能在pthread_create()返回之前该线程就终止了，终止之后它就可能将线程号和系统资源移交给其他线程，这样pthread_create()可能就会返回错误的线程号。避免这种情况最常见的措施就是同步通知，比如在被创建的线程里调用pthread_cond_timedwait()函数，让线程等待一会儿，留出足够的时间让 pthread_create()返回：

1
int pthread_cond_timedwait(pthread_cond_t *cond,
2
                           pthread_mutex_t *mutex,
3
                           const struct timespec *abstime);

• cond：条件变量指针，是一个事件通知器，用于判断某种条件是否成立
• mutex：互斥锁指针
• abstime：绝对时间，等待超时的截止时间，单位为秒+纳秒 注意：pthread_cond_timedwait() 等待的是 “到指定时间点” 为止，而不是 “等待N秒”！

pthread_cond_timedwait()本质上是一个带锁的同步等待机制，目的是等待某个线程间的“条件”成立。它会阻塞线程，但可以通过事件唤醒，还可以设置超时时间，防止死锁。适合：

• 等待某个事件的发生，如数据就绪或任务完成
• 在一段时间内等待，而非无限等待
• 希望在等待期间自动释放资源

该函数一般不能用sleep()和wait()代替：

• sleep()只是简单的挂起线程，无法被事件唤醒，也无法和条件变量配合使用
• wait()用于进程，不能用于线程同步

应用示例：

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <pthread.h>
4
#include <unistd.h>
5
#include <time.h>
6

7
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
8
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
9

10
static void *thread_func(void *arg)
11
{
12
    printf("线程启动了（ID=%lu）\n", pthread_self());
13

14
    struct timespec ts;
15
    clock_gettime(CLOCK_REALTIME, &ts);
16
    ts.tv_sec += 1;  // 等待1秒钟
17

18
    pthread_mutex_lock(&mutex);
19
    // 等待条件变量1秒，让主线程有足够时间返回pthread_create()
20
    pthread_cond_timedwait(&cond, &mutex, &ts);
21
    pthread_mutex_unlock(&mutex);
22

23
    printf("线程准备退出\n");
24

25
    pthread_exit(NULL);
26
}
27

28
int main()
29
{
30
    pthread_t tid;
31
    pthread_attr_t attr;
32

33
    pthread_attr_init(&attr);
34
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);  // 设置为分离状态
35

36
    if (pthread_create(&tid, &attr, thread_func, NULL) != 0) {
37
        perror("pthread_create error");
38
        exit(EXIT_FAILURE);
39
    }
40

41
    // 保证pthread_create返回前线程还在运行
42
    printf("主线程：pthread_create成功，线程ID=%lu\n", tid);
43

44
    pthread_attr_destroy(&attr);
45

46
    sleep(2);  // 等待子线程退出
47

48
    printf("主线程退出\n");
49
    return 0;
50
}

线程清理函数(Thread cleanup handler)#

线程可通过函数 pthread_cleanup_push()和 pthread_cleanup_pop()分别负责向调用线程的清理函数栈中添加和移除清理函数：

1
#include <pthread.h>
2

3
void pthread_cleanup_push(void (*routine)(void *), void *arg);
4
void pthread_cleanup_pop(int execute);

pthread_cleanup_push()用于注册一个清理函数routine(arg)，pthread_cleanup_pop()负责移除栈顶的cleanup handler，如果excute != 0，则调用它。

线程执行以下动作时，清理函数栈中的清理函数才会被执行：

• 调用pthread_exit()退出时
• 响应取消请求时(pthread_cancel)
• 用非0参数调用pthread_cleanup_pop()

pthread_cleanup_push()和 pthread_cleanup_pop()实际上是两个宏，必须成对出现，并在同一个函数作用域中使用。

示例：

1
static void cleanup(void *arg)
2
{
3
    printf("cleanup: %s\n", (char *)arg);
4
}
5

6
static void *new_thread_start(void *arg)
7
{
8
    printf("新线程--start run\n");
9
    pthread_cleanup_push(cleanup, "第 1 次调用");
10
    pthread_cleanup_push(cleanup, "第 2 次调用");
11
    pthread_cleanup_push(cleanup, "第 3 次调用");
12

13
    pthread_cleanup_pop(1); //执行最顶层的清理函数
14
    printf("~~~~~~~~~~~~~~~~~\n");
15
    sleep(2);
16
    pthread_exit((void *)0); //线程终止
17

18
    /* 为了与 pthread_cleanup_push 配对 */
19
    pthread_cleanup_pop(0);
20
    pthread_cleanup_pop(0);
21
}

线程属性#

线程属性是pthread_attr_t类型的，其在线程创建前被创建、初始化和修改，并在线程创建时通过形参传入线程。

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <pthread.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/types.h>
7
#include <unistd.h>
8

9
static void *thread_1_start(void *arg)
10
{
11
    size_t stacksize;
12

13
    /* 获取线程栈大小 */
14
    pthread_attr_getstacksize((pthread_attr_t *)arg, &stacksize);
15

16
    printf("Thread 1 start, stack size: %zu\n", stacksize);
17

18
    sleep(2);
19

20
    /* 退出线程 */
21
    pthread_exit(NULL);
22
}
23

24
int main()
25
{
26
    int ret;
27
    pthread_t thread_1;
28
    pthread_attr_t thread_1_attr;
29

30
    /* 初始化线程属性 */
31
    pthread_attr_init(&thread_1_attr);
32

33
    /* 设置线程为分离态 */
34
    pthread_attr_setdetachstate(&thread_1_attr, PTHREAD_CREATE_DETACHED);
35

36
    /* 设置线程栈大小 */
37
    ret = pthread_attr_setstacksize(&thread_1_attr, 88888);
38
    if (ret != 0){
39
        fprintf(stderr, "pthread_attr_setstacksize failed: %s\n", strerror(ret));
40
        exit(-1);
41
    }
42

43
    /* 创建线程 */
44
    ret = pthread_create(&thread_1, &thread_1_attr, thread_1_start, &thread_1_attr);
45

46
    /* 销毁线程属性 */
47
    pthread_attr_destroy(&thread_1_attr);
48

49
    sleep(3);
50

51
    /* 退出线程 */
52
    pthread_exit(NULL);
53
}