socket api- c/s模式:服务读写,客户写读. IO模式:阻塞

服务端:socket->address->bind->listen->loop{accpet->read->write->close(auto socket)}->close(listen socket)
1)因为是阻塞模式,所以客户端没有关闭的时候,服务端会阻塞在read函数,
2)客户端发送之后断开连接。是一个有序的数据片。服务端由内核经过排序片。一定会接收到数据。
而不会因为close的数据先到就以为没有数据。所以必须理解客户端的行为。也就是write和close函数。
他们都是发送数据包。是有顺序的,seq的。包括connect也是发送数据包。只不过工作由内核处理。
connect,write,close。如果按顺序写。发送的包的seq number是持续增加的。

客户端:socket->connect->wirte->loop(read)->close(client socket)
1)因为是阻塞模式。服务端的read会阻塞。所以客户端write之后再read。服务端是一定会接收到数据,再进行下一步发送数据的。
2)而客户端也是阻塞模式。所以read是一定会等待服务端发来的数据。并等到服务端的close信息。再完成接收数据步骤。

知识点:

char a[]=“” 会计算字符大小并加入结束符
read 函数,会读入任何符号,包括结束符号。
snprintf(&buff,n,"",x),实际上的字符大小只有n-1.会自动加入结束符号。

strlen 来计算实际的字符数量。不会包括结束符号。
1)所以write的时候用strlen确定实际字符大小。
2)read的时候。用一个n大小的char数组接收,并明确read的大小为n-1.方便放满字符还可以自行加入结束符号。
3)每次读之前,必须清空char数组,方便下次写入。

未处理知识点:
1)因为是阻塞模式。服务端没法确定客户端不再发送数据。因为客户端不可能关闭。它还要等待接收数据。
而客户端不关闭。服务端,会一直阻塞在read函数。
所以本实验是,客户固定发送比较小的数据,服务端用较大的缓冲区一次接收完客户数据。
而不考虑服务端一次接收不完的情况。
是否可以自己加入结束边界标志?对。书上好像提到过。应该是这样处理。
2)如果服务端一次没有读完客户数据。socket里面还有数据。这个时候发送,是发送正常的?是因为socket有2个缓冲区还是,之前的缓冲区清空了?

server:

#include <iostream>
#include <sys/socket.h>//{socket_type.h}:socket,AF_INET,SOCK_STREAM,PF_INET
#include <netdb.h>//{<netinet/in.h>}:IPPROTO_TCP
#include <sys/errno.h>
#include <string.h>
#include <stdio.h>//perror
#include <fcntl.h>
#include <unistd.h>//close.
#include <time.h>
#include <thread>
#include <arpa/inet.h>//INET_PTON

using namespace std;

typedef struct sockaddr_in SA;

void Accpetthread(int serverFD);
int main()
{
    //socket->addr->bind->listen->accept(read ,write)
    int serverFD;
    int intflag;

    SA serverAddr;
    bzero(&serverAddr,sizeof(serverAddr));
    serverFD=socket(AF_INET,SOCK_STREAM,IPPROTO_IP);
    if(serverFD==-1)
    {
        perror("create()");
        return -1;
    }

    //serverAddr.sin_addr.s_addr=htonl(INADDR_ANY);
    inet_pton(AF_INET,"127.0.0.1",&serverAddr.sin_addr);
    serverAddr.sin_family=AF_INET;
    serverAddr.sin_port=htons(3004);
    //serverAddr.sin_zero??

    intflag=bind(serverFD,(sockaddr*)&serverAddr,sizeof(sockaddr));
    if(intflag==-1)
    {
        perror("bind()");
        return -1;
    }

    listen(serverFD,10);//max queue?

    thread a=thread(Accpetthread,serverFD);

    a.detach();

    int cmd;
    cout<<"exist:input 88"<<endl;
    for(;;)
    {
        cin>>cmd;
        if(cmd==88)
        {
            break;
        }
    }

    close(serverFD);//close 之后,地址不能使用.要等待2ml
    return 0;
}

//
void Accpetthread(int serverFD)
{
    for(;;)
    {
        int serverTempFD=accept(serverFD,0,0);

        //read
        char readbuf[51];
        int sizeread= read(serverTempFD,readbuf,50);
        readbuf[sizeread]=‘\0‘;//以免溢出,插入结束符号.

        char writebuff[100];
        bzero(writebuff,100);//以免溢出,全部写结束符号.
        int tempsize= snprintf(writebuff,99,"%s:%d",readbuf,strlen(readbuf));
        cout<<writebuff<<endl;
        cout<<strlen(writebuff)<<endl;//为什么size是100?不是根绝\0决定的吗?

        write(serverTempFD,writebuff,strlen(writebuff));
        close(serverTempFD);
    }
}

client:

#include <iostream>
#include <sys/socket.h>//{socket_type.h}:socket,AF_INET,SOCK_STREAM,PF_INET
#include <netdb.h>//{<netinet/in.h>}:IPPROTO_TCP
#include <sys/errno.h>
#include <string.h>
#include <stdio.h>//perror
#include <fcntl.h>
#include <unistd.h>//close.
#include <time.h>
#include <netinet/in.h>
#include<arpa/inet.h>//INET_PTON

using namespace std;

int main()
{
    //socket->connect->read.
    int socketClientFD;
    int statusFlag;

    socketClientFD=socket(PF_INET,SOCK_STREAM,IPPROTO_IP);
    if(socketClientFD==-1)
    {
        perror("socket()");
        return -1;
    }

    struct sockaddr_in serverAddr;
    bzero(&serverAddr,sizeof(serverAddr));
    serverAddr.sin_family=AF_INET;
    inet_pton(AF_INET,"127.0.0.1",&serverAddr.sin_addr);

    //printf("%0x,%0x,%0x,%0x",((char*)&serverAddr.sin_addr)[0],((char*)&serverAddr.sin_addr)[1],((char*)&serverAddr.sin_addr)[2],((char*)&serverAddr.sin_addr)[3]);

    serverAddr.sin_port=htons(3004);

    statusFlag=connect(socketClientFD,(sockaddr*)&serverAddr,sizeof(serverAddr));

    if(statusFlag==-1)
    {
        perror("connect()");
        return -1;
    }

    char buff[11];

    char writeChar[16]="hi,i am client.";//一定会加入结束符号.char 大小要比实际字符大1.
    statusFlag= write(socketClientFD,writeChar,strlen(writeChar));//写的时候只发送字符。不发送结束符。所以用strlen.

    if(statusFlag==-1)
    {
        perror("write()");
        return -1;
    }

    for(;;)
    {
        //bzero(buff,11);//每次要清空,更安全点。虽然后面已经buff[statusFlag]=‘\0‘;
        statusFlag=read(socketClientFD,buff,10);//这里会读入任何符号。包括结束符号。所以要求写的时候,不要发送结束符号。因此要求用strlen,确定实际字符。
        if(statusFlag>0)
        {
            buff[statusFlag]=‘\0‘;
            cout<<buff<<flush;
        }
        else if(statusFlag==0)
        {
            cout<<endl;
            break;
        }
        else
        {
            perror("read()");
            return -1;
        }
    }

    cout<<"eixist:input 88."<<endl;
    int cmd;
    while(1)
    {
        cin>>cmd;

        if(cmd==88)
        {
            close(socketClientFD);
            break;
        }
    }

    return 0;
}
时间: 2024-10-16 16:33:15

socket api- c/s模式:服务读写,客户写读. IO模式:阻塞的相关文章

socket api- c/s模式:服务写,客户读. IO模式:阻塞

场景: 1)客户端从服务端获取信息. 2)阻塞模式. 所以: 1)服务端,步骤,socket, addr,bind,listen, loop{accept,write,close(auto socket)},close server socket. 1.1.服务端地址必须绑定,以提供服务. 1.2.listen之后,每个客户端connect会导致加入服务端的listen队列的队尾. 1.3.accpet,时,会从listen队列的队头取出客户address,内核并在服务端建立一个新的自动地址的s

第八天 文件的读,写,追加,读写,写读,seek()光标的移动,修改文件以及另一种打开文件的方式

主要内容:    1.初始文件操作 2.只读( r,rb ) 3.只写( w,wb ) 4.追加( a ,ab) 5.读写( r+ ) 6.写读( w+ ) 7.追加写读 ( a+ ) 8.其他操作方法 9.文件的修改以及另一种打开文件句柄的方式 一.初始文件的操作    使用python来读写文件是非常简单的操作. 我们使用open()函数来打开?个文件, 获取到文件句柄. 然后通过文件句柄就可以进行各种各样的操作了. 根据打开方式的不同能够执行的操作也会有相应的差异. 打开文件的方式: r,

socket api- c/s模式:服务多次读写,客户多次写读(同步处理多客户,多线程). IO模式:阻塞t

服务端: 1)多线程处理客户connect.主线程,处理用户输入,二线程处理accpet,每次有新的connect,就建立新线程处理每个客户端. 2)二线程阻塞在accept,其他新线程阻塞在read. 3)当客户端close.服务端对应线程,read得到0. 之后也进行close(这一部上次实验没做,导致服务socket一直在close wait ,而客户一直在fin wait 2.) 所以客户端socket阻塞在内核的time wait.而服务端阻塞的内核的 close wait. 缺点:

Linux统系统开发11 Socket API编程2 多进程 多线程 高并发处理

[本文谢绝转载原文来自http://990487026.blog.51cto.com] <纲要> Linux统系统开发11 Socket API编程2 多进程 多线程 高并发处理 UDP服务器 客户端最小模型,处理字符转大写 TCP 多进程并发服务器模型,为每个客户端开启一个进程: TCP 多线程服务器模型,使用wrap函数封装 作业: ---------------------------------------------------- UDP服务器 客户端最小模型,处理字符转大写 [em

Linux统系统开发12 Socket API编程3 TCP状态转换 多路IO高并发select poll epoll udp组播 线程池

[本文谢绝转载原文来自http://990487026.blog.51cto.com] Linux统系统开发12 Socket API编程3 TCP状态转换 多路IO高并发select  poll  epoll udp组播 线程池 TCP 11种状态理解: 1,客户端正常发起关闭请求 2,客户端与服务端同时发起关闭请求 3,FIN_WAIT1直接转变TIME_WAIT 4,客户端接收来自服务器的关闭连接请求 多路IO转接服务器: select模型 poll模型 epoll模型 udp组播模型 线

python 简单搭建非阻塞式单进程,select模式,epoll模式服务

由于经常被抓取文章内容,在此附上博客文章网址:,偶尔会更新某些出错的数据或文字,建议到我博客地址 :  --> 点击这里 1 单进程服务器 - 非堵塞模式 服务端 : #coding=utf-8 from socket import * import time #用来存储所有的新连接的socket,这个是重点 g_socketList = [] def main(): serSocket = socket(AF_INET, SOCK_STREAM) serSocket.setsockopt(SO

socket API CSocket CAsyncSocket 用法及区别

要进行网络编程就要和Socket打交道,Socket有同步阻塞方式和异步非阻塞方式两种使用,事实上同步和异步在我们编程的生涯中可能遇到了很多,而Socket也没什么特别.虽然同步好用,不费劲,但不能满足一些应用场合,其效率也很低.    或许初涉编程的人不能理解"同步(或阻塞)"和"异步(或非阻塞)",其实简单两句话就能讲清楚,同步和异步往往都是针对一个函数来说的,"同步"就是函数直到其要执行的功能全部完成时才返回,而"异步"

一个hello/hi的简单的网络聊天程序和python Socket API与Linux Socket API之间的关系

1.Socket概述 套接字(socket)是一个抽象层,应用程序可以通过它发送或接收数据,可对其进行像对文件一样的打开.读写和关闭等操作.套接字允许应用程序将I/O插入到网络中,并与网络中的其他应用程序进行通信.网络套接字是IP地址与端口的组合. 套接字可以看成是两个网络应用程序进行通信时,各自通信连接中的一个端点.通信时,其中的一个网络应用程序将要传输的一段信息写入它所在主机的Socket中,该Socket通过网络接口卡的传输介质将这段信息发送给另一台主机的Socket中,使这段信息能传送到

通过基于java实现的网络聊天程序分析java中网络API和Linux Socket API关系

1. 引言 socket网络编程,可以指定不同的通信协议,在这里,我们使用TCP协议实现基于java的C/S模式下“hello/hi”网络聊天程序 2. 目标 1). 通过该网络聊天程序,了解java Socket API接口的基本用法 2). java Socket API简要介绍 3). linux socket API 简单分析 4). tcp协议的连接和终止 5). 探究java socket API 和 linux socket api之间的关系 3. linux socket API