【网络】（九）close与shutdown

最新推荐文章于 2023-11-30 07:00:00 发布
最新推荐文章于 2023-11-30 07:00:00 发布
阅读量714 收藏
点赞数
分类专栏： Linux 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CMbug/article/details/48441073
版权

1、两者的区别

  • close函数会终止数据传送的两个方向，包括套接口的读取和写入；
  • shutdown函数可以有选择的终止某个方向的数据传送，或者终止两个方向；
  • shutdown函数的how参数如果为SHUT_RDWR,表示关闭了套接口的写端，可以保证此时对方会收到一个FIN段，并导致对方read函数读取到EOF并返回0，shutdown函数关闭写端时总会这么做，
    它不理会套接字引用计数；而close函数不会保证，调用close函数时，直到套接字引用计数为0时才会发送FIN段！

2、改进代码

假设：客户端发送数据给服务端，服务端收到数据后，等待一段事件再将数据会送给客户端！

如果客户端将数据全部发送出去后，客户端调用了close函数关闭了套接字，那么服务器在回送数据时，客户端已经无法再接收数据，第一次回送后，服务端会收到RST段，第二次回送后，服务端会引发SIGPIPE信号，从而导致服务端进程终止。

解决方法就是不调用close函数，改用shutdown函数，当客户端将数据全部发送完毕后，只关闭发送端口，接收端口还可正常接收数据，关闭发送端口会导致客户端向服务端发送一个FIN段，服务端收到该段后，可再调用close关闭套接字，此时数据已经回送完毕，等到客户端接收到服务端发送的FIN段，数据也已经接收完成！这时再完全关闭套接字即可。

服务端代码

server.c

编译命令：

gcc -Wall -g -std=gnu99 server.c -o server
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>
#include <signal.h>


#define handle_error(msg)   \
                    do{perror(msg);exit(EXIT_FAILURE);}while(0)


ssize_t readn(int fd, void *buf, size_t count)
{
  if((fd < 0) || (buf == NULL) || (count < 0))
        return -1;
  size_t nleft = count;   //剩余字节数
  ssize_t nread = 0;      //已读字节数
  char *pbuf = (char*)buf;
  while(nleft > 0)
  {
    if((nread = read(fd, pbuf, nleft)) < 0)
    {
        if(errno == EINTR)
            continue;
        return -1;
    }
    else if (nread == 0)
        return count - nleft;
    pbuf += nread;
    nleft -= nread;
  }
  return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    if((fd < 0) || (buf == NULL) || (count < 0))
          return -1;
    size_t nleft = count;   //剩余字节数
    ssize_t nwritten = 0;      //已发送字节数
    char *pbuf = (char*)buf;
    while (nleft > 0)
    {
        if((nwritten = write(fd, pbuf, nleft)) < 0)
        {
            if(errno == EINTR)
                continue;
            return -1;
        }
        else if(nwritten == 0)
            continue;
        pbuf += nwritten;
        nleft -= nwritten;
    }
    return count;
}

//使用recv函数从套接字接收缓冲区中接收数据，但并不从缓冲去中清除数据
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while(true)
    {
        int iret = recv(sockfd, buf, len, MSG_PEEK);
        if(iret == -1 && errno == EINTR)    //如果失败是因为信号中端，那么就重新再试
            continue;
        return iret;
    }
}

//如果读到的数据包含\n，则返回，表示一条完整的消息读取完毕
ssize_t recvline(int sockfd, void *buf, size_t maxlen)
{
    int iret = 0;
    int nread = 0;  //已读数据
    char *pbuf = (char*)buf;
    int nleft = maxlen; //剩余字符
    while(true)
    {
        iret = recv_peek(sockfd, pbuf, nleft);
        if(iret < 0)
            return iret;    //读取失败
        else if(iret == 0)
            return iret;    //对方关闭套接口

        nread = iret;
        if(nread > nleft)       //已经读取到的数据只可能小于或者等于剩余的数据
            exit(EXIT_FAILURE);

        for(int i = 0; i < nread; i++)
        {
            if(pbuf[i] == '\n')
            {
                iret = readn(sockfd, pbuf, i+1);    //从缓冲区中读走包括\n在内的数据
                if(iret != i+1)
                    exit(EXIT_FAILURE);     //没有读取都i+1个数据，说明失败
                return iret;                //读取都\n返回
            }
        }

        //在当前读到的数据中没有发现\n,那么先将这部分数据从缓冲区中读走，然后接着偷窥后面的数据
        nleft -= nread;
        iret = readn(sockfd, pbuf, nread);
        if(iret != nread)
            exit(EXIT_FAILURE);
        pbuf += nread;
    }
    return -1;
}


//为了防止SIGPIPE信号产生而终止了进程，所以捕获此信号
void handle_sigpipe(void)
{
    struct sigaction act;
    act.sa_handler = SIG_IGN;       //忽略SIGPIPE信号
    act.sa_flags = 0;
    sigemptyset(&act.sa_mask);
    if(sigaction(SIGPIPE, &act, NULL) == -1)
        handle_error("sigaction");
}


int main(void)
{
    handle_sigpipe();       //捕获SIGPIPE信号

    int sk_fd = socket(AF_INET, SOCK_STREAM , IPPROTO_TCP);
    if(sk_fd < 0)
        handle_error("socket");


    //使用REUSEADDR，不必等待TIME_WAIT 状态消失，就可以重新使用端口
    int on = 1;
    if(setsockopt(sk_fd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
    {
        close(sk_fd);
        handle_error("setsockopt");
    }


    struct sockaddr_in sr_addr;
    memset(&sr_addr,0,sizeof(sr_addr));
    sr_addr.sin_family = AF_INET;
    sr_addr.sin_port = htons(5188);
    sr_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    //sr_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    //inet_aton("127.0.0.1",&sr_addr.sin_addr);

    if(bind(sk_fd, (struct sockaddr*)&sr_addr, sizeof(sr_addr)) < 0)
    {
        close(sk_fd);
        handle_error("bind");
    }

    //被动套接字
    if(listen(sk_fd, SOMAXCONN) < 0)     //内核为此套接字排队的最大连接数由SOMAXCONN宏指定
    {
        close(sk_fd);
        handle_error("listen");
    }

    //使用select函数实现单进程并发服务器
    fd_set readset;
    fd_set allset;
    FD_ZERO(&readset);
    FD_ZERO(&allset);
    FD_SET(sk_fd, &allset);     //初始状态下，只关心监听套接字

    int maxfd = sk_fd;      //假设最大文件描述符
    int maxfd_last = maxfd; //保存一个maxfd记录，上一次的最大值
    int nready = 0;
    int maxindex = 0;       //client_sk数组最大已用位置
    int maxindex_last = 0;  //maxindex上一次的值
    int client_sk[FD_SETSIZE];      //存储客户端连接信息
    for(int i = 0; i < FD_SETSIZE; i++)
    {
        client_sk[i] = -1;
    }

    while (true)
    {
        readset = allset;
        nready = select(maxfd + 1, &readset, NULL, NULL, NULL);
        if(nready == -1)
        {
            if(errno == EINTR)      //被信号中断
                continue;
            handle_error("select");
        }
        if(nready == 0)     //time out
            continue;
        if(FD_ISSET(sk_fd, &readset))   //检测到监听套接字事件
        {
            //调用accept建立连接
            struct sockaddr_in cl_addr;
            socklen_t cl_length = sizeof(cl_addr);
            memset(&cl_addr,0,sizeof(cl_addr));

            int ac_sk = accept(sk_fd, (struct sockaddr *)&cl_addr, &cl_length);
            if(ac_sk < 0)
            {
                if(errno == EINTR)
                    continue;
                handle_error("accept");
            }
            //加入到监听集合中
            FD_SET(ac_sk, &allset);
            if(ac_sk > maxfd)
            {
                maxfd_last = maxfd; //保存历史记录
                maxfd = ac_sk;      //更新最大文件描述符
            }
            int i;
            for(i = 0; i < FD_SETSIZE; i++)
            {
                if(client_sk[i] < 0)
                {
                    client_sk[i] = ac_sk;
                    if(maxindex < i)
                    {
                        maxindex_last = maxindex;   //保存历史记录
                        maxindex = i;       //更新最大已用位置
                    }
                    break;
                }
            }
            if(i == FD_SETSIZE)     //client_sk数组空间已满，客户端太多
            {
                fprintf(stderr, "Client too many!");
                exit(EXIT_FAILURE);
            }
            printf("Connect ip = %s\tport = %d\n",inet_ntoa(cl_addr.sin_addr),ntohs(cl_addr.sin_port));

            if(--nready <= 0)   //如果除了监听套接字外没有其他套接字发生事件
                continue;
        }
        //客户端连接套接字发生事件
        for(int i = 0; i <= maxindex; i++)
        {
            int conn_sk = client_sk[i];
            if(FD_ISSET(conn_sk, &readset))
            {
                //有数据可以接收
                char recvbuf[1024];
                memset(recvbuf,0,sizeof(recvbuf));
                int iret = recvline(conn_sk,recvbuf,sizeof(recvbuf));    //获取包数据长度
                if(iret == -1)
                    handle_error("read");
                else if(iret == 0)
                {
                    //客户端关闭，删除对应的连接套接字
                    if(conn_sk == maxfd)
                    {
                        maxfd = maxfd_last;     //如果删除的时最大文件描述符
                    }
                    if(i == maxindex)
                    {
                        maxindex = maxindex_last;   //如果删除的描述符的位置是当前最大已用位置
                    }
                    client_sk[i] = -1;
                    FD_CLR(conn_sk, &allset);
                    printf("Client was closed!\n");
                    close(conn_sk);
                }
                fputs(recvbuf,stdout);

                //收到数据后，延迟4秒再发送出去
                sleep(4);

                writen(conn_sk, recvbuf, strlen(recvbuf));    //回传数据

                if(--nready <= 0)       //判断是否处理完
                    break;
            }
        }

    }
    for(int i = 0; i <= maxindex; i++)
    {
        close(client_sk[i]);
    }
    close(sk_fd);
    return 0;
}

客户端代码
client.c

编译命令

gcc -Wall -g -std=gnu99 client.c -o client
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <stdbool.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>
#include <string.h>
#include <sys/select.h>



#define handle_error(msg)   \
                    do{perror(msg);exit(EXIT_FAILURE);}while(0)

ssize_t readn(int fd, void *buf, size_t count)
{
  if((fd < 0) || (buf == NULL) || (count < 0))
        return -1;
  size_t nleft = count;   //剩余字节数
  ssize_t nread = 0;      //已读字节数
  char *pbuf = (char*)buf;
  while(nleft > 0)
  {
    if((nread = read(fd, pbuf, nleft)) < 0)
    {
        if(errno == EINTR)
            continue;
        return -1;
    }
    else if (nread == 0)
        return count - nleft;
    pbuf += nread;
    nleft -= nread;
  }
  return count;
}

ssize_t writen(int fd, const void *buf, size_t count)
{
    if((fd < 0) || (buf == NULL) || (count < 0))
          return -1;
    size_t nleft = count;   //剩余字节数
    ssize_t nwritten = 0;      //已发送字节数
    char *pbuf = (char*)buf;
    while (nleft > 0)
    {
        if((nwritten = write(fd, pbuf, nleft)) < 0)
        {
            if(errno == EINTR)
                continue;
            return -1;
        }
        else if(nwritten == 0)
            continue;
        pbuf += nwritten;
        nleft -= nwritten;
    }
    return count;
}

//使用recv函数从套接字接收缓冲区中接收数据，但并不从缓冲去中清除数据
ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while(true)
    {
        int iret = recv(sockfd, buf, len, MSG_PEEK);
        if(iret == -1 && errno == EINTR)    //如果失败是因为信号中端，那么就重新再试
            continue;
        return iret;
    }
}



ssize_t recvline(int sockfd, void *buf, size_t maxlen)
{
    int iret = 0;
    int nread = 0;  //已读数据
    char *pbuf = (char*)buf;
    int nleft = maxlen; //剩余字符
    while(true)
    {
        iret = recv_peek(sockfd, pbuf, nleft);
        if(iret < 0)
            return iret;    //读取失败
        else if(iret == 0)
            return iret;    //对方关闭套接口

        nread = iret;
        if(nread > nleft)       //已经读取到的数据只可能小于或者等于剩余的数据
            exit(EXIT_FAILURE);

        for(int i = 0; i < nread; i++)
        {
            if(pbuf[i] == '\n')
            {
                iret = readn(sockfd, pbuf, i+1);    //从缓冲区中读走包括\n在内的数据
                if(iret != i+1)
                    exit(EXIT_FAILURE);     //没有读取都i+1个数据，说明失败
                return iret;                //读取都\n返回
            }
        }

        //在当前读到的数据中没有发现\n,那么先将这部分数据从缓冲区中读走，然后接着偷窥后面的数据
        nleft -= nread;
        iret = readn(sockfd, pbuf, nread);
        if(iret != nread)
            exit(EXIT_FAILURE);
        pbuf += nread;
    }
    return -1;
}

//select可看做一个管理者，可用它来管理多个IO，
//一旦其中的一个IO或这多个IO发生了我们感兴趣的事件，select函数就返回，
//返回值为检测到的个数，并且会告诉我们哪些IO发生了事件

//参数：
    //1、读写异常集合中的文件描述父的最大值+1
    //读集合，输入输出参数
    //写集合，输入输出参数
    //异常集合，输入输出参数
    //超时结构体，设置此结构体后，可设定让select函数返回的超时时间
void client_handler(int sk_fd)
{
    fd_set readset;
    FD_ZERO(&readset);
    int nready = 0;
    int fd_stdin = fileno(stdin);   //获得标准输入的描述符，防止输入重定向
    int fd_max = fd_stdin > sk_fd ? fd_stdin : sk_fd;
    bool stdinflag = true;      //表示是否需要select监听stdin
    while(true)
    {
        if(stdinflag)
            FD_SET(fd_stdin, &readset);
        FD_SET(sk_fd, &readset);        //readset集合可能会改变，所以每次都要添加
        nready = select(fd_max + 1, &readset, NULL, NULL, NULL);
        if(nready == -1)
            handle_error("select");
        if(nready == 0)
            continue;
        if(FD_ISSET(sk_fd, &readset))   //套接口产生了读事件
        {
            char recvbuf[1024] = {0};
            int iret = recvline(sk_fd, recvbuf, sizeof(recvbuf)); //接收包数据长度
            if(iret == -1)
                handle_error("read");
            else if(iret == 0)
            {
                printf("Server was closed!\n");
                break;
            }
            fputs(recvbuf, stdout);
            memset(&recvbuf, 0, sizeof(recvbuf));
        }
        if(FD_ISSET(fd_stdin, &readset))    //标准输入产生读事件
        {
            char sendbuf[1024] = {0};
            if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
            {
                //如果从标准输入接收到EOF，表示我们想关闭发送端口
                stdinflag = false;      //让select不再对stdin进行监听
                printf("Ctrl + D\n");
                shutdown(sk_fd, SHUT_WR);   //只关闭写端，对方会收到FIN段
            }
            else
            {
                writen(sk_fd, sendbuf, strlen(sendbuf));   //发送数据
                memset(&sendbuf, 0, sizeof(sendbuf));
            }
        }
    }
}



int main(void)
{
    int sk_fd;
    sk_fd = socket(AF_INET, SOCK_STREAM , IPPROTO_TCP);
    if(sk_fd < 0)
        handle_error("socket");
    struct sockaddr_in sr_addr;
    memset(&sr_addr,0,sizeof(sr_addr));
    sr_addr.sin_family = AF_INET;
    sr_addr.sin_port = htons(5188);
    //sr_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    sr_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    //inet_aton("127.0.0.1",&sr_addr.sin_addr);

    if(connect(sk_fd, (struct sockaddr*)&sr_addr, sizeof(sr_addr)) < 0)
    {
        close(sk_fd);
        handle_error("connect");
    }

    client_handler(sk_fd);
    close(sk_fd);
    return 0;
}
CMbug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux网络编程之shutdown() 与 close()函数详解
lgp88的专栏
01-05 4万+
1.close()函数 #include int close(int sockfd); //返回成功为0，出错为-1.     close 一个套接字的默认行为是把套接字标记为已关闭，然后立即返回到调用进程，该套接字描述符不能再由调用进程使用，也就是说它不能再作为read或write的第一个参数，然而TCP将尝试发送已排队等待发送到对端的任何数据，发送完毕后发生的是正常的TCP连接终
【网络】close与shutdown
小鱼菜鸟的博客
07-29 856
目录 区别 详细 问题和陷阱 示例代码 区别 shutdown() 用来关闭连接，而不是套接字，不管调用多少次 shutdown()，套接字依然存在，调用 close() / closesocket() 会将socket fd的引用 减1，减到0时，套接字就会被释放。调用 close()/closesocket() 将丢失输出缓冲区中的数...
linux网络编程--shut_down和close()函数的区别
鱼思故渊的专栏
09-01 5389
在Linux C网络编程中，一共有两种方法来关闭一个已经连接好的网络通信，它们就是close函数和shutdown函数，它们的函数原型分别为： 1 #include 2 int close(int sockfd) 3 //返回：0——成功， 1——失败 4
close与shutdown函数
weixin_30773135的博客
06-14 96
linux网络编程之socket（十）：shutdown 与 close 函数的区别 http://blog.csdn.net/yijiu0711/article/details/17349169 socket中关闭套接字的函数close和shutdown区别 #include <unistd.h>int close(int fd); close 关闭了自身数据传输的两个...
close和shutdown函数的区别
modi000的博客
04-22 249
转载from：https://blog.csdn.net/weixin_42634329/article/details/81147784 参考：https://blog.csdn.net/lgp88/article/details/7176509 《UNIX网络编程》 close()函数： close一个套接字的默认行为是把套接字标记为已关闭，然后立即返回到调用进程，该套接字描述符不能再...
深入理解linux中close与shutdown的区别
09-15
在Linux操作系统中，网络通信是通过套接字（socket）进行的，而`close`和`shutdown`函数是用于管理套接字生命周期的关键操作。理解它们的区别对于编写可靠的网络服务程序至关重要。 首先，我们来看`close`函数。`...
【网络基础-套接字关闭】面试BAT因为close被拒（close与shutdown以及SO_LINGER属性（精讲））
JianChiBieFei的博客
04-11 830
人们的视线总是会指向那些他们有兴趣靠近、试探、寻找或者拥有的东西。---摘自：《人生十二堂课》 当一个TCP连接终止时，需要调用close或者shutdown函数来关闭对应的套接字。那么对于这两个关闭接口，各自适用于什么情况呢，有什么不同呢？以及如何通过套接字属性控制它们产生不同的行为呢？ 下面我们就来详细说一说close以及shutdown函数的用法以及它们的区别： close：关闭套...
linux的close函数和,linux网络编程之shutdown() 与 close()函数详解
weixin_31714129的博客
05-03 1648
1.close()函数#includeint close(int sockfd); //返回成功为0，出错为-1.作用:close一个套接字的默认行为是把套接字标记为已关闭，然后立即返回到调用进程。该套接字描述符不能再由调用进程使用，也就是说它不能再作为read或write的第一个参数。要注意TCP将尝试发送已排队等待发送到对端的任何数据，发送完毕后发生的是正常的TCP连接终止序列。在多进...
linux 关闭socket shutdown,关于socket的关闭：close和shutdown
weixin_34847426的博客
05-15 1323
声明:该博文以socket中,关闭输出流为例进行说明. 为了方便讲解,我们把DataOutputstream dout = new DataOutputStream(new BufferedOutputStream(mySocket.getOutputStream()));中的dout做为Socket输出流的代言.同样的,din是输入流的代言. 可以造成dout被关闭的操作有: 1.调用dout....
Linux socket编程(8):shutdown和close的区别详解及例子
最新发布
主要分享硬件、嵌入式软件部分知识
11-30 957
close和shutdown。但这两种函数在使用时有着不同的行为和效果。在网络编程中，正确地选择和使用这些操作至关重要，因为它们直接影响着通信的结束和资源的释放。本文将介绍close和shutdown函数，然后举一个实际的例子来说明shutdown的使用。
网络编程close与shutdown的区别
热门推荐
xkdlzy的专栏
10-06 1万+
网络编程 close shutdown
close 和 shutdown 的差别
caofengtao1314的专栏
05-18 2766
close 函数 首先，我们来看最常见的 close 函数： int close(int sockfd) 这个函数很简单，对已连接的套接字执行 close 操作就可以，若成功则为 0，若出错则为 -1。 这个函数会对套接字引用计数减一，一旦发现套接字引用计数到 0，就会对套接字进行彻底释放，并且会关闭 TCP 两个方向的数据流。 套接字引用计数是什么意思呢？因为套接字可以被多个进程共享，你可以理解为我们给每个套接字都设置了一个积分，如果我们通过 fork 的方式产生子进程，套接字就会积分 +1
高性能网络编程4--TCP连接的关闭
iteye_10227的博客
10-26 1768
TCP连接的关闭有两个方法close和shutdown，这篇文章将尽量精简的说明它们分别做了些什么。 为方便阅读，我们可以带着以下5个问题来阅读本文： 1、当socket被多进程或者多线程共享时，关闭连接时有何区别？ 2、关连接时，若连接上有来自对端的还未处理的消息，会怎么处理？ 3、关连接时，若连接上有本进程待发送却未来得及发送出的消息，又会怎么处理？ 4、so_linger这个功能的用处在哪？...
浅谈shutdown()和close()的区别
Justlinux2010的专栏
03-10 1万+
shutdown()函数可以选择关闭全双工连接的读通道或者写通道，如果两个通道同时关闭，则这个连接不能再继续通信。close()函数会同时关闭全双工连接的读写通道，除了关闭连接外，还会释放套接字占用的文件描述符。而shutdown()只会关闭连接，但是不会释放占用的文件描述符。所以即使使用了SHUT_RDWR类型调用shutdown()关闭连接，也仍然要调用close()来释放连接占用的文件描述符
close 和 shutdown
扎实基础方能走远
01-17 1055
close和shutdown都是关闭套接字的系统调用函数 区别如下：   先说包交互流程： close会直接发送FIN包，并且（一般情况）不再接收对方发送的任何报文，如果有收到报文会回复RST。 shutdown有三类情况： 1，在参数是SHUT_RD，也就是只关闭了读的时候，是不会发送任何表明关闭了读的协议报文的。同时对端还可以发送报文，本端也会回复ack，但是本端在用系统调用rec...
Linux网络编程之TCP编程
y_q_m的博客
03-05 524
1 CS 模式   客户端（Client）和服务器（Serve）模式。客户端是主动的，服务器是被动的。一般情况下，一定服务器会响应多个客户端。 2 TCP网络编程架构 3 TCP 网络编程相关函数（API） 3.1 创建套接字函数 Socket（）   套接字和无名管道、有名管道、信号灯，共享内存、消息队列、信号灯集都属于进程间通讯方式。套接字一般用于网络通信，其他的一般用于本地通信。 3.1...
关于close与shutdown的区别
狂客队长
03-16 4948
终止网络连接的通常方法是调用close函数。不过close有两个限制，却可以使用shutdown来避免。 1  close把描述字的引用计数减1，仅在该计数变为0的时候才关闭套接口。而使用shutdown可以不管引用计数的值是多少就激发TCP的正常连接终止序列，也即是发送FIN节。 2  close终止数据传送的两个方向：读和写。而有的时候只是想关闭读或写，那么此时就使用shutdown函数进
shutdown函数与close函数
04-10
b'shutdown'函数和'close'函数是用来关闭网络连接的。它们的作用有一些不同，'shutdown'函数是用来在网络连接上发送一个关闭信号，而'close'函数是用来关闭连接并且释放相关资源。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值