一些关于网络知识的笔记，便于以后翻阅

栈存放：局部变量，先入后出，系统自己分配和释放。

  函数参数

  

堆存放：数组

  少于200字节的数组

pthread_join等待线程函数结束

pthread_create创建线程函数，线程间同步操作。

select的作用：网络中当存在阻塞时，为了不影响别的程序运行，选择了select

 read / recv 阻塞函数，

accept返回值时一个新的socketID；

文件描述符为什么要加1？

 因为文件描述符是从0 开始的。 0 1 2。。。。。最大文件描述符是2, 但是实际上

监听的文件描述符是3个

进程的内存结构：

  在创建进程时，会给它分配内存。4G

  一般情况下分为四个段，代码段，数据段，堆段，栈段

 代码段时只读的；数据段一般分为bss段（未初始化的全局变量）

 数据段（已初始化的全局变量、静态变量）和常量区

 堆段（malloc / new）

 栈段（局部变量，参数，保存现场）  

 

1.UDP

打开socket

绑定自己的ip,port

通信recvfrom/set dest addr, sendto-->addr

关闭socket

2. UDP download

server:

打开socket

绑定自己的ip,port

open file

发送文件大小

while(1)

{

ret = read();

if (0 >= ret)

 break;

sendto

}

close file

close socket

client:

打开socket

绑定自己的ip,port

create and open file

接收文件大小

while(1)

{

ret = recvfrom();

if (0 >= ret)

 break;

write

fileSize -= ret;

if (0 >= fileSize)

 break;

}

close file

close socket

内存使用：小栈大堆

栈：先入后出；系统自己分配和释放；用的时候分配，用完自动释放。

栈里存放-》局部变量，参数... ...

例：数组-》栈 -》少于200个字节

堆：

ogm->视频->7M空间

一、IO模型

1.fcntl修改阻塞<->非阻塞

2.多路复用

tcp server

版本1

打开socket; 绑定自己的ip,port; 监听

三次握手

 通信

三次握手

 通信

三次握手

 通信

三次握手

 通信

 ... ...

 

关闭socket

版本2

打开socket; 绑定自己的ip,port; 监听

while(1)

{

 三次握手 accept

 通信     recv, (scanf)send

}

 

关闭socket

版本3

打开socket; 绑定自己的ip,port; 监听

while(1)

{

 三次握手 accept

 通信     recv, recv, recv ... (scanf)send

}

 

关闭socket

版本4

打开socket; 绑定自己的ip,port; 监听

while(1)

{

 三次握手 accept(socketID)

 while(1){

  通信     recv(newID) //(scanf)send

 }

}

 

关闭socket

总结：

当前的程序中有多个阻塞描述符，每一个描述符可能会对其它描述符的正常通信造成影响。

可以使用多路复用来解决上述问题，例如select

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

int select(int n, fd_set *read_fds, fd_set *write_fds, fd_set *except_fds, struct timeval *timeout);

参数

n: 监听的最大文件描述符+1.

read_fds : 读文件描述符集。-- 通俗的讲是使用读相关的函数来操作描述符的。

 例: accept, read, recv, scanf ... ...

write_fds : 所有要的写文件文件描述符的集合

except_fds : 其他要向我们通知的文件描述符

timeout : 超时设置.

 NULL：一直阻塞，直到有文件描述符就绪或出错

 时间值为0：仅仅检测文件描述符集的状态，然后立即返回

 时间值不为0：在指定时间内，如果没有事件发生，则超时返回。

定义变量fd_set read_fds;

FD_SET     将fd加入到fd_set

FD_CLR     将fd从fd_set里面清除

FD_ZERO    从fd_set中清除所有的文件描述符

FD_ISSET   判断fd是否在fd_set集合中

void FD_CLR(int fd, fd_set *set);

int  FD_ISSET(int fd, fd_set *set);

void FD_SET(int fd, fd_set *set);

void FD_ZERO(fd_set *set);

//清空

FD_ZERO(&read_fds);

//把socketID加入到读描述符集里

FD_SET(socketID, &read_fds);

//设置描述符最大值加1

int maxFds = socketID + 1;

//调用select

select(maxFds, &read_fds, NULL, NULL, NULL);

 

多路复用版本1

打开socket; 绑定自己的ip,port; 监听

fd_set read_fds;

//清空

FD_ZERO(&read_fds);

//把socketID加入到读描述符集里

FD_SET(socketID, &read_fds);

//设置描述符最大值加1

int maxFds = socketID + 1;

while(1)

{

 select(maxFds, &read_fds, NULL, NULL, NULL);

 三次握手 accept(socketID)

 //while(1){

  通信     recv(newID) //(scanf)send

 //}

}

 

关闭socket  

总结版本1，问题是：当一个客户端连接服务器后，accept会返回newID.

这时，直接调用recv，这时，如果当前客户端没有发过来数据，那么recv阻塞。

此时，如果第二个客户端想要连接服务器，必须要等待。

 

多路复用版本2

打开socket; 绑定自己的ip,port; 监听

fd_set read_fds;

//清空

FD_ZERO(&read_fds);

//把socketID加入到读描述符集里

FD_SET(socketID, &read_fds);

//设置描述符最大值加1

int maxFds = socketID;

while(1)

{//1,3,4,5

 fd_set tmp = read_fds;

 select(maxFds +１, &tmp, NULL, NULL, NULL);

 //select正确返回时，判断每一个监听的描述符是否可以进行IO操作

 for (i = 0; i < maxFds + 1; i++)

 {

  if (FD_ISSET -> socketID && socketID == i)//tmp

  {

   三次握手 accept(socketID)--> newID=16

   FD_SET(newID, &read_fds);   //16

   if (maxFds　<  newID)       16

   {

    maxFds = newID;

   }

  }

  if (FD_ISSET -> i)//tmp

   通信     recv(i) //(scanf)send

 }

}

 

关闭socket  

 

typedef struct

  {

    __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];

  } fd_set;

__fd_mask类型 ： long int

__fds_bits数组名

__FD_SETSIZE / __NFDBITS数组的大小: 1024 / (8 * sizeof(long int))

-->

typedef struct

  {

    long arr[128 / (sizeof(long))];

  } fd_set;

fd_set readFds; --> 大小为1024bit

 

 select(maxFds +１, &read_fds, NULL, NULL, NULL);

 三次握手 accept(socketID)--> newID=13

 

 FD_SET(newID, &read_fds);

 if (maxFds　<  newID)13

 {

  maxFds = newID;

 }

  

 //2

 select(maxFds +１, &read_fds, NULL, NULL, NULL);

 if (FD_ISSET -> socketID)

 {

  三次握手 accept(socketID)--> newID=15

  FD_SET(newID, &read_fds);   //15

  if (maxFds　<  newID)       15

  {

   maxFds = newID;

  }

 }

 if (FD_ISSET -> 13)

  通信     recv(13) //(scanf)send

 

 //3-> socketID, 13, 15

 select(maxFds +１, &read_fds, NULL, NULL, NULL);

 if (FD_ISSET -> socketID)

 {

  三次握手 accept(socketID)--> newID=16

  FD_SET(newID, &read_fds);   //16

  if (maxFds　<  newID)       16

  {

   maxFds = newID;

  }

 }

 if (FD_ISSET -> 13)

  通信     recv(13) //(scanf)send

 if (FD_ISSET -> 15)

  通信     recv(15) //(scanf)send

 //4 socketID, 13, 15, 16

 select(maxFds +１, &read_fds, NULL, NULL, NULL);

 //select正确返回时，判断每一个监听的描述符是否可以进行IO操作

 if (FD_ISSET -> socketID)

 {

  三次握手 accept(socketID)--> newID=16

  FD_SET(newID, &read_fds);   //16

  if (maxFds　<  newID)       16

  {

   maxFds = newID;

  }

 }

 if (FD_ISSET -> 13)

  通信     recv(13) //(scanf)send

 if (FD_ISSET -> 15)

  通信     recv(15) //(scanf)send

 if (FD_ISSET -> 16)

  通信     recv(16)

  

 思考：上面的在个if是重复性的动作，想要简化。 

 方法1：

  for (i = 0; i < array.count; i++)

  {

   if (FD_ISSET -> i)

    通信     recv(i) //(scanf)send

  }  

 总结：数组的大小无法确定，不好。

 方法2：

  for (i = 0; i < maxFds + 1; i++)

  {

   if (FD_ISSET -> i)

    通信     recv(i) //(scanf)send

  }

 

 ---------------------------------------------

 现在综合上面把//4修改一下

 select(maxFds +１, &read_fds, NULL, NULL, NULL);

 //select正确返回时，判断每一个监听的描述符是否可以进行IO操作

 for (i = 0; i < maxFds + 1; i++)

 {

  if (FD_ISSET -> socketID && socketID == i)

  {

   三次握手 accept(socketID)--> newID=16

   FD_SET(newID, &read_fds);   //16

   if (maxFds　<  newID)       16

   {

    maxFds = newID;

   }

  }

  if (FD_ISSET -> i)

   通信     recv(i) //(scanf)send

 }