TCP/IP网络编程之多线程服务端的实现（一）
为什么引入线程
为了实现服务端并发处理客户端请求，我们介绍了多进程模型、select和epoll，这三种办法各有优缺点。创建（复制）进程的工作本身会给操作系统带来相当沉重的负担。而且，每个进程有独立的内存空间，所以进程间通信的实现难度也会随之提高。且进程的切换同样也是不菲的开销。什么是进程切换？我们都知道计算机即便只有一个CPU也可以同时运行多个进程，这是因为系统将CPU时间分成多个微小的块后分配给多个进程，比方进程B在进程A之后执行，当进程A所分配的CPU时间到点之后，要开始执行进程B，此时需要将进程A的数据移出内存保存到磁盘，并读入进程B的数据，所以上下文切换需要比较长的时间，即使通过优化加快速度，也会存在局限
为了保持多进程的优点，同时在一定程度上克服其缺点，人们引入了线程。这是为了将进程的各种劣势降至最低限度而设计的一种“轻量级进程”，线程相比进程有如下优点：
- 线程的创建和上下文切换比进程的创建和上下文切换更快
- 线程间交换数据时无需特殊技术
线程和进程的差异
每个进程的内存空间都由保存全局变量的“数据区”、向malloc等函数动态分配提供空间的堆（Heap）、函数运行时使用的栈（Stack）构成。每个进程都拥有这种独立的空间，多个进程结构如图1-1所示
图1-1 进程间独立的内存
但如果以获得多个代码执行流为主要目的，则不应像图1-1那样完全分离内存结构，而只需分离栈区域，通过这种方式可以获得如下优势：
- 上下文切换时不需要切换数据区和堆
- 可以利用数据区和堆交换数据
实际上这就是线程，线程为了保持多条代码执行流而隔开了栈区域，因此具有如图1-2所示的内存结构
图1-2 线程的内存结构
如图1-2所示，多个线程将共享数据区和堆，为了保持这种结构，线程将在进程内创建并运行。也就是说，进程和线程可以定义为如下形式：
- 进程：在操作系统构成单独执行流的单位
- 线程：在进程构成单独执行流的单位
如果说进程在操作系统内部生成多个执行流，那么线程就在同一进程内部创建多条执行流。因此，操作系统、进程、线程之间的关系可以通过图1-3表示
图1-3 操作系统、进程、线程之间的关系
线程的创建及运行
线程具有单独的执行流，因此需要单独定义线程的main函数，还需要请求操作系统在单独的执行流中执行该函数，完成该功能的函数如下：
#include<pthread.h> int pthread_create(pthread_t * restrict thread, const pthread_attr_t * restrict attr, void* (* start_routine)(void *), void * restrict arg);//成功时返回0，失败时返回其他值
- thread：保存新创建线程ID的变量地址值，线程与进程相同，也需要用于区分不同线程的ID
- attr：用于传递线程属性的参数，传递NULL时，创建默认属性的线程
- start_routine：相当于线程的main函数的、在单独执行流中执行的函数地址值（函数指针）
- arg：通过第三个参数传递调用函数时包含传递参数信息的变量地址值
下面，我们来看一个示例
thread1.c
#include <stdio.h>
#include <pthread.h>
void *thread_main(void *arg);
int main(int argc, char *argv[])
{
pthread_t t_id;
int thread_param = 5;
if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0)
{
puts("pthread_create() error");
return -1;
};
sleep(10); puts("end of main");
return 0;
}
void *thread_main(void *arg)
{
int i;
int cnt = *((int *)arg);
for (i = 0; i < cnt; i++)
{
sleep(1); puts("running thread");
}
return NULL;
}
- 第10行：请求创建一个线程，从thread_main函数调用开始，在单独的执行流中执行。同时在调用thread_main函数时向其传递thread_param变量的地址值
- 第15行：调用sleep函数使main函数停顿10秒，这是为了延迟进程的终止时间。执行第16行的return语句后终止进程，同时终止内部创建的线程。因此，为保证线程的正常执行而添加这条语句
- 第19、22行：传入arg参数的是第10行pthread_create函数的第四个参数
编译thread1.c并运行
# gcc thread1.c -o thread1 -lpthread # ./thread1 running thread running thread running thread running thread running thread end of main
从上述运行结果可以看到，线程相关代码在编译时需添加-lpthread选项声明需要连接线程库，只有这样才能调用头文件pthread.h中声明的函数，上述程序的执行流程如图1-4所示
图1-4 示例thread1.c的执行流程
图1-4中的虚线代表执行流程，向下的箭头指的是执行流，横向箭头是函数调用。
接下来，可以尝试将上述示例的第15行sleep函数的调用语句改为sleep(2)。运行之后大家会发现不会再像之前那样打印5次"running thread"字符串。因为main函数返回后整个进程将被销毁，如图1-5所示
图1-5 终止进程和线程
正因如此，我们之前的示例中通过调用sleep函数向线程提供了充足的时间
那么，如果我们希望等线程执行完毕，再结束程序，是不是一定要调用sleep函数？如果是，那么又牵扯出一个问题了，线程是在何时执行完毕呢？并非所有的程序都像thread1.c一样可预测线程的执行时间。那么，为了等待线程执行完毕，难道我们要用一个非常大的数作为sleep的参数吗？那这样就算线程可以执行完，程序依然在休眠，造成计算机资源的浪费是一定的。那么，针对这一困境，是否有解决方案呢？当然是有的，那就是pthread_join函数
#include <pthread.h> int pthread_join(pthread_t thread, void ** status);//成功时返回0，失败时返回其他值
- thread： thread所对应的线程终止后才会从pthread_join函数返回，换言之调用该函数后当前线程会一直阻塞到thread对应的线程执行完毕后才返回
- status：保存线程的main函数返回值的指针变量地址值
thread2.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
void *thread_main(void *arg);
int main(int argc, char *argv[])
{
pthread_t t_id;
int thread_param = 5;
void *thr_ret;
if (pthread_create(&t_id, NULL, thread_main, (void *)&thread_param) != 0)
{
puts("pthread_create() error");
return -1;
};
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);
return 0;
}
void *thread_main(void *arg)
{
int i;
int cnt = *((int *)arg);
char *msg = (char *)malloc(sizeof(char) * 50);
strcpy(msg, "Hello, I'am thread~ \n");
for (i = 0; i < cnt; i++)
{
sleep(1); puts("running thread");
}
return (void *)msg;
}
- 第19行：main函数中，针对第13行创建的线程调用pthread_join函数，因此，main函数将等待ID保存在t_id变量中的线程终止
- 第11、19、41行：第41行返回的值将保存到第19行第二个参数thr_ret。需要注意的是，该返回值是thread_main函数内部动态分配的内存空间地址值
编译thread2.c并运行
# gcc thread2.c -o thread2 -lpthread # ./thread2 running thread running thread running thread running thread running thread Thread return message: Hello, I'am thread~
接下来我们来看thread2.c的执行流程图，如图1-6所示
图1-6 调用pthread_join函数
可在临界区内调用的函数
之前的示例只创建一个线程，接下来的示例将创建多个线程。当然，无论创建多少个线程，其创建方法没有区别。但关于线程的运行需要考虑“多个线程同时调用函数时（执行时）可能产生的问题”。这类函数内部存在临界区，也就是说，多个线程同时执行这部分代码时，可能引起问题。根据临界区是否引起问题，函数可分为两类：
- 线程安全函数
- 非线程安全函数
线程安全函数被多个线程同时调用不会发生问题，反之，非线程安全函数被调用时就会出现问题。
下面我们介绍一个示例，将计算1到10的和，但并不是在main函数中计算，而是创建两个线程，其中一个线程计算1到5的和，另一个线程计算6到10的和，main函数只负责输出结果。这种方式的编程模型称为“工作线程模型”。计算1到5之和与计算6到10之和的线程将成为main线程管理的工作。最后，在给出示例代码之前先给出程序执行流程图，如图1-7所示
图1-7 示例thread3.c的执行流程
thread3.c
#include <stdio.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);
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
编译thread3.c 并运行
# gcc thread3.c -o thread3 -lpthread # ./thread3 result: 55
运行结果是55，虽然正确，但示例本身存在问题。此处存在临界区相关问题，因此再介绍另一示例，该示例与上述示例相似，只是增加了发生临界区相关错误的可能性
thread4.c
#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);
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;
}
上述示例共创建100个线程，其中一半执行thread_inc函数中的代码，另一半则执行thread_des函数中的代码，全局变量sum经过增减后的值应还是0，但是，我们在编译执行下程序
# gcc thread4.c -o thread4 -lpthread # ./thread4 sizeof long long: 8 result: 10862532
可以看到，结果并非我们预想的那样。虽然暂时不清楚原因，但可以肯定，冒然使用线程对变量进行操作，是有可能发生问题的。那么，这是什么问题？如何解决，我们会在后面的一章介绍
