C++网络编程（六）：多线程并发服务器

目录

引入线程线程创建及运行线程安全工作线程模型线程存在的问题和临界区线程同步互斥量信号量 线程的销毁多线程并发服务器端的实现参考资料

引入线程

在C++网络编程（四）：多进程并发服务器一文中，使用fork函数实现了多进程并发服务器，但是也提到了一些问题：

fork是昂贵的。fork时需要复制父进程的所有资源，包括内存映象、描述字等；目前的实现使用了一种写时拷贝（copy-on-write）技术，可有效避免昂贵的复制问题，但fork仍然是昂贵的;fork子进程后，父子进程间、兄弟进程间的通信需要进程间通信IPC机制，给通信带来了困难； 多进程在一定程度上仍然不能有效地利用系统资源系统中进程个数也有限制。

除此之外最重要的还有一点：每秒少则数十次、多则上千次的“上下文切换”是创建进程的最大开销。

为了保持多进程优点并克服缺点，我们需要引入线程，线程具有以下优点：

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

具体原因如下：多个线程之间会共享全局变量和堆等资源，具体可见多线程之间共享哪些资源？，这种方式可以带来上述的两种优点：

上下文切换时不需要切换全局数据区和堆可以利用全局数据区和堆交换数据

线程创建及运行

线程具有单独的执行流，需要单独定义线程的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的变量地址值。 attr：用于传递线程属性的参数，传递NULL时创建默认属性的线程 start_routine：相当于线程main函数的、在单独执行流中执行的函数地址值（函数指针）。 arg：通过第三个参数传递调用函数时包含传递参数信息的变量地址值。

代码示例：

thread1.c

#include<stdio.h> #include<pthread.h> void *thread_main(void *arg); int main(){ 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; }

使用以下命令编译运行（-l用于指定动态链接库）：

gcc thread1.c -o thread1 -lpthread ./thread1

运行结果：

（注：linux的sleep以秒为单位）

thread1.c的执行流程如下：

显然，如果我们把上面代码中的sleep(10)改成sleep(2)，就不会输出5次“running thread”了，因为main函数返回后整个进程将被销毁，执行过程将变成下面这样：

由此可以看出，为线程提供足够的运行时间是很重要的一件事情，但如果我们使用sleep设定一个时间就相当于要预测程序的执行流程，这是不可能准确预测的事情。

因此，我们不用sleep函数，而是通常利用pthread_join函数来控制线程的执行流，如下：

#include<pthread.h> int pthread_join(pthread_t thread,void ** status); 返回值：成功返回0，失败返回其他值 参数： thread:该参数值ID的线程终止后才会从函数返回 status:保存线程的main函数返回值的指针变量地址值

调用该函数的进程或线程会进入等待状态，直到第一个参数为ID的线程终止为止，而且可以得到线程的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; // 请求创建一个线程，从 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); 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'am thread~ \n"); for (int i = 0; i < cnt; i++) { sleep(1); puts("running thread"); } return (void *)msg; //返回值是 thread_main 函数中内部动态分配的内存空间地址值 }

使用以下命令编译运行（-l用于指定动态链接库）：

gcc thread2.c -o thread2 -lpthread ./thread1

运行结果: 执行流程图如下：

线程安全

我们需要考虑多个线程同时执行临界区代码带来的问题，我们可将函数分为：

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

线程安全函数被多个线程同时调用也不会引发问题，在linux中线程安全函数的名称后缀通常为_r，通过声明头文件前定义_REENTRANT宏可以自动将函数名gethostbyname变成gethostbyname_r，具体可见-D_REENTRANT 宏作用。

同时我们可以不必为了上述宏定义特意添加#define语句，可以在编译时通过添加-D_REENTRANT选项定义宏。

如：

gcc -D_REENTRANT mythread.c -o mthread -lpthread

工作线程模型

接下来介绍创建多个线程的情况。

比如我们要计算1到10的和，创建两个线程，一个线程计算1到5的和，另一个线程计算6-10的和，main函数只负责输出运算结果。这种编程模型叫做“工作线程模型”，计算1到5之和与计算6到10之和的线程将成为main线程管理的工作。

执行流程如下：

代码示例：

注意以下代码有临界区相关问题

#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，因此示例本身是存在问题的，仅供体会工作线程模型的用法。

线程存在的问题和临界区

多个线程同时访问同一变量会带来问题，考虑下述代码：

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; }

上述代码看起来运行结果应该为0，然而运行结果如下：

而且运行结果每次都不同。

这是为什么呢？

因为多个线程同时对全局变量num进行操作，导致了无数次以下类似情况的出现：当一个线程A进行加1操作时可能还没来得及将加1后的值（比如加1后的值为100）保存到变量num中，线程B通过切换得到CPU资源，执行流程就跳转到了同样进行加1操作的线程B中，这次线程B成功地完成对num值加1的操作，此时num变为100。回到线程1中继续完成保存的操作，此时线程1将自己的运算结果100再次写入num中。最终导致了num的结果为100，只加了一次1，而预期结果应该是101。

这说明了多线程编程存在同时操作同一全局变量的问题，因此“同步”是必不可少的一点。

临界区：

临界区就是访问和操作共享数据的代码段，如上述例子中的num+=1和num-=1就是临界区，由此可见临界区并非num本身，而是访问num的两条语句。

这两条语句都可能由多个线程同时运行，也是引起问题的直接原因，产生的问题可以有下面3种情况：

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

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

线程同步

为了解决上述问题，我们需要使用线程同步。

想要深入理解同步方法可以看Linux内核同步。

下面介绍互斥量和信号量。

互斥量

互斥锁（英语：英语：Mutual exclusion，缩写 Mutex）是一种用于多线程编程中，防止两条线程同时对同一公共资源（比如全域变量）进行读写的机制。该目的通过将代码切片成一个一个的临界区域（critical section）达成。临界区域指的是一块对公共资源进行访问的代码，并非一种机制或是算法。一个程序、进程、线程可以拥有多个临界区域，但是并不一定会应用互斥锁。

通俗的说就互斥量就是一把优秀的锁，当临界区被占据的时候就上锁，等占用完毕然后再放开。

下面是互斥量的创建及销毁函数。

#include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr); int pthread_mutex_destroy(pthread_mutex_t *mutex); /* 成功时返回 0，失败时返回其他值 mutex : 创建互斥量时传递保存互斥量的变量地址值，销毁时传递需要销毁的互斥量地址 attr : 传递即将创建的互斥量属性，没有特别需要指定的属性时传递 NULL */

下面是利用互斥量锁住或释放临界区时使用的函数。

#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 的函数无法摆脱阻塞状态。这种情况称为「死锁」。

下面是利用互斥量解决上面示例thread4.c中遇到问题的代码：

mutex.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; 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); //销毁互斥量 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; pthread_mutex_lock(&mutex); for (i = 0; i < 50000000; i++) num -= 1; pthread_mutex_unlock(&mutex); return NULL; }

编译运行：

gcc mutex.c -D_REENTRANT -o mutex -lpthread ./mutex

运行结果：

result: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; }

以上代码的临界区划分范围较大，但这是考虑如下优点所做的决定:

最大限度减少互斥量 lock unlock 函数的调用次数

信号量

信号量（英语：Semaphore）又称为信号标，是一个同步对象，用于保持在0至指定最大值之间的一个计数值。当线程完成一次对该semaphore对象的等待（wait）时，该计数值减一；当线程完成一次对semaphore对象的释放（release）时，计数值加一。当计数值为0，则线程等待该semaphore对象不再能成功直至该semaphore对象变成signaled状态。semaphore对象的计数值大于0，为signaled状态；计数值等于0，为nonsignaled状态.

semaphore对象适用于控制一个仅支持有限个用户的共享资源，是一种不需要使用忙碌等待（busy waiting）的方法。

信号量的概念是由荷兰计算机科学家艾兹赫尔·戴克斯特拉（Edsger W. Dijkstra）发明的，广泛的应用于不同的操作系统中。在系统中，给予每一个进程一个信号量，代表每个进程当前的状态，未得到控制权的进程会在特定地方被强迫停下来，等待可以继续进行的信号到来。如果信号量是一个任意的整数，通常被称为计数信号量（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); /* 成功时返回 0 ，失败时返回其他值 sem : 创建信号量时保存信号量的变量地址值，销毁时传递需要销毁的信号量变量地址值 pshared : 传递其他值时，创建可由多个继承共享的信号量；传递 0 时，创建只允许 1 个进程内部使用的信号量。需要完成同一进程的线程同步，故为0 value : 指定创建信号量的初始值 */

上述的 pshared 参数超出了我们的关注范围，故默认向其传递为 0 。下面是信号量中相当于互斥量 lock unlock 的函数。

#include <semaphore.h> int sem_post(sem_t *sem); int sem_wait(sem_t *sem); /* 成功时返回 0 ，失败时返回其他值 sem : 传递保存信号量读取值的变量地址值，传递给 sem_post 的信号量增1，传递给 sem_wait 时信号量减一 */

调用 sem_init 函数时，操作系统将创建信号量对象，此对象中记录这「信号量值」（Semaphore Value）整数。该值在调用 sem_post 函数时增加 1 ，调用sem_wait 函数时减一。但信号量的值不能小于 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 次，完成后输出总和并退出程序。

下面是代码：

semaphore.c

#include <stdio.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); 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; }

编译运行：

gcc semaphore.c -D_REENTRANT -o sema -lpthread ./sema

运行结果：

Input num:1 Input num:2 Input num:3 Input num:4 Input num:5 Result:15

线程的销毁

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

调用 pthread_join 函数调用 pthread_detach 函数

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

#include <pthread.h> int pthread_detach(pthread_t th); /* 成功时返回 0 ，失败时返回其他值 thread : 终止的同时需要销毁的线程 ID */

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

需要注意：pthread_detach函数只是使线程处于被分离状态，不会让线程终止。当我们不需要等待一个线程，同时对线程的返回值不感兴趣，可以设置这个线程为被分离状态，让系统在线程退出的时候自动回收它所占用的资源。

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

下面是多个客户端之间可以交换信息的简单聊天程序。

chat_server.c

#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 mutx; 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(&mutx, 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(&mutx); //上锁 clnt_socks[clnt_cnt++] = clnt_sock; //写入新连接 pthread_mutex_unlock(&mutx); //解锁 pthread_create(&t_id, NULL, handle_clnt, (void *)&clnt_sock); //创建线程为新客户端服务，并且把clnt_sock作为参数传递 pthread_detach(t_id); //引导线程销毁，不阻塞 printf("Connected client IP: %s \n", inet_ntoa(clnt_adr.sin_addr)); //客户端连接的ip地址 } close(serv_sock); return 0; } void *handle_clnt(void *arg) { int clnt_sock = *((int *)arg); int str_len = 0, i; char msg[BUF_SIZE]; while ((str_len = read(clnt_sock, msg, sizeof(msg))) != 0) send_msg(msg, str_len); //接收到消息为0，代表当前客户端已经断开连接 pthread_mutex_lock(&mutx); for (i = 0; i < clnt_cnt; i++) //删除没有连接的客户端 { if (clnt_sock == clnt_socks[i]) { while (i++ < clnt_cnt - 1) clnt_socks[i] = clnt_socks[i + 1]; break; } } clnt_cnt--; pthread_mutex_unlock(&mutx); close(clnt_sock); return NULL; } void send_msg(char *msg, int len) //向连接的所有客户端发送消息 { int i; pthread_mutex_lock(&mutx); for (i = 0; i < clnt_cnt; i++) write(clnt_socks[i], msg, len); pthread_mutex_unlock(&mutx); } void error_handling(char *msg) { fputs(msg, stderr); fputc('\n', stderr); exit(1); }

chat_clnt.c

#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; 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 将同时发生变化。因此下列情形会导致数据不一致，从而引发错误：

线程 A 从数组 clnt_socks 中删除套接字信息，同时线程 B 读取 clnt_cnt 变量线程 A 读取变量 clnt_cnt ，同时线程 B 将套接字信息添加到 clnt_socks 数组

编译运行：

gcc chat_server.c -D_REENTRANT -o cserv -lpthread gcc chat_clnt.c -D_REENTRANT -o cclnt -lpthread ./cserv 9191 ./cclnt 127.0.0.1 9191 张三 ./cclnt 127.0.0.1 9191 李四

运行结果：

参考资料

《TCP IP网络编程》尹圣雨Linux并发服务器编程之多线程并发服务器