本文介绍了TCP的三次握手和四次挥手过程，以及滑动窗口机制在流量控制中的作用。同时，讨论了在实现高并发服务器时，如何通过多线程或多进程处理多个客户端连接请求，包括使用非阻塞I/O和多进程/线程策略。并展示了函数封装的思想，提供了错误处理的函数示例。
目录
1 内容回顾
数据的通信过程: 就是发送之前层层打包, 对方收到之后再层层解包.
7层模型和4层模型:
协议格式: TCP和UDP
UDP: 端口
TCP: 端口, 有序号和确认序号, 目的是使数据有序且不丢失.
IP: 32位IP, 网络字节序, TTL(下一跳), TTL的目的是防止网络阻塞.
socket概念: 一个文件描述符, 2个缓冲区, 2个队列
服务端的编码流程:
创建socket
将lfd与IP和端口进行绑定
侦听listen
将socket有主动态变为被动态
调用accept函数阻塞等待新的连接到来
while循环read 和 write
close文件描述符lfd和cfd
客户端的编码流程:
创建socket
调用connect连接远端的服务器
while循环 read 和 write
close文件描述符cfd
2 学习目标
- 掌握三次握手建立连接过程
- 掌握四次握手关闭连接的过程
- 掌握滑动窗口的概念
- 掌握错误处理函数封装
- 实现多进程并发服务器
- 实现多线程并发服务器
3 三次握手和四次挥手
思考: 为什么TCP是面向连接的安全可靠的传输????
TCP是面向连接的安全的数据传输, 在客户端与服务端建立建立的时候要经过三次握手的过程, 在客户端与服务端断开连接的时候要经历四次挥手的过程, 下图是客户端与服务端三次握手建立连接, 数据传输和断开连接四次挥手的全过程.
TCP时序:
说明讲义中图的含义.
SYN: 表示请求, ACK:表示确认
100（0）后面的0代表携带数据的个数
<mss 1460>1460代表服务器每次可以接受的最大数量
服务端发送的SYN和客户端发送的SYN本身也会占1位.
单独讲解三次握手过程, 以图解形式说明.
上图中ACK表示确认序号, 确认序号的值是对方发送的序号值+数据的长度, 特别注意的是SYN和FIN本身也会占用一位.
注: SYS----->synchronous
ACK----->acknowledgement
FIN------>finish
三次握手和四次挥手的过程都是在内核实现的.
下图是TCP数据报格式
窗口大小: 指的是缓冲区大小
通信的时候不再需要SYN标识位了, 只有在请求连接的时候需要SYN标识位.
传输数据的时候的随机序号seq就是最近一次对方发送给自己的ACK的随机序号值, 而发给对方的ACK就是上次刚刚发给对方的ACK的值.
图中发送的ACK确认包表示给对方发送数据的一个确认, 表示你发送的数据我都收到了, 同时告诉对方下次发送该序号开始的数据.
由于每次发送数据都会收到对方发来的确认包, 所以可以确认对方是否收到了, 若没有收到对方发来的确认包, 则会进行重发.
mss: 最大报文长度, 告诉对方我这边最多一次能收多少, 你不能超过这个长度.
win: 表示告诉对方我这边缓存大小最大是多少.
4 滑动窗口
主要作用: 滑动窗口主要是进行流量控制的.
见下图:如果发送端发送的速度较快，接收端接收到数据后处理的速度较慢，而接收缓冲区的大小是固定的，就会导致接收缓冲区满而丢失数据。TCP协议通过“滑动窗口（Sliding Window）”机制解决这一问题。
详细说明参考讲义
SYN代表第一次连接请求 ACK表示确认数据请求
图中win表示告诉对方我这边缓冲区大小是多少, mss表示告诉对方我这边最多一次可以接收多少数据, 你最好不要超过这个长度.
在客户端给服务端发包的时候, 不一定是非要等到服务端返回响应包, 由于客户端知道服务端的窗口大小, 所以可以持续多次发送, 当发送数据达到对方窗口大小了就不再发送, 需要等到对方进行处理, 对方处理之后可继续发送.
mss和MTU
MTU: 最大传输单元
MTU:通信术语最大传输单元（Maximum Transmission Unit，MTU）
是指一种通信协议的某一层上面所能通过的最大数据包大小（以字节为 单位). 最大传输单元这个参数通常与通信接口有关（网络接口卡、串 口等), 这个值如果设置为太大会导致丢包重传的时候重传的数据量较大, 图中的最大值是1500, 其实是一个经验值.
mss: 最大报文长度, 只是在建立连接的时候, 告诉对方我最大能够接收多少 数据, 在数据通信的过程中就没有mss了.
5 函数封装思想
函数封装的思想-处理异常情况
结合man-page和errno进行封装.
在封装的时候起名可以把第一个函数名的字母大写, 如socket可以封装成Socket, 这样可以按shift+k进行搜索, shift+k搜索函数说明的时候不区分大小写, 使用man page也可以查看, man page对大小写不区分.
像accept，read这样的能够引起阻塞的函数，若被信号打断，由于信号的优先级较高, 会优先处理信号, 信号处理完成后，会使accept或者read解除阻塞, 然后返回, 此时返回值为 -1，设置errno=EINTR;
errno=ECONNABORTED表示连接被打断,异常.
errno宏:
在/usr/include/asm-generic/errno.h文件中包含了errno所有的宏和对应的错误描述信息.
粘包的概念
粘包: 多次数据发送, 收尾相连, 接收端接收的时候不能正确区分第一次发 送多少, 第二次发送多少.
粘包问题分析和解决??
方案1: 包头+数据
如4位的数据长度+数据 -----------> 00101234567890
其中0010表示数据长度, 1234567890表示10个字节长度的数据.
另外, 发送端和接收端可以协商更为复杂的报文结构, 这个报文结 构就相当于双方约定的一个协议.
方案2: 添加结尾标记.
如结尾最后一个字符为\n \$等.
方案3: 数据包定长
如发送方和接收方约定, 每次只发送128个字节的内容, 接收方接收定 长128个字节就可以了.
下面为封装的一些常用的网络接口函数代码
头文件
#ifndef __WRAP_H_
#define __WRAP_H_
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.h>
//错误输出函数
void perr_exit(const char *s);
//服务器端接收函数 用于通信
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr);
//绑定函数
int Bind(int fd, const struct sockaddr *sa, socklen_t salen);
//连接函数
int Connect(int fd, const struct sockaddr *sa, socklen_t salen);
//服务器端监听函数
int Listen(int fd, int backlog);
//初始化socket函数
int Socket(int family, int type, int protocol);
//读取数据函数
ssize_t Read(int fd, void *ptr, size_t nbytes);
//写数据函数
ssize_t Write(int fd, const void *ptr, size_t nbytes);
//关闭文件描述符函数
int Close(int fd);
//读取n个数据
ssize_t Readn(int fd, void *vptr, size_t n);
//写n个数据
ssize_t Writen(int fd, const void *vptr, size_t n);
//用于读取单个字符函数
ssize_t my_read(int fd, char *ptr);
//读取一行函数
ssize_t Readline(int fd, void *vptr, size_t maxlen);
//TCP绑定函数 里面保护初始化socket和bind
int tcp4bind(short port,const char *IP);
#endif //__WRAP_H_cpp文件
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <strings.h>
//错误输出函数
void perr_exit(const char *s)
{
perror(s);
exit(-1);
}
//服务器端接收函数 用于通信
int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
{
int n;
again:
if ((n = accept(fd, sa, salenptr)) < 0)
{
//ECONNABORTED 连接已终止
//EINTR 系统调用被在有效连接到达之前捕获的信号中断；见信号（7）
if ((errno == ECONNABORTED) || (errno == EINTR))
goto again;
else
perr_exit("accept error");
}
return n;
}
//绑定函数
int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = bind(fd, sa, salen)) < 0)
perr_exit("bind error");
return n;
}
//连接函数
int Connect(int fd, const struct sockaddr *sa, socklen_t salen)
{
int n;
if ((n = connect(fd, sa, salen)) < 0)
perr_exit("connect error");
return n;
}
//服务器端监听函数
int Listen(int fd, int backlog)
{
int n;
if ((n = listen(fd, backlog)) < 0)
perr_exit("listen error");
return n;
}
//初始化socket函数
int Socket(int family, int type, int protocol)
{
int n;
if ((n = socket(family, type, protocol)) < 0)
perr_exit("socket error");
return n;
}
//读取数据函数
ssize_t Read(int fd, void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = read(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
//写数据函数
ssize_t Write(int fd, const void *ptr, size_t nbytes)
{
ssize_t n;
again:
if ( (n = write(fd, ptr, nbytes)) == -1) {
if (errno == EINTR)
goto again;
else
return -1;
}
return n;
}
//关闭文件描述符函数
int Close(int fd)
{
int n;
if ((n = close(fd)) == -1)
perr_exit("close error");
return n;
}
/*读取n个数据 参三: 应该读取的字节数*/
ssize_t Readn(int fd, void *vptr, size_t n)
{
size_t nleft; //usigned int 剩余未读取的字节数
ssize_t nread; //int 实际读到的字节数
char *ptr;
ptr = vptr;
nleft = n;
//重复循环读取数据
while (nleft > 0) {
if ((nread = read(fd, ptr, nleft)) < 0) {
if (errno == EINTR)
nread = 0;
else
return -1;
} else if (nread == 0)
break;
//指针根据读取的数据进行移动
nleft -= nread;
ptr += nread;
}
return n - nleft;
}
//写n个数据
ssize_t Writen(int fd, const void *vptr, size_t n)
{
size_t nleft;
ssize_t nwritten;
const char *ptr;
ptr = vptr;
nleft = n;
while (nleft > 0) {
if ( (nwritten = write(fd, ptr, nleft)) <= 0) {
if (nwritten < 0 && errno == EINTR)
nwritten = 0;
else
return -1;
}
nleft -= nwritten;
ptr += nwritten;
}
return n;
}
//用于读取单个字符函数
static ssize_t my_read(int fd, char *ptr)
{
//静态变量 再进来就不会进行初始化
static int read_cnt;
static char *read_ptr;
static char read_buf[100];
if (read_cnt <= 0) {
again:
if ( (read_cnt = read(fd, read_buf, sizeof(read_buf))) < 0) {
if (errno == EINTR)
goto again;
return -1;
} else if (read_cnt == 0)
return 0;
read_ptr = read_buf;
}
read_cnt--;
*ptr = *read_ptr++;
return 1;
}
//读取一行函数
ssize_t Readline(int fd, void *vptr, size_t maxlen)
{
ssize_t n, rc;
char c, *ptr;
ptr = vptr;
for (n = 1; n < maxlen; n++) {
if ( (rc = my_read(fd, &c)) == 1) {
*ptr++ = c;
if (c == '\n')
break;
} else if (rc == 0) {
*ptr = 0;
return n - 1;
} else
return -1;
}
*ptr = 0;
return n;
}
//TCP绑定函数 里面保护初始化socket和bind
int tcp4bind(short port,const char *IP)
{
struct sockaddr_in serv_addr;
int lfd = Socket(AF_INET,SOCK_STREAM,0);
//bzero初始化函数 相当于memset
bzero(&serv_addr,sizeof(serv_addr));
if(IP == NULL){
//如果这样使用 0.0.0.0,任意ip将可以连接
serv_addr.sin_addr.s_addr = INADDR_ANY;
}else{
if(inet_pton(AF_INET,IP,&serv_addr.sin_addr.s_addr) <= 0){
perror(IP);//转换失败
exit(1);
}
}
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(port);
Bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
return lfd;
}
6 高并发服务器
如何支持多个客户端---支持多并发的服务器
由于accept和read函数都会阻塞, 如当read的时候, 不能调用accept接受新的连接, 当accept阻塞等待的时候不能read读数据.
第一种方案: 使用多进程, 可以让父进程接受新连接, 让子进程处理与客户端通信
思路: 让父进程accept接受新连接, 然后fork子进程, 让子进程处理通信, 子进程处理完成后退出, 父进程使用SIGCHLD信号回收子进程.
代码实现:
第二种方案: 使用多线程, 让主线程接受新连接, 让子线程处理与客户端通信; 使用多线程要将线程设置为分离属性, 让线程在退出之后自己回收资源
思考: 如何不使用多进程或者多线程完成多个客户端的连接请求
可以将accept和read函数设置为非阻塞, 调用fcntl函数可以将文件描述符设置为非阻塞, 让后再while循环中忙轮询.
解决办法1:
将cfd设置为非阻塞: fcntl
假如有多个客户端连接请求, cfd只会保留最后一个文件描述符的值
解决方法2:
使用多进程: 让父进程监听接受新的连接, 子进程处理新的连接(接收和发送数据);
父进程还负责回收子进程
处理流程:
1 创建socket, 得到一个监听的文件描述符lfd---socket()
2 将lfd和IP和端口port进行绑定-----bind();
3 设置监听----listen()
4 进入while(1)
{
//等待有新的客户端连接到来
cfd = accept();
//fork一个子进程, 让子进程去处理数据
pid = fork();
if(pid<0)
{
exit(-1);
}
else if(pid>0)
{
//关闭通信文件描述符cfd
close(cfd);
}
else if(pid==0)
{
//关闭监听文件描述符
close(lfd);
//收发数据
while(1)
{
//读数据
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
break;
}
//发送数据给对方
write(cfd, buf, n);
}
close(cfd);
//下面的exit必须有, 防止子进程再去创建子进程
exit(0);
}
}
close(lfd);
多进程代码操作如下：
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <sys/wait.h>
#include "warp.h"
//父子进程中共享的内容
//文件描述符
//mmap映射区
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//绑定数据
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(8888); //host代表主机 s短整型 l长整型
serv.sin_addr.s_addr = htonl(INADDR_ANY); //表示使用本地任意可用IP
if((Bind(lfd, (struct sockaddr *)&serv, sizeof(serv))) < 0)
{
return -1;
}
//监听数据
Listen(lfd, 128);
//多进程进行处理
int cfd;
pid_t fd;
struct sockaddr_in client;
char sIP[16];
socklen_t len;
while (1)
{
len = sizeof(client);
memset(sIP, 0x00, sizeof(sIP));
//获取cfd之后创建子进程进行处理
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
//输出连接的客户端信息
printf("CLient Ip:[%s], Port:[%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
if (cfd > 0)
{
fd = fork();
//创建失败
if(fd < 0)
{
exit(-1);
}
//父进程
else if(fd > 0)
{
//关闭通信接口，子进程负责通信
Close(cfd);
pid_t wpid;
int status;
//回收子进程
while (1)
{
//-1代表等待任意子进程 WNOHANG:不阻塞
wpid = waitpid(-1, &status, WNOHANG);
//无线程退出
if(wpid == 0)
{
continue;
}
else if(wpid == -1)//子进行已经全部回收
{
printf("child is all killed\n");
break;
}
else if(wpid > 0)//有子进程退出
{
if(WIFEXITED(status))
{
printf("normal exit, status==[%d]\n", WEXITSTATUS(status));
}
else if(WIFSIGNALED(status))
{
printf("killed by signo==[%d]\n", WTERMSIG(status));
}
}
}
}
//子进程
else if(fd == 0)
{
//关闭监听接口 因为使用的是多进程，实际关闭的只是当前进程复制的lfd,实际内核没有完全断开连接
//如果使用多线程，则会关闭，因为多线程之间共享资源
Close(lfd);
//进行读数据
int n = 0;
int i = 0;
char buf[1024];
while (1)
{
//读取数据
memset(buf, 0x00, sizeof(buf));
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client close\n");
break;
}
printf("client port:[%d]\n", ntohs(client.sin_port));
printf("buf = [%s], length = [%d]\n", buf, n);
//发送数据
for (i = 0; i < n; i++)
{
//小写转大写
buf[i] = toupper(buf[i]);
}
write(cfd, buf, n);
}
Close(cfd);
//下面的exit必须有, 防止子进程再去创建子进程
exit(0);
}
}
}
return 0;
}回收子进程有多种方法，下面采用信号的方法对进程进行回收，代码如下
#include <arpa/inet.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <sys/wait.h>
#include "warp.h"
//父子进程中共享的内容
//文件描述符
//mmap映射区
//信号处理函数
void waitchild(int signo)
{
pid_t wpid;
while(1)
{
wpid = waitpid(-1, NULL, WNOHANG);
if(wpid>0)
{
printf("child exit, wpid==[%d]\n", wpid);
}
else if(wpid==0 || wpid==-1)
{
break;
}
}
}
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//绑定数据
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(8888); //host代表主机 s短整型 l长整型
serv.sin_addr.s_addr = htonl(INADDR_ANY); //表示使用本地任意可用IP
if((Bind(lfd, (struct sockaddr *)&serv, sizeof(serv))) < 0)
{
return -1;
}
//监听数据
Listen(lfd, 128);
//多进程进行处理
int cfd;
pid_t fd;
struct sockaddr_in client;
char sIP[16];
socklen_t len;
while (1)
{
len = sizeof(client);
memset(sIP, 0x00, sizeof(sIP));
//获取cfd之后创建子进程进行处理
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
//提前阻塞，防止未注册信号信号就被触发
//阻塞SIGCHLD信号
sigset_t mask;
//初始化
sigemptyset(&mask);
//添加到序列中
sigaddset(&mask, SIGCHLD);
sigprocmask(SIG_BLOCK, &mask, NULL);
//输出连接的客户端信息
printf("CLient Ip:[%s], Port:[%d]\n", inet_ntop(AF_INET, &client.sin_addr.s_addr, sIP, sizeof(sIP)), ntohs(client.sin_port));
if (cfd > 0)
{
fd = fork();
//创建失败
if(fd < 0)
{
exit(-1);
}
//父进程
else if(fd > 0)
{
//关闭通信接口，子进程负责通信
Close(cfd);
//注册SIGCHLD信号处理函数
struct sigaction act;
act.sa_handler = waitchild;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaction(SIGCHLD, &act, NULL);
//解除对SIGCHLD的阻塞
sigprocmask(SIG_UNBLOCK, &mask, NULL);
}
//子进程
else if(fd == 0)
{
//关闭监听接口 因为使用的是多进程，实际关闭的只是当前进程复制的lfd,实际内核没有完全断开连接
//如果使用多线程，则会关闭，因为多线程之间共享资源
Close(lfd);
//进行读数据
int n = 0;
int i = 0;
char buf[1024];
while (1)
{
//读取数据
memset(buf, 0x00, sizeof(buf));
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client close\n");
break;
}
printf("client port:[%d]\n", ntohs(client.sin_port));
printf("buf = [%s], length = [%d]\n", buf, n);
//发送数据
for (i = 0; i < n; i++)
{
//小写转大写
buf[i] = toupper(buf[i]);
}
write(cfd, buf, n);
}
Close(cfd);
//下面的exit必须有, 防止子进程再去创建子进程
exit(0);
}
}
}
return 0;
}多线程的处理流程如下：
多线程版本的服务器开发流程:
{
1 创建socket, 得到一个监听的文件描述符lfd---socket()
2 将lfd和IP和端口port进行绑定-----bind();
3 设置监听----listen()
4 while(1)
{
//接受新的客户端连接请求
cfd = accept();
//创建一个子线程
pthread_create(&threadID, NULL, thread_work, &cfd);
//设置线程为分离属性
pthread_detach(threadID);
}
close(lfd);
}
子线程执行函数:
void *thread_work(void *arg)
{
//获得参数: 通信文件描述符
int cfd = *(int *)arg;
while(1)
{
//读数据
n = read(cfd, buf, sizeof(buf));
if(n<=0)
{
break;
}
//发送数据
write(cfd, buf, n);
}
close(cfd);
}
多线程操作代码如下
//多线程版本的服务器
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <ctype.h>
#include <pthread.h>
#include "warp.h"
typedef struct info
{
int cfd; //若为-1表示可用, 大于0表示已被占用
int idx;
pthread_t thread;
struct sockaddr_in client;
}INFO;
INFO thInfo[1024];
//线程执行函数
void *thread_work(void *arg)
{
//使用指针进行接收 这样可以改变原来的值
INFO *p = (INFO *)arg;
printf("idx==[%d]\n", p->idx);
//输出客户端的信息
char sIP[16];
memset(sIP, 0x00, sizeof(sIP));
printf("new client:[%s][%d]\n", inet_ntop(AF_INET, &(p->client.sin_addr.s_addr), sIP, sizeof(sIP)), ntohs(p->client.sin_port));
int n;
//获取pid
int cfd = p->cfd;
//获取客户端信息
struct sockaddr_in client;
memcpy(&client, &(p->client), sizeof(client));
char buf[1024];
while(1)
{
memset(buf, 0x00, sizeof(buf));
//读数据
n = Read(cfd, buf, sizeof(buf));
if(n<=0)
{
printf("read error or client closed, n==[%d]\n", n);
Close(cfd);
p->cfd =-1; //设置为-1表示该位置可用
pthread_exit(NULL);
}
for(int i=0; i<n; i++)
{
buf[i] = toupper(buf[i]);
}
//发送数据
Write(cfd, buf, n);
}
}
//初始化结构体函数
void init_thInfo()
{
int i = 0;
for(i=0; i<1024; i++)
{
thInfo[i].cfd = -1;;
}
}
//寻找可用索引函数
int findIndex()
{
int i;
for(i=0; i<1024; i++)
{
if(thInfo[i].cfd==-1)
{
break;
}
}
if(i==1024)
{
return -1;
}
return i;
}
int main()
{
//创建socket
int lfd = Socket(AF_INET, SOCK_STREAM, 0);
//设置端口复用
int opt = 1;
setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(int));
//绑定--将lfd 和 IP PORT绑定
struct sockaddr_in serv;
bzero(&serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_port = htons(8888);
serv.sin_addr.s_addr = htonl(INADDR_ANY);
Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));
//监听
Listen(lfd, 128);
//初始化
init_thInfo();
int cfd;
int ret;
int idx;
socklen_t len;
pthread_t thread;
struct sockaddr_in client;
while(1)
{
len = sizeof(client);
bzero(&client, sizeof(client));
//获得一个新的连接
cfd = Accept(lfd, (struct sockaddr *)&client, &len);
//创建一个子进程, 让子进程处理连接---接收数据和发送数据
//找数组中空闲的位置
idx = findIndex();
if(idx==-1)
{
Close(cfd);
continue;
}
//对空闲位置的元素的成员赋值
thInfo[idx].cfd = cfd;
thInfo[idx].idx = idx;
memcpy(&thInfo[idx].client, &client, sizeof(client));
//创建子线程---该子线程完成对数据的收发
ret = pthread_create(&thInfo[idx].thread, NULL, thread_work, &thInfo[idx]);
if(ret!=0)
{
printf("create thread error:[%s]\n", strerror(ret));
exit(-1);
}
//设置子线程为分离属性
pthread_detach(thInfo[idx].thread);
}
Close(lfd);
return 0;
}
多线程处理时的三个问题
1 子线程能否关闭lfd?
子线程不能关闭监听文件描述符lfd,原因是子线程和主线程共享文件描述符而不是复制的.
2 主线程能否关闭cfd?
主线程不能关闭通信文件描述符cfd, 主线程和子线程共享一个cfd, 而不是复制的, close之后cfd就会被真正关闭.关闭之后就不能进行读写操作。
3 多个子线程共享cfd, 会有什么问题发生?
共享同一个cfd，取cfd值的时候默认保存的是最后一个连接的cfd值，会让前面连接的cfd断开连接，因此需要使用数组保存不同的cfd。
1014
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
