Linux-socket编程

最新推荐文章于 2024-01-04 17:54:59 发布
最新推荐文章于 2024-01-04 17:54:59 发布
阅读量646 收藏
点赞数 2
文章标签： udp tcp socket 多进程 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Enthusiastic_boy/article/details/124915857
版权
本文详细介绍了UDP和TCP套接字编程的基本流程、接口和代码实现。对于UDP，强调了其无连接、不可靠和面向数据报的特性，并展示了服务端和客户端的代码实现。对于TCP，讲解了面向连接、可靠性和面向字节流的特性，以及服务端监听、获取新连接和客户端发起连接的步骤，同时分析了多进程和多线程在处理并发连接时的区别和解决方案。
摘要由CSDN通过智能技术生成

目录

UDP-socket编程

UDP特性

编程流程

接口

代码实现

 TCP-socket编程

TCP特性

编程流程

接口

 原理

代码实现

UDP-socket编程

UDP特性

无连接:UDP双方在发送数据之前是不需要进行沟通的。只需要知道对方的ip地址和端口号就好。

不可靠:不保证UDP数据是可靠，有序的到达对端

面向数据报:UDP应用层/网络层递交数据的时候，都是整条数据进行交付的。

编程流程

服务端：创建套接字，绑定地址信息，接收数据，发送数据，关闭套接字。

客户端：创建套接字，绑定地址信息（不推荐），发送数据，接收数据，关闭套接字。

创建套接字绑定地址信息的含义：将进程与网卡绑定，进程可以从网卡中接收数据，也可以是通过网卡发送数据。绑定ip，绑定端口，是为了在网络上标识一台主机和一个进程。对于发送方而言，就知道收方在哪台机器的哪个进程了。对于接收方而言，就知道网络数据从哪机器的那个进程发出了。

接口

1.创建套接字接口

2.绑定接口

3. 发送接口

 4.接收接口

5.关闭套接字接口

代码实现

在实现代码之前，可以先使用命令ifconfig命令查看当前电脑的ip地址，方便后续绑定，如下：

 服务端代码如下：

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(){
    //创建套接字
    int fd=socket(AF_INET,SOCK_DGRAM,0);
    if(fd<0){
        perror("socket");
        return 0;
    }
    struct sockaddr_in  addr;//地址信息的结构体
    addr.sin_family=AF_INET;//使用ipv4版本协议
    addr.sin_port=htons(9999);//转换为网络字节序
    addr.sin_addr.s_addr=inet_addr("10.0.24.6");//将ip地址转换为数字并且转换为网络字节序
    int ret=bind(fd,(struct sockaddr*)&addr,sizeof(addr));//绑定地址信息
    if(ret<0){
        perror("bind");
        return 0;
    }
    while(1){
        char buf[1024]={0};//将接收到的消息保存在buf中
        struct sockaddr_in src_addr;//用来保存recv_size接收到的客户端的地址信息
        socklen_t addrlen=sizeof(src_addr);
        ssize_t recv_size=recvfrom(fd,buf,sizeof(buf)-1,0,(struct sockaddr*)&src_addr,&addrlen);//接收消息，以及客户端地址信息
        if(recv_size<0){
            perror("recvfrom");
            return 0;
        }
        printf("%s,%d:%s\n",inet_ntoa(src_addr.sin_addr),ntohs(src_addr.sin_port),buf);//将接收到的消息以及源ip，源port，打印到屏幕
        memset(buf,0,sizeof(buf));//清空buf
        sprintf(buf,"i am serve");//往buf中写入内容
        sendto(fd,buf,strlen(buf),0,(struct sockaddr*)&src_addr,sizeof(src_addr));//给客户端回消息
    }
    close(fd);//关闭套接字描述符
    return 0;
}

编译运行：

 服务端阻塞在了recvfrom接口，现在正在等待客户端发送消息，现在可以使用命令netstat -anp | grep [端口号]来查看地址信息是否绑定成功，如下：

如果查询出现以上信息，说明地址信息绑定成功，注意：端口号是一个2字节16位的整数，只要不使用知名端口，就可以在此范围内随便给。

下面给出客户端的代码：

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include <iostream>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
using namespace std;
int main(int argc,char* argv[]){
    if(argc!=3){//命令行参数的个数必须是3个
        printf("./clint [ip] [port]\n");
        return 0;
    }
    char* ip=argv[1];//取出从命令行输入的ip
    int port=atoi(argv[2]);//将从命令行输入的字符串转化成整数
    int fd=socket(AF_INET,SOCK_DGRAM,0);//创建套接字
    if(fd<0){
        perror("socket");
        return 0;
    }
    struct sockaddr_in desaddr;//用来存放服务端的地址信息
    desaddr.sin_family=AF_INET;//使用ipv4协议
    desaddr.sin_port=htons(port);//将服务端的端口号转化为网络字节序并保存起来
    desaddr.sin_addr.s_addr=inet_addr(ip);//将服务端ip转化为数字，并转化为网络字节序保存起来
    while(1){
        printf("Please enter the content to send:");//提示用户输入要发送的内容
        fflush(stdout);//刷新缓冲区
        char buf[1024]={0};
        cin.getline(buf,1024);//接收用户发送的信息
        ssize_t send_size=sendto(fd,buf,strlen(buf),0,(struct sockaddr*)&desaddr,sizeof(desaddr));//把信息发送到服务端
        if(send_size<0){
            perror("sendto");
            return 0;
        }
        struct sockaddr_in souaddr;//用来保存服务端一会要发送的信息，这个可以不用写，因为服务端的地址信息已经知道了
        socklen_t addrlen=sizeof(souaddr);
        memset(buf,0,sizeof(buf));//清空buf
        ssize_t recv_size=recvfrom(fd,buf,sizeof(buf)-1,0,(struct sockaddr*)&souaddr,&addrlen);//接收服务端回的信息
        if(recv_size<0){
            perror("recvfrom");
            return 0;
        }
        printf("%s,%d:%s\n",inet_ntoa(souaddr.sin_addr),ntohs(souaddr.sin_port),buf);//将服务端回的信息打印出来
    }
    close(fd);
    return 0;
}

为什么客户端没有绑定地址信息呢？

其实在sendto函数内部，会检测当前进程有没有绑定地址信息，如果没有，操作系统会帮我们绑定地址信息。那么为什么我们不自己调用bind函数绑定？因为可能存在多个客户端，也就是说存在多个客户端进程。而代码只有一份，如果在代码中手动绑定了地址信息，意味着当前代码编译生成的可执行程序已经确定了要绑定的端口号，一旦启动后，端口号就被当前进程占用了，而在一台主机上端口号是不能重复的，再想启动相同的客户端就会失败。如果交给操作系统来给客户端分配端口号的话，是一定不会分配已经使用的端口号的，就可以运行多个客户端进程了。

编译运行后：

提示输入要发送的信息，下面来检测服务端是否可以收到客户端的信息：

客户端发送信息后，服务端可以正常接收到。

 TCP-socket编程

TCP特性

面向连接:TCP双方在发送数据之前需要建立好连接

可靠:TDP保证传输的数据是可靠，有序的到达对端

面向字节流:对于传输的数据没有明显的边界，接收方可以按照任意字节进行接收

编程流程

服务端：创建套接字，绑定地址信息，监听，获取新连接，接收数据，发送数据，关闭套接字

客户端：创建套接字，绑定地址信息（不推荐），发起连接，发送数据，接收数据，关闭套接字

接口

创建套接字、绑定地址信息、关闭套接字的接口与UDP相同，给出其他接口：

1.监听接口

2.获取新连接接口

3.发起连接接口

 4.发送接口

 5.接收接口

 原理

服务端调用listen接口监听后，等待客户端调用connect接口发起连接，连接建立后，服务端通过accept接口来获取新连接套接字，然后用这个新连接套接字来和客户端进行通信。

在解释的直白点：

服务端使用socket创建出来的套接字描述符，相当于“拉皮条的”，就是在侦听是否有新连接到来

服务端使用accept获取到的新连接套接字描述符（建立连接的过程在内核就已经完成了），相当于接客的“小红”，就是在同客户通信

代码实现

先来看客户端代码，跟UDP客户端不同的一点是发送数据时需要将连接先建立好，其他基本相同。

代码如下：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(){
    int fd=socket(AF_INET,SOCK_STREAM,0);///创建套接字
    if(fd<0){
        perror("socket");
        return 0;
    }
    sockaddr_in addr;//用来保存服务端的地址信息，也就是数据发往哪里
    addr.sin_family=AF_INET;//使用ipv4协议
    addr.sin_addr.s_addr=inet_addr("120.53.243.185");//将ip转化成数字，并转化为网络字节序
    addr.sin_port=htons(9999);//将port转化为网络字节序
    int ret=connect(fd,(sockaddr*)&addr,sizeof(addr));//发起连接,注意是在服务端监听后
    if(ret<0){
        perror("connect");
        return 0;
    }
    while(1){
        char buf[1024]={0};
        printf("Please enter your message:");//提示用户输入
        fflush(stdout);
        scanf("%s",buf);
        ret=send(fd,buf,strlen(buf),0);//给服务端发送数据
        if(ret<0){
            continue;
        }
        memset(buf,0,sizeof(buf));//清空buf
        ssize_t recvsize=recv(fd,buf,sizeof(buf)-1,0);//接收服务端发回的数据
        if(recvsize<0){
            perror("recv");
        }else if(recvsize==0){//recvsize==0，说明对端关闭了连接
            printf("The perr closed the connection\n");
            exit(1);
        }
        printf("%s\n",buf);

        }
    return 0;
}

服务端代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main(){
    int fd=socket(AF_INET,SOCK_STREAM,0);//创建监听套接字
    if(fd<0){
        perror("socket");
        return 0;
    }
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;//使用ipv4协议
    addr.sin_port=htons(9999);//将port转化为网络字节序并保存
    addr.sin_addr.s_addr=inet_addr("10.0.24.6");//将ip转化为数字并转化为网络字节序后保存
    int ret=bind(fd,(struct sockaddr*)&addr,sizeof(addr));//绑定地址信息
    if(ret<0){
        perror("bind");
        return 0;
    }
    listen(fd,5);//监听
    sockaddr_in cli_addr;//用来保存客户端的地址信息
    socklen_t cli_len=sizeof(cli_addr);//地址信息长度
    while(1){
        int newfd=accept(fd,(sockaddr*)&addr,&cli_len);//获取新连接套接字描述符
        if(newfd<0){
            perror("accept");
            return 0;
        }
        char buf[1024]={0};
        ssize_t recvsize=recv(newfd,buf,sizeof(buf)-1,0);
        if(recvsize<0){
            perror("recv");
            return 0;
        }else if(recvsize==0){//recvsize==0,说明对端关闭了连接
            printf("The peer close the connection\n");
        }
        printf("%s\n",buf);//打印服务端发送的信息
        memset(buf,0,sizeof(buf));//清空buf
        sprintf(buf,"%s,%d:i am serve,i get your message",inet_ntoa(addr.sin_addr),ntohs(addr.sin_port));
        send(newfd,buf,strlen(buf),0);//向服务端发送数据，注意要使用accept获取到的套接字描述符
    }
    return 0;
}

将客户端与服务端代码写完后，来测试是否能正常进行通信：

先启动服务端进行监听，然后再启动客户端1向服务端发送数据，接着启动客户端2向服务端发送数据。做完这些操作后，再使用客户端1向服务端发送数据，再使用客户端2向服务端发送数据，后面这两次发送都会失败，如下图：

这种现象说明服务端的代码是有问题的。存在两个问题：

1.在循环中accept如果获取不到新连接套接字就会阻塞掉，导致不能接收客户端发送的数据

2.每次获取到的新连接套接字描述符会被下一次获取到的新连接套接字描述符覆盖掉

那么如何解决以上问题呢？

可以采用两种解决方式：

1.多进程：服务端代码在获取到新连接套接字描述符后就创建子进程，让子进程拿着这个新连接套接字描述符去和客户端通信。如下图所示，子进程会将父进程files_struct也拷贝一份，那么在子进程中就也存在监听套接字描述符和新连接套接字描述符。

 注意：必须在父进程获取新连接套接字描述符之后再创建子进程，这样子进程才会拥有这个新连接套接字描述符。在创建完子进程后，为了防止资源浪费，父进程需要关闭这个新连接套接字描述符，而子进程需要关闭监听套接字描述符。

服务端代码如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <wait.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
void SignalCallBack(int sig){
    printf("%d\n",sig);
    wait(NULL);
}
int main(){
    signal(SIGCHLD,SignalCallBack);
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd<0){
        perror("socket");
        return 0;
    }
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("0.0.0.0");
    int ret=bind(fd,(struct sockaddr*)&addr,sizeof(addr));
    if(ret<0){
        perror("bind");
        return 0;
    }
    listen(fd,5);
    sockaddr_in cli_addr;
    socklen_t cli_len=sizeof(cli_addr);
    while(1){
        int newfd=accept(fd,(sockaddr*)&cli_addr,&cli_len);
        if(newfd<0){
            perror("accept");
            return 0;
        }
        pid_t pid=fork();//创建子进程
        if(pid<0){
            close(newfd);
        }else if(pid==0){//子进程逻辑：子进程拿着新连接套接字描述符去和客户端通信
            close(fd);//关闭监听套接字描述符
            while(1){
                char buf[1024]={0};
                ssize_t recvsize=recv(newfd,buf,sizeof(buf)-1,0);
                if(recvsize<0){
                    perror("recv");
                    exit(0);
                }else if(recvsize==0){
                    printf("close the connection:%s,%d\n",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port));
                    exit(0);
                }
                printf("%s,%d:%s\n",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port),buf);
                memset(buf,0,sizeof(buf));
                sprintf(buf,"%s,%d:i am serve,i get your message",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port));
                send(newfd,buf,strlen(buf),0);
            }
        }else{//父进程逻辑
            close(newfd);//关闭新连接套接字描述符
        }
    }
    return 0;
}

编译运行，测试如下：

 使用命令查看父子进程此时的状态：

 

2.多线程：服务端代码在获取到新连接套接字描述符后就创建工作线程，让工作线程拿着这个新连接套接字描述符去和客户端通信。因为线程与线程之间共享文件描述符，所以使用多线程也可以达到目的。

代码如下：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
class Cli_info{//将新连接套接字描述符与客户端地址信息结构封装起来，以便于交给工作线程使用
public:
    int newfd;
    sockaddr_in cli_addr;
};
void* start(void* arg){//工作线程执行的代码,完成收发数据
    pthread_detach(pthread_self());//线程分离，线程退出后，可以不用手动回收
    Cli_info* cli=(Cli_info*)arg;
    int newfd=cli->newfd;//取出新连接套接字描述符
    sockaddr_in cli_addr=cli->cli_addr;//取出客户端地址信息
    while(1){//收发数据
        char buf[1024]={0};
        ssize_t recvsize=recv(newfd,buf,sizeof(buf)-1,0);
        if(recvsize<0){
            perror("recv");
            return 0;
        }else if(recvsize==0){
            printf("The peer close the connection:%s,%d\n",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port));
            close(newfd);
            delete cli;
            pthread_exit(NULL);
        }
        printf("%s,%d:%s\n",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port),buf);
        memset(buf,0,sizeof(buf));
        sprintf(buf,"%s,%d:i am serve,i get your message",inet_ntoa(cli_addr.sin_addr),ntohs(cli_addr.sin_port));
        send(newfd,buf,strlen(buf),0);
    }
}
int main(){
    int fd=socket(AF_INET,SOCK_STREAM,0);
    if(fd<0){
        perror("socket");
        return 0;
    }
    struct sockaddr_in addr;
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("0.0.0.0");
    int ret=bind(fd,(struct sockaddr*)&addr,sizeof(addr));
    if(ret<0){
        perror("bind");
        return 0;
    }
    listen(fd,5);
    sockaddr_in cli_addr;
    socklen_t cli_len=sizeof(cli_addr);
    while(1){
        int newfd=accept(fd,(sockaddr*)&cli_addr,&cli_len);
        if(newfd<0){
            perror("accept");
            return 0;
        }
        Cli_info* cli=new Cli_info;
        cli->newfd=newfd;//保存新连接套接字描述符，交给工作线程使用
        memcpy(&cli->cli_addr,&cli_addr,sizeof(cli_addr));//保存客户端地址信息，交给工作线程使用
        pthread_t thread; 
        int ret=pthread_create(&thread,NULL,start,(void*)cli);//创建工作线程，并传递相应的数据
        if(ret<0){
            close(newfd);
            delete cli;
        }
    }
    return 0;
}

编译运行，测试：

查看serve进程与线程：

Enthusiastic_boy
关注
linux-socket网络编程详解.doc
01-16
在Linux环境中，Socket编程涉及到创建、配置和使用Socket对象进行数据传输。 1. **Socket基本概念** - **Socket接口**：Socket接口是一组函数，用于实现应用程序和TCP/IP网络之间的通信。它是操作系统提供的标准...
UDP编程
cabbage2008的专栏
05-05 355
TCP是建立可靠连接，并且通信双方都可以以流的形式发送数据。相对TCP，UDP则是面向无连接的协议。 使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。 虽然用UDP传输数据不可靠，但它的优点是和TCP比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。 我们来看看如何通过UDP协议传输数据。和TCP类似，使用UDP的通信双方也分为客户端和服务器。服务器首先需要绑定端口：
Socket编程（C语言实现）——TCP协议（网络间通信AF_INET）的流式（SOCK_STREAM）+报式（SOCK_DGRAM）传输
m0_67403272的博客
08-24 4200
① 所谓Socket通常也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过“套接字”向网络发出请求或者应答网络请求。② Socket是连接运行在网络上的两个程序间的双向通信的端点。③ 网络通讯其实指的就是Socket间的通讯。④ 通讯的两端都有Socket，数据在两个Socket之间通过IO来进行传输。
计算机网络基本概念＜三＞UDP和TCP协议详解
GoodManS的CSDN
10-20 3458
UDP和TCP都是传输层的重要协议，也是学习网络的必备内容了，接下来这篇我们就详细分析一下这两者的内容，以及这两者的区别
Qt实现UDP单播、组播和广播功能
我智商开挂的博客
01-04 5671
对象会选择其中一个地址来接收数据包。这个选择通常由操作系统或网络栈决定，并且可能会受到各种因素的影响，例如网络接口的优先级、路由表等。对象绑定到本机的所有 IPv4 地址，但实际上它只能通过其中一个地址接收数据包。然而，需要注意的是，绑定到多个 IPv4 地址并不意味着可以同时从多个地址接收数据包。对象可以接收通过本机的任意一个 IPv4 地址发送到指定端口的数据包。对象绑定到本机的所有 IPv4 地址。多网口的话，要指定唯一的网卡ip，之后加入组播。对象只能通过一个 IP 地址接收数据包。
Qt之UDP通信
风间琉璃的博客
10-03 2万+
UDP（User Datagram Protocol 即用户数据报协议）是一个轻量级的，不可靠的，面向数据报的无连接协议。由于 UDP 的特性：它不属于连接型协议，因而具有资源消耗小，处理速度快的优点，所以通常音频、视频和普通数据在传送时使用 UDP 较多，因为它们即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。UDP 通信示意图如下：UDP 消息传送有三种模式，分别是单播、广播和组播三种模式。①单播（unicast）
Linux-socket网络编程基础完整版资料.ppt
11-13
Linux Socket 网络编程基础 Linux Socket 网络编程基础是指在 Linux 操作系统中使用 Socket 编程技术来实现网络通信的基础知识。它涵盖了 Socket 的定义、 Socket 的类型、网络协议、数据包头信息、BSD Socket 网络...
socket_linux-socket网络编程详解_
10-01
在Linux Socket编程中，我们需要定义服务器和客户端的网络地址，这通常使用`struct sockaddr_in`结构体完成。包含IP地址和端口号。 ```c struct sockaddr_in server; server.sin_family = AF_INET; server.sin_addr...
linux-c++ socket编程
05-13
在IT领域，Linux环境下的C++ Socket编程是网络通信的核心技术之一。Socket接口提供了一种在不同进程间通过网络进行通信的方法，无论这些进程是否在同一台机器上。本压缩包包含了一个简单的TCP服务器（TCPServer.zip...
HP-Socket编译-Linux
最新发布
05-20
首先，我们需要了解Linux socket编程的基本概念。Socket是进程间通信的一种方式，它允许两个或多个运行在相同或不同机器上的程序通过网络进行通信。在Linux中，socket API是基于Berkeley套接字模型的，提供了丰富的...
简单理解socket（AF_INET&SOCK_STREAM,SOCK_DGRAM）
热门推荐
博客
11-17 5万+
套接字 在任何类型的通信开始之前，网络应用程序都必须创建套接字。 套接字最初是为同一主机上的应用程序所创建，使得主机上运行的一个程序（又名一个进程）与另一个运行的程序进行通信。这就是所谓的进程间通信（Inter Process Communication，IPC） 有两种类型的套接字：基于文件的和面向网络的。 基于文件的 家族名：AF_UNIX （又名AF_LOCAL，在POSIX1.g...
没有IP和端口号，可以进行socket通信吗？
码农爱学习的博客
10-24 2362
在使用socket通信时，无论是本机内部通信，还是两台机器通信，也无论是TCP的方式，还是UDP的方式，一般都要指定IP和端口号。在Linux开发中，如果是同一台设备内部通信，也可以不需要IP和端口号，这就是Unix域socket通信，它实际上是通过文件的方式实现通信，从而不再需要IP和端口号。本篇就来介绍了Unix域socket的使用示例。
TCP/IP网络编程之--socket编程
u013416923的博客
07-06 1765
TCP/IP socket，支持多线程
socket网络编程入门
Stephen8848的博客
05-14 782
网络编程 实现两台或多台已经联网的计算机互相交换数据的行为,就是网络编程. 我们日常使用的操作系统已经为我们提供了socket, 不需要熟悉网络数据传输的原理, 也能掌握网络编程. windows中的socket与Linux中的有何区别? 相同 Linux通常会用文件描述符来表示或区分已经打开了的文件; windows通过文件句柄的方式来表示,和上述的Linux的文件描述符是类似的概念; 不同 Linux的一切都是文件,所以网路连接也是一个文件. Windows则会将socket和文件区分开来,因此在W
与socket网络编程有关的函数
主要记录嵌入式学习与开发过程。
07-12 1867
以下内容源于网络资源的学习与整理，如有侵权请告知删除。
套接口、ip、端口号相关
cpp加油站的专栏
06-10 1091
1. 网络相关概念 1.1 套接口的概念 套接口，也叫“套接字”。是操作系统内核中的一个数据结构，它是网络中的节点进行相互通信的门户。网络通信，归根到底还是进程间的通信（不同计算机上的进程间通信）。在网络中，每一个节点（计算机或路由）都有一个网络地址，也就是IP地址。两个进程通信时，首先要确定各自所在的网络节点的网络地址。但是，网络地址只能确定进程所在的计算机，而一台计算机上很可能同时运行着多个进...
TCP/IP和socket的关系
05-30 561
TCP/IP和Socket的关系  要写网络程序就必须用Socket，这是程序员都知道的。而且，面试的时候，我们也会问对方会不会Socket编程？一般来说，很多人都会说，Socket编程基本就是listen，accept以及send，write等几个基本的操作。是的，就跟常见的文件操作一样，只要写过就一定知道。 对于网络编程，我们也言必称TCP/IP，似乎其它网络协议已经不存在了。
Linux网络编程之Socket套接字
小鱼学编程
06-11 2674
在网络编程中，我们经常会提到 socket 这个词，它的中文翻译为套接字，有的时候也叫做套接口。今天，我们来学习这个套接字
使用udp进行单播通信和tcp中的通信的比较
Littlehero_121的博客
05-08 1319
一、ip地址和端口号 tcp通信和udp通信都需要指定ip地址和端口号，而在同一台计算机上进行通信时，并且实现的是一对一进行通信的时候。 区别：1、tcp实现一对一通信的时候需要将客户端和服务器的ip地址和端口号都需要设置成一致的，如：ip：127.0.0.1，端口号：8888 2、udp实现一对一通信的时候，客户端和服务器的ip地址是相同的，但是两个的端口号却不是一致的，如：客户端：ip:...
Linux Socket编程实践指南
"《Linux Socket编程实战》是Warren W. Gay所著的一本关于Linux网络编程的书籍，主要关注Socket编程技术。本书通过实例详细介绍了如何在Linux环境下使用Socket进行网络通信。" Linux Socket编程是开发网络应用程序...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值