user-0 提问: 到底什么是流式输入输出，和非流式有啥区别?

回复:
user: user-0
content: 引用 14 楼 adlay 的回复:[quote=引用 13 楼 cc_mugiwala 的回复:] 反正意思是，不管多少udp客户端连进来，他们sendto发送完数据都是立即返回，服务端如果在线(建立socket，绑定端口)就会接收所有客户端的数据；然后服务端用recvfrom一个数据包一个数据包的读，其实在recvfrom之前服务器就已经接收到数据了，对不对？  你说tcp的recv可能只是某个send的一部分，意思是，在一个tcp连接里，我要用多次recv吗，，但是好像一般写代码好像也没有用多次recv啊。  1. 是的 2. 总之是你一次 recv 的数据和你一次 send 的数据没有对应关系，而 UDP 是对应的。要怎么样 recv 得看具体的情况，比如，你在传送一个文件，那么你把每次 recv 的内容依次写入文件就行了，不用管哪一次 recv 了多少字节；但是如果你要传送协议，比如每一个协议包是固定大小的，发送端虽然每次 send 了一个完整的包，接受端的一次 recv 就不一定是一个完整的包了，有可能只有半个，有可能是一个半， 这时你就需要把所有 recv 的内容先放到一个缓冲区，直到缓冲区里面的内容组成了一个完整的包后再从缓冲区里面取出包来处理。[/quote]  最后一个问题，如果服务器不在线，对于tcp来说，客户端连接肯定就失败；对于udp，由于没有连接，sendto还是会成功返回，那发送的数据去哪了，客户端发送数据完后，过了一天，服务器上线还可以收到数据吗

user: user-1
content: 引用 13 楼 cc_mugiwala 的回复:反正意思是，不管多少udp客户端连进来，他们sendto发送完数据都是立即返回，服务端如果在线(建立socket，绑定端口)就会接收所有客户端的数据；然后服务端用recvfrom一个数据包一个数据包的读，其实在recvfrom之前服务器就已经接收到数据了，对不对？  你说tcp的recv可能只是某个send的一部分，意思是，在一个tcp连接里，我要用多次recv吗，，但是好像一般写代码好像也没有用多次recv啊。  1. 是的 2. 总之是你一次 recv 的数据和你一次 send 的数据没有对应关系，而 UDP 是对应的。要怎么样 recv 得看具体的情况，比如，你在传送一个文件，那么你把每次 recv 的内容依次写入文件就行了，不用管哪一次 recv 了多少字节；但是如果你要传送协议，比如每一个协议包是固定大小的，发送端虽然每次 send 了一个完整的包，接受端的一次 recv 就不一定是一个完整的包了，有可能只有半个，有可能是一个半， 这时你就需要把所有 recv 的内容先放到一个缓冲区，直到缓冲区里面的内容组成了一个完整的包后再从缓冲区里面取出包来处理。

user: user-0
content: 引用 8 楼 adlay 的回复:[quote=引用 5 楼 cc_mugiwala 的回复:] [quote=引用 4 楼 jiqiang01234 的回复:] [quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  突然想到一个问题：         一般tcp服务端代码是这样的：首先循环监听一个套接字，如果有客户端连接进来，服务端就新建一个子进程，然后在这个子进程里再建一个套接字，用这个新的套接字交互，这样，可以同时接收多个连接；         但是udp服务端怎么同时和多个客户端交互，一般udp服务端都是用一个循环，然后循环里直接与客户端交互，并没有子进程，如果有一个客户端发了报文过来了，这时候服务端进入循环开始处理，这时候又有另外一个客户端发过来了，由于循环已经开始处理，那这另外一个客户端发的报文去哪了，丢掉了吗。。。。         还是说udp服务端就直接开N个进程，每个进程一个循环？？？感觉不科学。。。[/quote] 1. tcp 服务端的子进程里不是再创建一个套接字，而是使用 accept 返回的套接字。 2. udp 在处理的时候，后面来的包会排队的，超过一定的数量系统才会丢弃。      udp 没有连接状态，是直接处理包的。 服务器收到一个包，处理返回，然后继续读下一个包。 并不存在一个客户端的包来了就要循环处理这个客户端直到这个客户端退出。  -----------------  upd 的数据发送端一个 sendto 是什么数据，recvfrom 得到的就是什么数据，这是就是一个数据包，是上层的处理单位。 tcp 的 send 发送的数据，recv 的时候可能从只是某个 send 的一部分，也可能是多个 send 连在一起的，也可能是一个 send 有一半的数据，另一个又有一半的数据。  所以说，tcp 传递的数据是有序的，连续的，这就是流 udp 传递的数据是无序的，离散的，这就是数据报[/quote]  反正意思是，不管多少udp客户端连进来，他们sendto发送完数据都是立即返回，服务端如果在线(建立socket，绑定端口)就会接收所有客户端的数据；然后服务端用recvfrom一个数据包一个数据包的读，其实在recvfrom之前服务器就已经接收到数据了，对不对？  你说tcp的recv可能只是某个send的一部分，意思是，在一个tcp连接里，我要用多次recv吗，，但是好像一般写代码好像也没有用多次recv啊。

user: user-0
content: 引用 11 楼 cc_mugiwala 的回复:[quote=引用 7 楼 jiqiang01234 的回复:] 如果正在处理器中一个udp连接，同时又有其他客户端啊发送数据。此时操作系统内部会保存其他udp的数据，等到下个循环再处理，当然如果有太多的客户端发送导致服务端没时间处理，就会丢掉 意思是，对于每个客户端就是一个循环。一个客户端连进来，发送数据，下一个客户端必须等到第一个客户端发送完(循环完)，在下一个循环中发送数据。。。这样理解对吗？[/quote]  我可能理解错了，应该是这样：  第一个客户端连进来，正在发送数据；此时第二个客户端也连进来了，它并不会等一个循环完，第二个客户端的sendto不会阻塞，也是立即返回的，发送的数据其实已经被服务器接收掉了，并存在系统里。只是在服务端必须用两次recvfrom循环的读出这两个客户端的数据，一个循环读一个客户端。。这样？

user: user-0
content: 引用 7 楼 jiqiang01234 的回复:如果正在处理器中一个udp连接，同时又有其他客户端啊发送数据。此时操作系统内部会保存其他udp的数据，等到下个循环再处理，当然如果有太多的客户端发送导致服务端没时间处理，就会丢掉 意思是，对于每个客户端就是一个循环。一个客户端连进来，发送数据，下一个客户端必须等到第一个客户端发送完(循环完)，在下一个循环中发送数据。。。这样理解对吗？

user: user-1
content: 引用 15 楼 cc_mugiwala 的回复:[quote=引用 14 楼 adlay 的回复:] [quote=引用 13 楼 cc_mugiwala 的回复:] 反正意思是，不管多少udp客户端连进来，他们sendto发送完数据都是立即返回，服务端如果在线(建立socket，绑定端口)就会接收所有客户端的数据；然后服务端用recvfrom一个数据包一个数据包的读，其实在recvfrom之前服务器就已经接收到数据了，对不对？  你说tcp的recv可能只是某个send的一部分，意思是，在一个tcp连接里，我要用多次recv吗，，但是好像一般写代码好像也没有用多次recv啊。  1. 是的 2. 总之是你一次 recv 的数据和你一次 send 的数据没有对应关系，而 UDP 是对应的。要怎么样 recv 得看具体的情况，比如，你在传送一个文件，那么你把每次 recv 的内容依次写入文件就行了，不用管哪一次 recv 了多少字节；但是如果你要传送协议，比如每一个协议包是固定大小的，发送端虽然每次 send 了一个完整的包，接受端的一次 recv 就不一定是一个完整的包了，有可能只有半个，有可能是一个半， 这时你就需要把所有 recv 的内容先放到一个缓冲区，直到缓冲区里面的内容组成了一个完整的包后再从缓冲区里面取出包来处理。[/quote]  最后一个问题，如果服务器不在线，对于tcp来说，客户端连接肯定就失败；对于udp，由于没有连接，sendto还是会成功返回，那发送的数据去哪了，客户端发送数据完后，过了一天，服务器上线还可以收到数据吗[/quote] 不可能一天后还能收到数据的。。。 服务器没在的话数据就丢失了，UDP 本来就是不可靠的

user: user-2
content: 流式就是，抛开底层细节， 直接按照 一个字节（字节流）， 或者固定大小（块流）输入输出  实现上就是带缓冲的输入输出。 流的意思是连续不断，像流水一样。 C语言 有两套以上的输入输出函数 其中底层接口，就有两套 例如文件操作 面向句柄的：  _creat,_read,_write,_close creat,open,read,write,close C标准库的流操作 使用 FILE指针 函数为 fopen,fread,fwrite,fclose 以及其他函数，文件操作函数。    C++ 流就是 fstream 这些类  至于 TCP/UDP  TCP 是面向连接的，UDP 不是 他的流，和 文件流 不太一样。大致意思相仿佛，但不是一样的

user: user-1
content: 引用 6 楼 cc_mugiwala 的回复:[quote=引用 5 楼 cc_mugiwala 的回复:] [quote=引用 4 楼 jiqiang01234 的回复:] [quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  突然想到一个问题：         一般tcp服务端代码是这样的：首先循环监听一个套接字，如果有客户端连接进来，服务端就新建一个子进程，然后在这个子进程里再建一个套接字，用这个新的套接字交互，这样，可以同时接收多个连接；         但是udp服务端怎么同时和多个客户端交互，一般udp服务端都是用一个循环，然后循环里直接与客户端交互，并没有子进程，如果有一个客户端发了报文过来了，这时候服务端进入循环开始处理，这时候又有另外一个客户端发过来了，由于循环已经开始处理，那这另外一个客户端发的报文去哪了，丢掉了吗。。。。         还是说udp服务端就直接开N个进程，每个进程一个循环？？？感觉不科学。。。[/quote]  我贴一个udp服务端的例子：  int main(){      int sockfd;      int len;      int z;      char buf[256];      struct sockaddr_in adr_inet;      struct sockaddr_in adr_clnt;      printf("waiting for client...\n");      adr_inet.sin_family=AF_INET;      adr_inet.sin_port=htons(port);      adr_inet.sin_addr.s_addr=htonl(INADDR_ANY);      bzero(&(adr_inet.sin_zero),8);      len=sizeof(adr_clnt);      sockfd=socket(AF_INET,SOCK_DGRAM,0);      if(sockfd==-1){        perror("socket error_1");        exit(1);      }      z=bind(sockfd,(struct sockaddr *)&adr_inet,sizeof(adr_inet));      if(z==-1){        perror("bind error_1");        exit(1);      }      while(1){        z=recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&adr_clnt,&len);        if(z<0){          perror("recvfrom error_1");          exit(1);        }        buf[z]=0;        printf("接收：%s",buf);        if(strncmp(buf,"stop",4)==0){          printf("结束....\n");          break;        }      }      close(sockfd);      exit(0);   }  这个就是单独一个循环里面直接recvfrom，一次只能接收一个客户端的报文吗？？[/quote]  每一次调用 recvfrom 返回的都可能是不同的客户端的包 这个服务器是可以服务任意数量的客户端的，只要服务器性能够。

user: user-1
content: 引用 5 楼 cc_mugiwala 的回复:[quote=引用 4 楼 jiqiang01234 的回复:] [quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  突然想到一个问题：         一般tcp服务端代码是这样的：首先循环监听一个套接字，如果有客户端连接进来，服务端就新建一个子进程，然后在这个子进程里再建一个套接字，用这个新的套接字交互，这样，可以同时接收多个连接；         但是udp服务端怎么同时和多个客户端交互，一般udp服务端都是用一个循环，然后循环里直接与客户端交互，并没有子进程，如果有一个客户端发了报文过来了，这时候服务端进入循环开始处理，这时候又有另外一个客户端发过来了，由于循环已经开始处理，那这另外一个客户端发的报文去哪了，丢掉了吗。。。。         还是说udp服务端就直接开N个进程，每个进程一个循环？？？感觉不科学。。。[/quote] 1. tcp 服务端的子进程里不是再创建一个套接字，而是使用 accept 返回的套接字。 2. udp 在处理的时候，后面来的包会排队的，超过一定的数量系统才会丢弃。      udp 没有连接状态，是直接处理包的。 服务器收到一个包，处理返回，然后继续读下一个包。 并不存在一个客户端的包来了就要循环处理这个客户端直到这个客户端退出。  -----------------  upd 的数据发送端一个 sendto 是什么数据，recvfrom 得到的就是什么数据，这是就是一个数据包，是上层的处理单位。 tcp 的 send 发送的数据，recv 的时候可能从只是某个 send 的一部分，也可能是多个 send 连在一起的，也可能是一个 send 有一半的数据，另一个又有一半的数据。  所以说，tcp 传递的数据是有序的，连续的，这就是流 udp 传递的数据是无序的，离散的，这就是数据报

user: user-3
content: 如果正在处理器中一个udp连接，同时又有其他客户端啊发送数据。此时操作系统内部会保存其他udp的数据，等到下个循环再处理，当然如果有太多的客户端发送导致服务端没时间处理，就会丢掉

user: user-0
content: 引用 5 楼 cc_mugiwala 的回复:[quote=引用 4 楼 jiqiang01234 的回复:] [quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  突然想到一个问题：         一般tcp服务端代码是这样的：首先循环监听一个套接字，如果有客户端连接进来，服务端就新建一个子进程，然后在这个子进程里再建一个套接字，用这个新的套接字交互，这样，可以同时接收多个连接；         但是udp服务端怎么同时和多个客户端交互，一般udp服务端都是用一个循环，然后循环里直接与客户端交互，并没有子进程，如果有一个客户端发了报文过来了，这时候服务端进入循环开始处理，这时候又有另外一个客户端发过来了，由于循环已经开始处理，那这另外一个客户端发的报文去哪了，丢掉了吗。。。。         还是说udp服务端就直接开N个进程，每个进程一个循环？？？感觉不科学。。。[/quote]  我贴一个udp服务端的例子：  int main(){      int sockfd;      int len;      int z;      char buf[256];      struct sockaddr_in adr_inet;      struct sockaddr_in adr_clnt;      printf("waiting for client...\n");      adr_inet.sin_family=AF_INET;      adr_inet.sin_port=htons(port);      adr_inet.sin_addr.s_addr=htonl(INADDR_ANY);      bzero(&(adr_inet.sin_zero),8);      len=sizeof(adr_clnt);      sockfd=socket(AF_INET,SOCK_DGRAM,0);      if(sockfd==-1){        perror("socket error_1");        exit(1);      }      z=bind(sockfd,(struct sockaddr *)&adr_inet,sizeof(adr_inet));      if(z==-1){        perror("bind error_1");        exit(1);      }      while(1){        z=recvfrom(sockfd,buf,sizeof(buf),0,(struct sockaddr *)&adr_clnt,&len);        if(z<0){          perror("recvfrom error_1");          exit(1);        }        buf[z]=0;        printf("接收：%s",buf);        if(strncmp(buf,"stop",4)==0){          printf("结束....\n");          break;        }      }      close(sockfd);      exit(0);   }  这个就是单独一个循环里面直接recvfrom，一次只能接收一个客户端的报文吗？？

user: user-0
content: 引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  引用 4 楼 jiqiang01234 的回复:[quote=引用 3 楼 cc_mugiwala 的回复:] [quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到[/quote]  突然想到一个问题：         一般tcp服务端代码是这样的：首先循环监听一个套接字，如果有客户端连接进来，服务端就新建一个子进程，然后在这个子进程里再建一个套接字，用这个新的套接字交互，这样，可以同时接收多个连接；         但是udp服务端怎么同时和多个客户端交互，一般udp服务端都是用一个循环，然后循环里直接与客户端交互，并没有子进程，如果有一个客户端发了报文过来了，这时候服务端进入循环开始处理，这时候又有另外一个客户端发过来了，由于循环已经开始处理，那这另外一个客户端发的报文去哪了，丢掉了吗。。。。         还是说udp服务端就直接开N个进程，每个进程一个循环？？？感觉不科学。。。

user: user-3
content: 引用 3 楼 cc_mugiwala 的回复:[quote=引用 2 楼 jiqiang01234 的回复:] “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。[/quote] udp超过报文长度也会拆分发送，但udp是面向无连接的，如果被拆分的包有丢失，对方就没办法知道了。  如果想验证多次收发，建议用公网，局域网不容易看到

user: user-0
content: 引用 2 楼 jiqiang01234 的回复:“面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。 意思是tcp可以不管发送信息的大小，而udp超过一定的长度，就发送不了了吗？或者说，就接收不了or分几次接收？ 但是一般写socket程序，也没有看到有分几次接收的啊。。

user: user-3
content: “面向流”就是源源不断地，分不清开始和结束的字节。每次的收发量不确定 ”面向报文“就是每次的收发都有最大的长度限制(即报文长度)，接收端每次都会接收到一个报文，也就能分清每次报文的开始和结束。

user: user-4
content: 非流即包