linux -网络编程-多线程并发服务器

目录

1.三次握手和四次挥手

2 滑动窗口

3 函数封装思想

4 高并发服务器

学习目标:

  • 掌握三次握手建立连接过程
  • 掌握四次握手关闭连接的过程
  • 掌握滑动窗口的概念
  • 掌握错误处理函数封装
  • 实现多进程并发服务器
  • 实现多线程并发服务器

1.三次握手和四次挥手

思考: 为什么TCP是面向连接的安全可靠的传输????

TCP是面向连接的安全的数据传输, 在客户端与服务端建立建立的时候要经过三次握手的过程, 在客户端与服务端断开连接的时候要经历四次挥手的过程, 下图是客户端与服务端三次握手建立连接, 数据传输和断开连接四次挥手的全过程.

TCP时序:

linux -网络编程-多线程并发服务器_第1张图片

说明讲义中图的含义.

SYN: 表示请求, ACK:表示确认

服务端发送的SYN和客户端发送的SYN本身也会占1位.

单独讲解三次握手过程, 以图解形式说明.

上图中ACK表示确认序号, 确认序号的值是对方发送的序号值+数据的长度, 特别注意的是SYN和FIN本身也会占用一位.

注: SYS----->synchronous

      ACK----->acknowledgement

       FIN------>finish

三次握手和四次挥手的过程都是在内核实现的.

下图是TCP数据报格式

linux -网络编程-多线程并发服务器_第2张图片

 窗口大小: 指的是缓冲区大小

linux -网络编程-多线程并发服务器_第3张图片

通信的时候不再需要SYN标识位了, 只有在请求连接的时候需要SYN标识位.

传输数据的时候的随机序号seq就是最近一次对方发送给自己的ACK的随机序号值, 而发给对方的ACK就是上次刚刚发给对方的ACK的值.

linux -网络编程-多线程并发服务器_第4张图片

图中发送的ACK确认包表示给对方发送数据的一个确认, 表示你发送的数据我都收到了, 同时告诉对方下次发送该序号开始的数据.

由于每次发送数据都会收到对方发来的确认包, 所以可以确认对方是否收到了, 若没有收到对方发来的确认包, 则会进行重发.

mss: 最大报文长度, 告诉对方我这边最多一次能收多少, 你不能超过这个长度.

win: 表示告诉对方我这边缓存大小最大是多少.

2 滑动窗口

主要作用: 滑动窗口主要是进行流量控制的.

见下图:如果发送端发送的速度较快,接收端接收到数据后处理的速度较慢,而接收缓冲区的大小是固定的,就会导致接收缓冲区满而丢失数据。TCP协议通过“滑动窗口(Sliding Window)”机制解决这一问题。

linux -网络编程-多线程并发服务器_第5张图片

详细说明参考讲义

图中win表示告诉对方我这边缓冲区大小是多少, mss表示告诉对方我这边最多一次可以接收多少数据, 你最好不要超过这个长度.

在客户端给服务端发包的时候, 不一定是非要等到服务端返回响应包, 由于客户端知道服务端的窗口大小, 所以可以持续多次发送, 当发送数据达到对方窗口大小了就不再发送, 需要等到对方进行处理, 对方处理之后可继续发送.

mss和MTU

MTU: 最大传输单元

MTU:通信术语最大传输单元(Maximum Transmission Unit,MTU)

是指一种通信协议的某一层上面所能通过的最大数据包大小(以字节为 单位). 最大传输单元这个参数通常与通信接口有关(网络接口卡、串 口等), 这个值如果设置为太大会导致丢包重传的时候重传的数据量较大, 图中的最大值是1500, 其实是一个经验值.

mss: 最大报文长度, 只是在建立连接的时候, 告诉对方我最大能够接收多少 数据, 在数据通信的过程中就没有mss了. 

3 函数封装思想

函数封装的思想-处理异常情况

结合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所有的宏和对应的错误描述信息.

warp.h

#ifndef __WRAP_H_
#define __WRAP_H_
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

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);
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);
ssize_t Readn(int fd, void *vptr, size_t 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);
int tcp4bind(short port,const char *IP);
#endif

warp.c

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
//绑定错误显示和退出
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) {
		if ((errno == ECONNABORTED) || (errno == EINTR))//ECONNABORTED 代表连接失败 ETINTR 代表被信号打断
			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;
}

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

/*参三: 应该读取的字节数*/
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;
}

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];//定义了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;//0 = '\0'
			return n - 1;
		} else
			return -1;
	}
	*ptr  = 0;

	return n;
}

int tcp4bind(short port,const char *IP)
{
    struct sockaddr_in serv_addr;
    int lfd = Socket(AF_INET,SOCK_STREAM,0);
    bzero(&serv_addr,sizeof(serv_addr));//清空serv_addr地址 对比 memset()
    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);
    int opt = 1;
    setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
    Bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));
    return lfd;
}

粘包的概念

粘包: 多次数据发送, 收尾相连, 接收端接收的时候不能正确区分第一次发 送多少, 第二次发送多少.

粘包问题分析和解决??

方案1: 包头+数据

如4位的数据长度+数据  -----------> 00101234567890

其中0010表示数据长度, 1234567890表示10个字节长度的数据.

另外, 发送端和接收端可以协商更为复杂的报文结构, 这个报文结 构就相当于双方约定的一个协议.

方案2: 添加结尾标记.

如结尾最后一个字符为\n \$等.

方案3: 数据包定长
如发送方和接收方约定, 每次只发送128个字节的内容, 接收方接收定 长128个字节就可以了.

wrap.c代码解读和分析.

要求能看懂代码, 会使用即可.

4 高并发服务器

如何支持多个客户端---支持多并发的服务器

由于accept和read函数都会阻塞, 如当read的时候, 不能调用accept接受新的连接, 当accept阻塞等待的时候不能read读数据.

第一种方案: 使用多进程, 可以让父进程接受新连接, 让子进程处理与客户端通信

思路: 让父进程accept接受新连接, 然后fork子进程, 让子进程处理通信, 子进程处理完成后退出, 父进程使用SIGCHLD信号回收子进程.

代码实现:

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "warp.h"

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);
     serv.sin_addr.s_addr = htonl(INADDR_ANY);

     Bind(lfd, (struct sockaddr *)&serv, sizeof(serv));

     pid_t pid;
     // 设置g监听
     Listen(lfd, 128);
     int cfd;

     struct sockaddr_in client;
     socklen_t len;

     char sIP[16];


     while (1)
     {
          len=sizeof(client);
          memset(sIP,0x00,sizeof(sIP));
          // 接受新的连接,创建一个新的子进程,g让子进程完成数据的收发的工作
          cfd = Accept(lfd, (struct sockaddr *)&client, &len);
          //打印客户端的ip地址

          printf("client:[%s],[%d]\n",inet_ntop(AF_INET,&client.sin_addr.s_addr,sIP,sizeof(sIP)),ntohs(client.sin_port));
          pid = fork();

          if (pid < 0)
          {
               perror("fork error");
               exit(-1);
          }

          // 父进程
          else if (pid > 0)
          {

               // 关闭g通信文件描述符cfd
               close(cfd);
          }

          // 子进程  --收发数据
          else if (pid == 0)
          {
               // 关闭监听文件描述符号
               close(lfd);

               int n;
               int i = 0;
               char buf[1024];

               while (1)
               {
                    // 读数据
                    n = Read(cfd, buf, sizeof(buf));
                    if (n <= 0)
                    {
                         printf("read error or client closed,n==[%d]\n", n);
                         break;
                    }

                    //将收到的数据再服务端显示出来
                    printf("[%d] -->  n==[%d],buf==[%s]\n",ntohs(client.sin_port),n,buf);

                    // 将小写转换为大写 之后再发送给客户端
                    for (i = 0; i < n; i++)
                    {
                         buf[i] = toupper(buf[i]);
                    }

                    // 发送数据
                    Write(cfd, buf, n);
               }

               close(cfd);
               // 停止,n不让子进程继续创建
               exit(0);
          }
     }

     // 关闭监听文件描述符
     close(lfd);

     return 0;



     //note ::父子进程可以共享的内容有哪些 
     /*
     
          文件描述符(子进程是复制父进程的文件描述符)
          mmap 共享映射区
     
     */
}

第二种方案: 使用多线程, 让主线程接受新连接, 让子线程处理与客户端通信; 使用多线程要将线程设置为分离属性, 让线程在退出之后自己回收资源.

#include
#include
#include
#include
#include 
#include
#include 
#include 
#include
#include
#include "warp.h"


//子线程回调函数
void *thread_work(void * arg){

     int cfd=*(int *)arg;
     int n;
     int i;
     char buf[1024];
     while(1){

          //read 数据
          memset(buf,0x00,sizeof(buf));

          n=Read(cfd,buf,sizeof(buf));

          if(n<=0){

               printf("read error or client close,n==[%d]\n",n);
               break;
          }

          printf("n==[%d],buf==[%s]\n",n,buf);

          //将数据转换成大写再发送给客户端。
          for(i=0;i

思考: 如何不使用多进程或者多线程完成多个客户端的连接请求

可以将accept和read函数设置为非阻塞, 调用fcntl函数可以将文件描述符设置为非阻塞, 让后再while循环中忙轮询.

你可能感兴趣的:(服务器,网络,C++)