《TCP/IP网络编程》学习笔记 | Chapter 18：多线程服务器端的实现

线程的概念

引入线程的背景

多进程模型的缺点：

1. 创建（复制）进程的工作本身会给操作系统带来相当沉重的负担
2. 进程间通信的实现难度高，为了完成进程间数据交换，需要特殊的 IPC 技术
3. 每秒少则数十次、多则数千次的“上下文切换”（Context Switching）是创建进程时最大的开销

只有一个 CPU 的系统是将时间分成多个微小的块后分配给了多个进程。为了分时使用 CPU ，需要「上下文切换」的过程。

运行程序前需要将相应进程信息读入内存，如果运行进程 A 后紧接着需要运行进程 B ，就应该将进程 A 相关信息移出内存，并读入进程 B 相关信息。这就是上下文切换。但是此时进程 A 的数据将被移动到硬盘，所以上下文切换要很长时间，即使通过优化加快速度，也会存在一定的局限。

为了保持多进程的优点，同时在一定程度上克服其缺点，人们引入了线程（Thread）的概念。这是为了将进程的各种劣势降至最低程度（不是直接消除）而设立的一种「轻量级进程」。线程比进程具有如下优点：

1. 线程的创建和上下文切换比进程的创建和上下文切换更快
2. 线程间交换数据无需特殊技术

线程与进程的区别

每个进程的内存空间由三个部分构成：

1. 数据区：用于保存全局变量
2. 堆区域：用于向malloc等函数的动态分配提供空间
3. 栈区域：函数运行时会使用

每个进程都有独立的这种空间，多个进程的内存结构如图所示：

为了得到多条代码流而复制整个内存区域的负担太重了，所以有了线程的出现。不应完全分离内存结构，而只需要分离栈区域。通过这种方式可以获得如下优势：

1. 上下文切换时不需要切换数据区和堆
2. 可以利用数据区和堆交换数据

实际上这就是线程。线程为了保持多条代码执行流而隔开了栈区域，因此具有如下图所示的内存结构：

多个线程共享数据区和堆。为了保持这种结构，线程将在进程内创建并运行。也就是说，进程和线程可以定义为如下形式：

• 进程：在操作系统中构成单独执行流的单位
• 线程：在进程内构成单独执行流的单位

如果说进程在操作系统内部生成多个执行流，那么线程就在同一进程内部创建多条执行流。因此，操作系统、进程、线程之间的关系可以表示为下图：

线程创建与运行

pthread_create

线程具有单独的执行流，因此需要单独定义线程的 main 函数，还需要请求操作系统在单独的执行流中执行该函数，完成该功能的函数如下：

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

参数：

• thread：保存新创建线程 ID 的变量地址值。线程与进程相同，也需要用于区分不同线程的 ID
• attr：用于传递线程属性的参数，传递 NULL 时，创建默认属性的线程
• start_routine：相当于线程 main 函数的、在单独执行流中执行的函数地址值（函数指针）
• arg：通过第三个参数传递的调用函数时包含传递参数信息的变量地址值

成功时返回 0，失败时返回 -1。

要想理解好上述函数的参数，需要熟练掌握restrict关键字和函数指针相关语法。但如果只关注使用方法，那么该函数的使用比想象中要简单。下面通过简单示例了解该函数的功能。

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

void *thread_main(void *arg);

int main(int argc, char *argv[])
{
    pthread_t t_id;
    int thread_param = 5;
    // 请求创建一个线程，从 thread_main 调用开始，在单独的执行流中运行。同时传递参数
    if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0)
    {
        puts("pthread_create() error");
        return -1;
    }
    sleep(10); // 延迟进程终止时间
    puts("end of main");

    // system("pause");
    return 0;
}
void *thread_main(void *arg) // 传入的参数是 pthread_create 的第四个
{
    int i;
    int cnt = *((int *)arg);
    for (int i = 0; i < cnt; i++)
    {
        sleep(1);
        puts("running thread");
    }
    return NULL;
}

线程相关代码在编译时需要添加-lpthread选项声明需要连接线程库，只有这样才可以调用头文件pthread.h中声明的函数。

运行结果：

上述程序的执行如下图所示。其中，虚线代表执行流称，向下的箭头指的是执行流，横向箭头是函数调用。

可以看出，程序在主进程没有结束时，生成的线程每隔一秒输出一次“running thread”，共输出5次，最后输出 main 函数中的“end of main”。

但是如果主进程没有等待十秒，而是直接结束，将主函数中的 sleep(10) 改成 sleep(2)。

这样不会输出 5 次“running thread”，main 函数返回后整个进程将被销毁，无论线程有没有运行完毕，如下图所示。

pthread_join

通过调用 sleep 函数控制线程的执行相当于预测程序的执行流程，但实际上这是不可能完成的事情。而且稍有不慎，很可能干扰程序的正常执行流。例如，怎么可能在上述示例中准确预测 thread_main 函数的运行时间，并让 main 函数恰好等待这么长时间呢？因此，我们不用 sleep 函数，而是通常利用下面的函数控制线程的执行流。

#include <pthread.h>

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

参数：

• thread：该参数值 ID 的线程终止后才会从该函数返回
• status：保存线程的 main 函数返回值的指针的变量地址值

成功时返回 0，失败时返回 -1。

调用该函数的进程（或线程）将进入等待状态，直到第一个参数为ID的线程终止为止。另外，还能得到线程的 main 函数返回值。

下面是该函数的用法示例代码：

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

void *thread_main(void *arg);

int main(int argc, char *argv[])
{
    pthread_t t_id;
    int thread_param = 5;
    void *thr_ret;
    // 请求创建一个线程，从 thread_main 调用开始，在单独的执行流中运行，同时传递参数
    if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0)
    {
        puts("pthread_create() error");
        return -1;
    }
    // main函数将等待 ID 保存在 t_id 变量中的线程终止
    if (pthread_join(t_id, &thr_ret) != 0)
    {
        puts("pthread_join() error");
        return -1;
    }
    printf("Thread return message : %s \n", (char *)thr_ret);
    free(thr_ret);

    // system("pause");
    return 0;
}

void *thread_main(void *arg) // 传入的参数是 pthread_create 的第四个
{
    int i;
    int cnt = *((int *)arg);
    char *msg = (char *)malloc(sizeof(char) * 50);
    strcpy(msg, "Hello, I'm thread~ \n");
    for (int i = 0; i < cnt; i++)
    {
        sleep(1);
        puts("running thread");
    }
    return (void *)msg; // 返回值是 thread_main 函数中内部动态分配的内存空间地址值
}

运行结果：

可以看出，线程输出了5次字符串，并且把返回值给了主进程。

下面是该函数的执行流程图：

可在临界区内调用的函数

在同步的程序设计中，临界区指的是一个访问共享资源（如共享设备、共享存储器）的程序片段，而这些共享资源有无法同时被多个线程访问的特性。

稍后将讨论哪些代码可能成为临界区，多个线程同时执行临界区代码时会产生哪些问题等内容。现阶段只需理解临界区的概念即可。根据临界区是否引起问题，函数可分为以下2类：

• 线程安全函数
• 非线程安全函数

线程安全函数被多个线程同时调用也不会发生问题。反之，非线程安全函数被同时调用时会引发问题。但这并非有关于临界区的讨论，线程安全的函数中同样可能存在临界区。只是在线程安全的函数中，同时被多个线程调用时可通过一些措施避免问题。

幸运的是，大多数标准函数都是线程安全函数。操作系统在定义非线程安全函数的同时，提供了具有相同功能的线程安全的函数。

比如，第 8 章的 gethostbyname 函数不是线程安全的：

struct hostent *gethostbyname(const char *hostname);

同时提供线程安全的同一功能的函数：

struct hostent *gethostbyname_r(const char *name,
                                struct hostent *result,
                                char *buffer,
                                int intbuflen,
                                int *h_errnop);

线程安全函数结尾通常是 _r（与 Windows 不同）。但是使用线程安全函数会给程序员带来额外的负担，可以通过以下方法自动将 gethostbyname 函数调用改为 gethostbyname_r 函数调用：声明头文件前定义 _REENTRANT 宏。

无需特意更改源代码，可以在编译的时候指定编译参数定义宏：

gcc -D_REENTRANT mythread.c -o mthread -lpthread

工作（Worker）线程模型

下面的示例是计算从 1 到 10 的和，但并不是通过 main 函数进行运算，而是创建两个线程，其中一个线程计算 1 到 5 的和，另一个线程计算 6 到 10 的和，main 函数只负责输出运算结果。这种方式的线程模型称为「工作线程」。

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

void *thread_summation(void *arg);
int sum = 0;

int main(int argc, char *argv[])
{
    pthread_t id_t1, id_t2;
    int range1[] = {1, 5};
    int range2[] = {6, 10};

    pthread_create(&id_t1, NULL, thread_summation, (void *)range1);
    pthread_create(&id_t2, NULL, thread_summation, (void *)range2);

    pthread_join(id_t1, NULL);
    pthread_join(id_t2, NULL);
    printf("result: %d \n", sum);

    // system("pause");
    return 0;
}

void *thread_summation(void *arg)
{
    int start = ((int *)arg)[0];
    int end = ((int *)arg)[1];
    while (start <= end)
    {
        sum += start;
        start++;
    }
    return NULL;
}

该程序的执行流程图：

运行结果：

可以看出计算结果正确，两个线程都用了全局变量 sum，证明了 2 个线程共享保存全局变量的数据区。

但是本例子本身存在临界区相关问题，可以从下面的代码看出，下面的代码和上面的代码相似，只是增加了发生临界区错误的可能性，即使在高配置系统环境下也容易产生的错误。

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

#define NUM_THREAD 100

void *thread_inc(void *arg);
void *thread_des(void *arg);
long long num = 0;

int main(int argc, char *argv[])
{
    pthread_t thread_id[NUM_THREAD];
    int i;

    printf("sizeof long long: %d \n", sizeof(long long));
    for (i = 0; i < NUM_THREAD; i++)
    {
        if (i % 2)
            pthread_create(&(thread_id[i]), NULL, thread_inc, NULL);
        else
            pthread_create(&(thread_id[i]), NULL, thread_des, NULL);
    }

    for (i = 0; i < NUM_THREAD; i++)
        pthread_join(thread_id[i], NULL);

    printf("result: %lld \n", num);

    system("pause");
    return 0;
}

void *thread_inc(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num += 1;
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num -= 1;
    return NULL;
}

运行结果：

理论上来说，上面代码的最后结果应该是 0。但实际上，每次运行的结果都不同，且不是 0。

线程存在的问题和临界区

多个线程访问同一变量的问题

上述代码的问题：2 个线程正在同时访问全局变量 num。

在详细解释问题之前，先了解一个概念———寄存器，它是存放值的地方。当线程从进程中获取值进行运算的时候，线程实际上会将这个值放入自己的寄存器在计算完成后才会重新更新进程内部的数据区。这种机制看似没啥问题，但是如果一但一个线程在将寄存器中的值更新回数据区之前它被操作系统中断掉，转而运行第二个线程，那么此时第二个线程实际上使用的是一个过期的值。

任何内存空间，只要被同时访问，都有可能发生问题。 因此，线程访问变量 num 时应该阻止其他线程访问，直到线程 1 运算完成。这就是同步。

临界区位置

临界区的定义：函数内同时运行多个线程时引发问题的多条语句构成的代码块。

全局变量 num 不能视为临界区，因为它不是引起问题的语句，只是一个内存区域的声明。

临界区通常位于由线程运行的函数内部。

下面是刚才代码的两个 main 函数：

void *thread_inc(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num += 1; // 临界区
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
        num -= 1; // 临界区
    return NULL;
}

由上述代码可知，临界区并非 num 本身，而是访问 num 的两条语句，这两条语句可能由多个线程同时运行，也是引起这个问题的直接原因。产生问题的原因可以分为以下三种情况：

1. 2 个线程同时执行 thread_inc 函数
2. 2 个线程同时执行 thread_des 函数
3. 2 个线程分别执行 thread_inc 和 thread_des 函数

比如发生以下情况：线程 1 执行 thread_inc 的 num+=1 语句的同时，线程 2 执行 thread_des 函数的 num-=1 语句。

也就是说，两条不同的语句由不同的线程执行时，也有可能构成临界区。前提是这 2 条语句访问同一内存空间。

线程同步

前面讨论了线程中存在的问题，下面就是解决方法——线程同步。

同步的两面性

线程同步用于解决线程访问顺序引发的问题。需要同步的情况可以从如下两方面考虑：

• 同时访问同一内存空间时发生的情况
• 需要指定访问同一内存空间的线程顺序的情况

之前已解释过前一种情况，因此重点讨论第二种情况。这是「控制线程执行的顺序」的相关内容。假设有 A、B 两个线程，线程 A 负责向指定的内存空间内写入数据，线程 B 负责取走该数据。所以这是有顺序的，不按照顺序就可能发生问题。所以这种也需要进行同步。

互斥量

互斥量是 Mutual Exclusion 的简写，表示不允许多个线程同时访问。互斥量主要用于解决线程同步访问的问题。

互斥量就像是一把锁，把临界区锁起来，不允许多个线程同时访问。下面是互斥量的创建及销毁函数：

#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t *mutex,
					   const pthread_mutexattr_t *attr);
					   
int pthread_mutex_destroy(pthread_mutex_t *mutex);

参数：

• mutex：创建互斥量时传递保存互斥量的变量地址值，销毁时传递需要销毁的互斥量地址
• attr：传递即将创建的互斥量属性，没有特别需要指定的属性时传递 NULL

成功时返回 0，失败时返回其他值。

从上述函数声明中可以看出，为了创建相当于锁系统的互斥量，需要声明如下 pthread_mutex_t 型变量：

pthread_mutex_t mutex;

该变量的地址值传递给 pthread_mutex_init 函数，用来保存操作系统创建的互斥量（锁系统）。调用 pthread_mutex_destroy 函数时同样需要该信息。如果不需要配置特殊的互斥量属性，则向第二个参数传递 NULL 时，可以利用 PTHREAD_MUTEX_INITIALIZER 宏进行如下声明：

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

但推荐尽可能的使用 pthread_mutex_init 函数进行初始化，因为通过宏进行初始化时很难发现发生的错误。

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

成功时返回 0 ，失败时返回其他值。

进入临界区前调用的函数就是 pthread_mutex_lock 。调用该函数时，发现有其他线程已经进入临界区，pthread_mutex_lock 函数不会返回，直到里面的线程调用 pthread_mutex_unlock 函数退出临界区位置。也就是说，其他线程让出临界区之前，当前线程一直处于阻塞状态。

接下来整理一下代码的编写方式。创建好互斥量的前提下，可以通过如下结构保护临界区：

pthread_mutex_lock(&mutex);
// 临界区开始
// ...
// 临界区结束
pthread_mutex_unlock(&mutex);

简言之，就是利用 lock 和 unlock 函数围住临界区的两端。此时互斥量相当于一把锁，阻止多个线程同时访问，还有一点要注意，线程退出临界区时，如果忘了调用 pthread_mutex_unlock 函数，那么其他为了进入临界区而调用 pthread_mutex_lock 的函数无法摆脱阻塞状态。这种情况称为「死锁」，需要格外注意。

下面利用互斥量解决之前示例中遇到的问题：

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

#define NUM_THREAD 100

void *thread_inc(void *arg);
void *thread_des(void *arg);

long long num = 0;
pthread_mutex_t mutex; // 保存互斥量读取值的变量

int main(int argc, char *argv[])
{
    pthread_t thread_id[NUM_THREAD];
    int i;

    pthread_mutex_init(&mutex, NULL); // 创建互斥量

    for (i = 0; i < NUM_THREAD; i++)
    {
        if (i % 2)
            pthread_create(&(thread_id[i]), NULL, thread_inc, NULL);
        else
            pthread_create(&(thread_id[i]), NULL, thread_des, NULL);
    }

    for (i = 0; i < NUM_THREAD; i++)
        pthread_join(thread_id[i], NULL);

    printf("result: %lld \n", num);
    pthread_mutex_destroy(&mutex); // 销毁互斥量

    system("pause");
    return 0;
}

void *thread_inc(void *arg)
{
    int i;
    pthread_mutex_lock(&mutex); // 上锁
    for (i = 0; i < 50000000; i++)
        num += 1;                 // 临界区
    pthread_mutex_unlock(&mutex); // 解锁
    return NULL;
}
void *thread_des(void *arg)
{
    int i;
    for (i = 0; i < 50000000; i++)
    {
        pthread_mutex_lock(&mutex);   // 上锁
        num -= 1;                     // 临界区
        pthread_mutex_unlock(&mutex); // 解锁
    }
    return NULL;
}

运行结果：

thread_inc 函数中临界区的划分范围比较大，这是考虑到如下优点所做的决定：最大限度减少互斥量lock、unlock函数的调用次数。

信号量

下面介绍信号量。信号量与互斥量极为相似，在互斥量的基础上很容易理解信号量。

信号量（Semaphore），是一个同步对象，用于保持在 0 至指定最大值之间的一个计数值。当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一；当线程完成一次对semaphore对象的释放（release）时，计数值加一。

如果信号量是一个任意的整数，通常被称为计数信号量（Counting semaphore），或一般信号量（general semaphore）。如果信号量只有二进制的 0 或 1，称为二进制信号量（binary semaphore）。在linux系统中，二进制信号量（binary semaphore）又称互斥锁（Mutex）。

此处只涉及利用「二进制信号量」（只用 0 和 1）完成「控制线程顺序」为中心的同步方法。

下面是信号量的创建及销毁方法：

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

int sem_destroy(sem_t *sem);

参数：

• sem：创建信号量时保存信号量的变量地址值，销毁时传递需要销毁的信号量变量地址值
• pshared：传递其他值时，创建可由多个继承共享的信号量；传递 0 时，创建只允许 1 个进程内部使用的信号量。需要完成同一进程的线程同步，故为 0
• value：指定创建信号量的初始值

成功时返回 0 ，失败时返回其他值。

上述的 shared 参数超出了我们的关注范围，故默认向其传递为 0。

下面是信号量中相当于互斥量 lock、unlock 的函数：

#include <semaphore.h>

int sem_post(sem_t *sem);

int sem_wait(sem_t *sem);

参数：

• sem：传递保存信号量读取值的变量地址值，传递给 sem_post 的信号量增1，传递给 sem_wait 时信号量减 1

成功时返回 0 ，失败时返回其他值。

调用 sem_init 函数时，操作系统将创建信号量对象，此对象中记录这「信号量值」（Semaphore Value）整数。该值在调用 sem_post 函数时增加 1 ，调用 sem_wait 函数时减 1。但信号量的值不能小于 0 ，因此，在信号量为 0 的情况下调用 sem_wait 函数时，调用的线程将进入阻塞状态（因为函数未返回）。当然，此时如果有其他线程调用 sem_post 函数，信号量的值将变为 1 ，而原本阻塞的线程可以将该信号重新减为 0 并跳出阻塞状态。

实际上就是通过这种特性完成临界区的同步操作，假设信号量的初始值为 1，可以通过如下形式同步临界区：

sem_wait(&sem); // 信号量变为 0...
// 临界区的开始
// ...
// 临界区的结束
sem_post(&sem); // 信号量变为 1...

上述代码结构中，调用 sem_wait 函数进入临界区的线程在调用 sem_post 函数前不允许其他线程进入临界区。信号量的值在 0 和 1 之间跳转，因此，具有这种特性的机制称为「二进制信号量」。

下面给出关于控制访问顺序的同步的例子，场景为：线程 A 从用户输入得到值后存入全局变量 num ，此时线程 B 将取走该值并累加。该过程一共进行 5 次，完成后输出总和并退出程序。

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

void *read(void *arg);
void *accu(void *arg);

static sem_t sem_one;
static sem_t sem_two;
static int num;

int main(int argc, char const *argv[])
{
    pthread_t id_t1, id_t2;
    sem_init(&sem_one, 0, 0);
    sem_init(&sem_two, 0, 1);

    pthread_create(&id_t1, NULL, read, NULL);
    pthread_create(&id_t2, NULL, accu, NULL);

    pthread_join(id_t1, NULL);
    pthread_join(id_t2, NULL);

    sem_destroy(&sem_one);
    sem_destroy(&sem_two);

    // system("pause");
    return 0;
}

void *read(void *arg)
{
    int i;
    for (i = 0; i < 5; i++)
    {
        fputs("Input num: ", stdout);

        sem_wait(&sem_two);
        scanf("%d", &num);
        sem_post(&sem_one);
    }
    return NULL;
}

void *accu(void *arg)
{
    int sum = 0, i;
    for (i = 0; i < 5; i++)
    {
        sem_wait(&sem_one);
        sum += num;
        sem_post(&sem_two);
    }
    printf("Result: %d \n", sum);
    return NULL;
}

运行结果：

从上述代码可以看出，设置了两个信号量，one 的初始值为 0 ，two 的初始值为 1。在调用函数的时候，「读」的前提是 two 可以减一，如果不能减一就会阻塞在这里，一直等到「计算」操作完毕后，给 two 加一，然后就可以继续执行下一句输入。对于「计算」函数，也类似。

销毁线程的 3 种方法

Linux 线程并不是在首次调用的线程main函数返回时自动销毁，所以用如下 2 种方法之一加以明确。否则由线程创建的内存空间将一直存在。

• 调用 pthread_join 函数
• 调用 pthread_detach 函数

之前调用过 pthread_join 函数。调用该函数时，不仅会等待线程终止，还会引导线程销毁。但该函数的问题是，线程终止前，调用该函数的线程将进入阻塞状态。因此，通过如下函数调用引导线程销毁：

#include <pthread.h>

int pthread_detach(pthread_t th);

参数：

• thread：终止的同时需要销毁的线程 ID

成功时返回 0 ，失败时返回其他值。

调用上述函数不会引起线程终止或进入阻塞状态，可以通过该函数引导销毁线程创建的内存空间。调用该函数后不能再针对相应线程调用 pthread_join 函数。

多线程并发服务器端的实现

服务器端：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>

#define BUF_SIZE 100
#define MAX_CLNT 256

void *handle_clnt(void *arg);
void send_msg(char *msg, int len);
void error_handling(char *msg);

int clnt_cnt = 0;         // 记录连接的客户端数量
int clnt_socks[MAX_CLNT]; // 存储连接的客户端套接字
pthread_mutex_t mutex;    // 互斥锁，保护共享资源

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    int clnt_adr_sz;
    pthread_t t_id;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁
    // 进行服务器套接字的创建和绑定
    serv_sock = socket(PF_INET, SOCK_STREAM, 0);

    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    while (1)
    {
        // 接受客户端连接
        clnt_adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);

        pthread_mutex_lock(&mutex);         // 上锁，保护共享资源
        clnt_socks[clnt_cnt++] = clnt_sock; // 将新连接的客户端套接字存储起来
        pthread_mutex_unlock(&mutex);       // 解锁
        // 创建线程为新客户端服务，并且把 clnt_sock 作为参数传递
        pthread_create(&t_id, NULL, handle_clnt, (void *)&clnt_sock);
        // 引导线程销毁，不阻塞
        pthread_detach(t_id);
        // 打印客户端的 IP 地址
        printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
    }
    close(serv_sock);
    return 0;
}

void *handle_clnt(void *arg)
{
    int clnt_sock = *((int *)arg);
    int str_len = 0;
    char msg[BUF_SIZE];
    // 读取客户端发来的消息，并广播给所有客户端
    while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0)
        send_msg(msg, str_len);
    // 当收到消息长度为 0 时，表示客户端断开连接
    pthread_mutex_lock(&mutex);    // 上锁
    for (int i = 0; i < clnt_cnt; i++) // 从连接列表中移除断开的客户端
    {
        if (clnt_socks[i] == clnt_sock)
        {
            while (i++ < clnt_cnt - 1)
                clnt_socks[i] = clnt_socks[i + 1];
            break;
        }
    }
    clnt_cnt--;
    pthread_mutex_unlock(&mutex); // 解锁
    close(clnt_sock);
    return NULL;
}

// 将消息发送给所有连接的客户端
void send_msg(char *msg, int len)
{
    pthread_mutex_lock(&mutex); // 上锁

    // 向每个连接的客户端发送消息
    for (int i = 0; i < clnt_cnt; i++)
        write(clnt_socks[i], msg, len);

    pthread_mutex_unlock(&mutex); // 解锁
}

void error_handling(char *msg)
{
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}

客户端：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <pthread.h>

#define BUF_SIZE 100
#define NAME_SIZE 20

void *send_msg(void *arg);
void *recv_msg(void *arg);
void error_handling(char *msg);

char name[NAME_SIZE] = "[DEFAULT]"; // 客户端名称
char msg[BUF_SIZE];                 // 存储要发送的消息

int main(int argc, char *argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    pthread_t snd_thread, rcv_thread;
    void *thread_return;
    // 解析命令行参数，设置客户端名称、服务器 IP 和端口
    if (argc != 4)
    {
        printf("Usage : %s <IP> <port> <name>\n", argv[0]);
        exit(1);
    }

    sprintf(name, "[%s]", argv[3]);
    // 创建客户端套接字，设置服务器地址结构体
    sock = socket(PF_INET, SOCK_STREAM, 0);

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = inet_addr(argv[1]);
    serv_addr.sin_port = htons(atoi(argv[2]));

    if (connect(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("connect() error");
    // 创建发送和接收消息的线程
    pthread_create(&snd_thread, NULL, send_msg, (void *)&sock);
    pthread_create(&rcv_thread, NULL, recv_msg, (void *)&sock);
    // 等待线程结束
    pthread_join(snd_thread, &thread_return);
    pthread_join(rcv_thread, &thread_return);
    close(sock);
    return 0;
}

// 发送消息的线程函数
void *send_msg(void *arg)
{
    int sock = *((int *)arg);
    char name_msg[NAME_SIZE + BUF_SIZE];
    while (1)
    {
        fgets(msg, BUF_SIZE, stdin);
        if (!strcmp(msg, "q\n") || !strcmp(msg, "Q\n")) // 判断是否输入退出指令
        {
            close(sock);
            exit(0);
        }
        sprintf(name_msg, "%s %s", name, msg);
        write(sock, name_msg, strlen(name_msg)); // 发送带有客户端名称的消息
    }
    return NULL;
}

// 接收消息的线程函数
void *recv_msg(void *arg)
{
    int sock = *((int *)arg);
    char name_msg[NAME_SIZE + BUF_SIZE];
    int str_len;
    while (1)
    {
        str_len = read(sock, name_msg, NAME_SIZE + BUF_SIZE - 1);
        if (str_len == -1)
            return (void *)-1;
        name_msg[str_len] = 0;
        // 打印接收到的消息
        fputs(name_msg, stdout);
    }
    return NULL;
}

void error_handling(char *msg)
{
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}

上面的服务端示例中，需要掌握临界区的构成，访问全局变量 clnt_cnt 和数组 clnt_socks 的代码将构成临界区，添加和删除客户端时，变量 clnt_cnt 和数组 clnt_socks 将同时发生变化。

客户端示例为了分离输入和输出过程而创建了 2 个线程。

运行结果：

习题

（1）单 CPU 系统中如何同时执行多个进程？请解释该过程中发生的上下文切换。

在单 CPU 系统中，多个进程看似“同时执行”的本质是通过分时共享（Time-Sharing）和上下文切换（Context Switching）实现的。操作系统将 CPU 时间划分为微小的时间片（如 10-100ms），每个进程在时间片内独占 CPU。时间片耗尽后，操作系统强制切换其他进程。虽然同一时刻 CPU 只能执行一个进程的指令，但操作系统通过快速轮换进程的执行权，让用户感知到多个进程的“并发运行”。

虽然切换过程有开销，但合理的时间片大小和调度算法能平衡响应速度和吞吐量，为用户提供“并行”的体验。

（2）为何线程的上下文切换速度相对更快？线程间数据交换为何不需要类似 IPC 的特别技术？

同一进程内的线程共享虚拟地址空间（包括页表、内存映射、文件描述符等），切换时只需保存/恢复寄存器、栈指针、程序计数器等少量 CPU 状态，无需更新内存管理相关硬件。同一进程的线程共享代码段、数据段和堆，切换后 CPU 缓存（Cache）和 TLB 的命中率更高，减少了因缓存失效导致的性能损失。

线程直接共享进程的全局变量、堆内存等，读写同一内存区域即可交换数据，无需内核介入或额外拷贝。

（3）请从执行流角度说明进程和线程的区别。

• 进程：在操作系统中构成单独执行流的单位
• 线程：在进程内构成单独执行流的单位

（4）下列关于临界区的说法错误的是？

a. 临界区是多个线程同时访问时发生问题的区域。
b. 线程安全的函数不存在临界区，即使多个线程同时调用也不会发生问题。
c. 1 个临界区只能由 1 个代码块，而非多个代码块构成。换言之，线程 A 执行的代码块 A 和线程 B 执行的代码块 B 之间绝对不会构成临界区。
d. 临界区由访问全局变量的代码构成。其他变量不会发生问题。

答：

b、c、d。

（5）下列关于线程同步的描述错误的是？

a. 线程同步就是限制访问临界区。
b. 线程同步也具有控制线程执行顺序的含义。
c. 互斥量和信号量是典型的同步技术。
d. 线程同步是代替进程 IPC 的技术。

答：

a、d。

（6）请说明完全销毁 Linux 线程的 2 种办法。

1. 调用 pthread_join 函数
2. 调用 pthread_detach 函数

第一个会阻塞调用的线程，而第二个不阻塞。这两个函数都可以引导线程销毁。

（7）请利用多线程技术实现回声服务器端，但要让所有线程共享保存客户端消息的内存空间（char数组）。这么做只是为了应用本章的同步技术，其实不符合常理。

// 第十八章 习题 7
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <pthread.h>

#define BUF_SIZE 100
void *handle_clnt(void *arg);
void error_handling(char *msg);

char buf[BUF_SIZE];
pthread_mutex_t mutex;

int main(int argc, char *argv[])
{
    int serv_sock, clnt_sock;
    struct sockaddr_in serv_adr, clnt_adr;
    int clnt_adr_sz;
    pthread_t t_id;

    if (argc != 2)
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    pthread_mutex_init(&mutex, NULL);

    serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    memset(&serv_adr, 0, sizeof(serv_adr));
    serv_adr.sin_family = AF_INET;
    serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_adr.sin_port = htons(atoi(argv[1]));

    if (bind(serv_sock, (struct sockaddr *)&serv_adr, sizeof(serv_adr)) == -1)
        error_handling("bind() error");
    if (listen(serv_sock, 5) == -1)
        error_handling("listen() error");

    while (1)
    {
        clnt_adr_sz = sizeof(clnt_adr);
        clnt_sock = accept(serv_sock, (struct sockaddr *)&clnt_adr, &clnt_adr_sz);
        pthread_create(&t_id, NULL, handle_clnt, (void *)&clnt_sock);
        pthread_detach(t_id);
        printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr));
    }

    close(serv_sock);
    return 0;
}

void *handle_clnt(void *arg)
{
    int clnt_sock = *((int *)arg);
    int str_len = 0;

    while (1)
    {
        pthread_mutex_lock(&mutex);
        str_len = read(clnt_sock, buf, sizeof(buf));

        if (str_len <= 0)
            break;

        write(clnt_sock, buf, str_len); // echo
        pthread_mutex_unlock(&mutex);
    }

    close(clnt_sock);
    return NULL;
}

void error_handling(char *msg)
{
    fputs(msg, stderr);
    fputc('\n', stderr);
    exit(1);
}

（8）上一题要求所有线程共享保存回声消息的内存空间，如果采用这种方式，无论是否同步都会产生问题。请说明每种情况各产生哪些问题。

如果不同步，两个以上线程会同时访问同一内存空间，从而引发问题。

如果同步，由于 read 函数中调用了临界区的参数，可能会发生无法读取其他客户端发送过来的字符串而必须等待的情况。