socket套接字编写多线程多进程的server和client

最新推荐文章于 2020-06-08 17:21:13 发布
最新推荐文章于 2020-06-08 17:21:13 发布
阅读量994 收藏 1
点赞数
分类专栏： 计算机网络 文章标签： socket 多线程 server
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/persistence_s/article/details/76064283
版权

关于套接字编程
套接字编程
IP地址+端口号就成为套接字
在TCP协议中。建立两个连接的进程个字有一个socket来标识，那么这两个socket组成desocketpair就表示一个唯一链接
socket用来描述网络连接一对一关系
socket地址的数据类型及相关函数
这里写图片描述
第一个是通用接口
第二个表示IPV4的地址使用socketaddr_in
第三个表示预间套接字
这样我们只需要知道某种socket结构体的首地址，就可以根据地质的具体类型字段确定结构体中的内容
服务器需要进行的操作
1>、服务器首先获得sockect调用socket函数
在这里我们用的是IPV4因此类型选择AF_INET。
由于是16位地址类型的AF_INET的所以我们采用sockaddr_in 类型的
客户端和服务端是一样的
这里写图片描述
sa_family:表示地址所属的类型 在这道理我们是AF_INET
_be16代表16位端口号
为什么是16位，因为在这里我们是从上往下进行交付
TCP的报头是16位端口号
server.sin_port=htons(atoi(port));
htons的功能：将一个无符号短整型数值转换为网络字节序，即大端模式(big-endian)
2>、接下来就应该绑定端口 调用bind函数绑定IP和端口号
3>、接下来服务器需要不断去监听有没有客户端发来请求调用listen函数
4>、接下来我们需要调用accept函数
accept()系统调用主要用在基于连接的套接字类型，比如SOCK_STREAM和SOCK_SEQPACKET。它提取出所监听套接字的等待连接队列中第一个连接请求，创建一个新的套接字，并返回指向该套接字的文件描述符。新建立的套接字不在监听状态，原来所监听的套接字也不受该系统调用的影响。
5>、之后就可以进行一系列的读写操作了

2、客户端进行的操作就比较简单，他只需要和服务器进行连接
version1版本的server和client 

server.c
#include<stdio.h>
#include <sys/types.h>        
#include <sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
int startup(char*ip,int port)
{
     int sock=socket(AF_INET,SOCK_STREAM,0);
     if(sock<0)
     {
          perror("socket");
          exit(2);
     }
    struct sockaddr_in server;
     server.sin_family=AF_INET;
     server.sin_port=htons(atoi(port));
     server.sin_addr.s_addr=inet_addr(ip);
    if(bind(sock,(struct sockaddr*)&server,sizeof(struct sockaddr_in))<0)
     {
          perror("bind");
          exit(3);
     }
    if(listen(sock,10)<0)
     {
          perror("listen");
          exit(4);
     }
     return sock;
}
void *usage(const char*proc)
{
   printf("%s [local_ip] [local_port]\n",proc);
   exit(5);
}
int main(int argv,char*argc[])
{
     if(argv!=3)
     {
          usage(argc[0]);
          exit(6);
     }
     int listen_sock=startup(argc[1],argc[2]);
     printf("fd:%d\n",listen_sock);
     while(1)
     {
          struct sockaddr_in client;
          socklen_t len=sizeof(client);
          int newsock=accept(listen_sock,(struct sockaddr*)&client,&len);
        if(newsock<0)
          {
               perror("accept");
               continue;
          }
          printf("get a client:[%s:%d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
          char buf[1024];
          while(1)
          {
            ssize_t ret=read(newsock,buf,sizeof(buf)-1);
               if(ret>0)
               {
                    buf[ret]=0;
                   printf("client say:%s\n",buf);
                   write(newsock,buf,sizeof(buf)-1);
               }
               else if(ret==0)
               {
                    printf("client quit!\n");
                    break;
               }
               else
               {
                    perror("read");
                    exit(7);
               }
          } 
         close(newsock);
     }
     close(listen_sock);
     return 0;
}


client.c
#include<stdio.h>
#include <sys/types.h>        
#include <sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
void Usage(char*proc)
{
   printf("%s [server_ip] [server_port]\n",proc);
   return 1;
}
int main(int argv,char*argc[])
{
     if(argv!=3)
     {
          Usage(argc[0]);
        return 2;
     }
     int sock=socket(AF_INET,SOCK_STREAM,0);
     struct sockaddr_in server_sock;
     server_sock.sin_family=AF_INET;
     server_sock.sin_port=htons(atoi(argc[2]));
     server_sock.sin_addr.s_addr=inet_addr(argc[1]);
     if(connect(sock,(struct sockaddr*)(&server_sock),sizeof(server_sock))<0)
     {
        perror("connect");
        return 3;
     }
   while(1)
  {
    printf("please Enter:\n");
    fflush(stdout);
     char buf[1024];
    ssize_t ret=read(0,buf,sizeof(buf)-1);
     if(ret>0)
     {
       buf[ret-1]=0;
       write(sock,buf,sizeof(buf)-1);
        read(sock,buf,sizeof(buf)-1);
        printf("server say:%s\n",buf);
     }
}
   close(sock);
   return 3;
}

多进程版本的：

**server.c**

#include<stdio.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
int startup(char*ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock<0)
    {
        perror("socket");
        exit(2);
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(port));
    server.sin_addr.s_addr = inet_addr(ip);
    if (bind(sock, (struct sockaddr*)&server, sizeof(struct sockaddr_in))<0)
    {
        perror("bind");
        exit(3);
    }
    if (listen(sock, 10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}
void *usage(const char*proc)
{
    printf("%s [local_ip] [local_port]\n", proc);
    exit(5);
}
int main(int argv, char*argc[])
{
        if(argv!=3)
        {
            Usage(argc[0]);
         }
    int listen_sock = startup(argc[1], argc[2]);
    printf("fd:%d\n", listen_sock);
    while (1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int newsock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if (newsock<0)
        {
            perror("accept");
            continue;
        }
        printf("get a client:[%s:%d]\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
        pid_t id = fork();
        if (id == 0)
        {
                        close(listen_sock);
            if (fork() == 0)
            {
                char buf[1024];
                while (1)
                {
                    ssize_t ret = read(newsock, buf, sizeof(buf)-1);
                    if (ret>0)
                    {
                        buf[ret] = 0;
                        printf("client say:%s\n", buf);
                        write(newsock, buf, sizeof(buf)-1);
                    }
                    else if (ret == 0)
                    {
                        printf("client quit!\n");
                        close(newsock);
                        exit(7);
                    }
                    else
                    {
                        perror("read");
                        exit(8);
                    }
                }
            }
            else
            {
                exit(9);
            }
        }
        else if (id>0)
        {
            close(newsock);
                        while((waitpid(-1,NULL,WNOHANG)>0));
                        continue;
        }
        else
        {
            perror("fork");
            exit(9);
        }
    }
    close(listen_sock);
    return 0;
}

多线程版本的：

#include<stdio.h>
#include <sys/types.h>         
#include <sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>
#include<string.h>
#include<unistd.h>
#include<stdlib.h>
#include <pthread.h>
int startup(char*ip, int port)
{
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock<0)
    {
        perror("socket");
        exit(2);
    }
    struct sockaddr_in server;
    server.sin_family = AF_INET;
    server.sin_port = htons(atoi(port));
    server.sin_addr.s_addr = inet_addr(ip);
    if (bind(sock, (struct sockaddr*)&server, sizeof(struct sockaddr_in))<0)
    {
        perror("bind");
        exit(3);
    }
    if (listen(sock, 10)<0)
    {
        perror("listen");
        exit(4);
    }
    return sock;
}
void *Usage(const char*proc)
{
    printf("%s [local_ip] [local_port]\n", proc);
    exit(5);
}
void* thread_handler(void*arg)
{
       int newsock=*((int*)arg);
            char buf[1024];
              while (1)
            {
             ssize_t ret = read(newsock, buf, sizeof(buf)-1);
             if (ret>0)
             {
                buf[ret] = 0;
                printf("client say:%s\n", buf);
                write(newsock, buf, sizeof(buf)-1);
             }
             else if (ret == 0)
             {
                printf("client quit!\n");
                close(newsock);
                exit(7);
             }
             else
             {
                perror("read");
                exit(8);
             }
       }
}


int main(int argv, char*argc[])
{
        if(argv!=3)
        {
            Usage(argc[0]);
         }
    int listen_sock = startup(argc[1], argc[2]);
    printf("fd:%d\n", listen_sock);
    while (1)
    {
        struct sockaddr_in client;
        socklen_t len = sizeof(client);
        int newsock = accept(listen_sock, (struct sockaddr*)&client, &len);
        if (newsock<0)
        {
            perror("accept");
            continue;
        }
        printf("get a client:[%s:%d]\n", inet_ntoa(client.sin_addr), ntohs(client.sin_port));
            pthread_t  tid;
            int ret=pthread_create(&tid,NULL,thread_handler,&newsock);
            if(ret<0)
             {
                perror("pthread_create");
                exit(9);
    }
        pthread_detach(tid);
}
    close(listen_sock);
    return 0;
 }

为什么会出现server bind失败
看下图：
由于我们的客户端还没有退出，服务器就先断开连接了造成了这种情况，为什么会出现这种现象呢？
这里写图片描述

这里写图片描述

通信双方建立TCP连接后，主动关闭连接的一方就会进入TIME_WAIT状态
TCP是全双工的通信，它是提供可靠传输的，它有着三次握手和四次挥手，在四次挥手的过程中，主动断开连接的一方会进入TIME_WAIT状态。如果服务器端先断开连接那么就会进入TIME_WAIT状态。为什么需要TIME_WAIT？TIME_WAIT是TCP协议用以保证被重新分配的socket不会受到之前残留的延迟重发报文影响的机制,是必要的逻辑保证。

persistence_s
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux c开发并发词典server与client
qq_27869357的博客
04-16 181
linux c多线程技术开发并发词典查询server与clientserver与client功能说明忠告下面开始代码正文 server与client功能说明 使用多线程并发技术实现服务端程序，解析所有客户端请求与回复，客户端功能有登录，注册，查单词，历史查询记录查询（功能可扩展，词库采用（key vaule形式）.txt格式村存储） 忠告 这不是优秀的代码手编写，各路高手请勿多多关照，代码有好有坏的地方，有什么问题还望各路高手指出，技术无限，分享精神有限 ------纯原创，转载请说明出处（代码不止我这一版
线程之间的通信socketpair【学习笔记】【原创】
12-18 362
平台信息:内核：linux3.1.0系统：android5.0平台：tiny4412 作者：庄泽彬(欢迎转载，请注明作者) 说明: 韦老师的安卓视频学习笔记 一、在一个进程中多个线程如何进行通信，主要使用的是socketpair的机制，详细代码如下: 1 #include <pthread.h> 2 #include <unistd.h> 3...
Linux 网络编程——并发服务器的三种实现模型
热门推荐
秋叶原 && Mike || 麦克
05-12 9万+
服务器设计技术有很多，按使用的协议来分有 TCP 服务器和 UDP 服务器，按处理方式来分有循环服务器和并发服务器。循环服务器与并发服务器模型在网络程序里面，一般来说都是许多客户对应一个服务器（多对一），为了处理客户的请求，对服务端的程序就提出了特殊的要求。目前最常用的服务器模型有：·循环服务器：服务器在同一时刻只能响应一个客户端的请求·并发服务器：服务器在同一时刻可以响应多个客户端的请求UDP ...
Linux下套接字详解（五）----基于fork多进程的TCP套接字（阻塞/同步/并发）
OSKernelLAB(gatieme)
01-31 5184
简介一个简单的改进方案是在服务器端使用多线程（或多进程）。多线程（或多进程）的目的是让每个连接都拥有独立的线程（或进程），这样任何一个连接的阻塞都不会影响其他的连接。具体使用多进程还是多线程，并没有一个特定的模式。传统意义上，进程的开销要远远大于线程，所以如果需要同时为较多的客户机提供服务，则不推荐使用多进程；如果单个服务执行体需要消耗较多的CPU资源，譬如需要进行大规模或长时间的数据运算或文件访问
recvfrom()收到数据，没有填充struct sockaddr和len
chienchia的专栏
12-09 1965
在学习steven的Unix Network Programming的UDP章节时，服务器的recvfrom在接收数据时，发现数据接收到了，但是recvfrom的结构体参数(struct sockaddr*)&client_addr和&len没有被填写，还是初始值。这是因为在recvfrom之前，要对len进行初始化， socklen_t len = sizeof(client_addr); re
使用TCPServer编写（多线程）socket服务
03-09
在IT行业中，网络编程是不可或缺的一部分，特别是在服务器端开发中，使用TCPServer编写多线程的socket服务是一项基础但重要的技术。本文将详细讲解如何使用TCPServer来实现这样的服务，以及多线程在其中的作用。 ...
socket_套接字_
09-28
在IT行业中，套接字（Socket）是一种网络通信机制，它允许不同的计算机通过网络进行数据交换。...通过实际编写和运行服务端和客户端代码，你可以直观地体验到套接字通信的魅力，并进一步提升自己的技术水平。
Python 网络编程之TCP客户端/服务端功能示例【基于socket套接字】
09-18
- **关闭套接字**：最后，服务端关闭与客户端的通信套接字`new_client_socket`和监听套接字`tcp_server_socket`。 在实际应用中，客户端和服务端可能需要处理更多的细节，如异常处理、多线程或多进程处理多个并发...
Python多线程套接字编程.docx
最新发布
06-12
Python的多线程套接字编程是实现高效网络服务的关键...总结来说，Python的多线程套接字编程结合了多线程的并发优势和套接字的网络通信能力，使得开发者能够构建高效、响应迅速的网络服务，满足复杂网络环境下的需求。
项目-局域网聊天室(linux c socket编程 和 多线程编程).rar
09-01
- 在Linux下，使用`socket()`函数创建套接字，`bind()`函数绑定IP地址和端口号，`listen()`函数使服务器进入监听状态，`accept()`函数等待并接受客户端连接，`connect()`函数则用于客户端连接服务器，`send()`和`...
基于多线程实现套接字服务端支持并发
weixin_34064653的博客
06-09 251
进程池|线程池（同步，异步 阻塞，非阻塞）多线程：IO密集型多进程：计算密集型线程是cpu运行单位，进程是资源单位 from socket import * from threading import Thread def comunicat(conn): while True: # 通信循环 try: data = co...
client
深蓝
06-18 734
[cpp] view plain copy  print? //***********************************************************************************   //文件说明：TSocket.h   //功能：   文件传输客户端实现头文件   //使用说明：使用TCP的IOCP实现,可以传
socketpair的用途以及实现
我的专栏
01-21 1685
一.概念及用途 一个问题：如何创建全双工管道？ 直接的办法当然是pipe两次，创建两组管道，但是有没有更简单的呢？ socketpair就可以了，man socketpair: socketpair - create a pair of connected sockets, The two sockets are indistinguishable，也就是说，用socketpair创建
网络程序设计（C++版） 知识点总结
小张的编程之旅
01-14 2105
1、TCP/IP协议层次,各层协议? 答：应用层、传输层、网络层、链路层； 1）应用层：FTP、Telnet、SMTP、HTTP、RIP、NFS、DNS  （2）传输层：传输控制协议TCP与用户数据报协议UDP （3）网际层协议：网际协议IP、网际控制报文协议ICMP、网际主机组管理协议IGMP、 （4）网络接口层：地址解析协议ARP和RARP 2、在Internet中定位一个应用
Linux网络套接字编程(2)-TCP传输+多线程+多进程
skrskr66的博客
06-11 718
TCP传输 TCP的三次握手 图解为TCP协议的传输过程。 客户端操作 服务端操作 1、创建套接字 1、创建套接字 2、向服务端发起连接 2、绑定地址信息 3、发送数据 3、监听(若有新的客户端，新建socket) 4、接收数据 4、接收已经连接成功的socket 5、关闭套接字 TCP传输-socket编程 通过C++实现一个类来封装tcp协议 //tcp...
MQTT使用的笔记（结合源代码）
q1165328963的博客
06-08 4012
MQTT理解（结合类库源代码） 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。 新的改变 我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能，帮助你用它写博客： 全新的界面设计 ，将会带来全新的写作体...
linux socket 编程
Top大杂烩
04-12 3万+
  socket    <!--google_ad_client = "pub-2299987709779770";google_ad_width = 300;google_ad_height = 250;goo
C# Socket多线程通信实战：服务器与客户端交互
"本文主要介绍了C#环境下的Socket多线程编程，讲解了套接字的基本概念、分类、工作原理，并提供了一个简单的聊天室程序作为实例，展示了如何在C#中实现服务器端和客户端的通信。 套接字是网络通信的基础，它允许...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值