【网络】：网络套接字（TCP）

最新推荐文章于 2024-09-13 18:41:04 发布
最新推荐文章于 2024-09-13 18:41:04 发布
阅读量1.4k 收藏 14
点赞数 35
分类专栏： 网络 文章标签： 网络 tcp/ip 网络协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73790767/article/details/135914425
版权

网络套接字（TCP）

一.编写TCP服务器

1.先搭一个架子

在这里插入图片描述

2.创建sockfd

在这里插入图片描述

domain参数依然是AF_INET(因为是IPV4)

在这里插入图片描述

type方式选择SOCK_STREAM（提供可靠的连接方式）

在这里插入图片描述

protocol协议类型默认缺省0

当然创建套接字是有可能失败的，所以这里加了一个日志(lg)文件，如果失败就打印日志（下面也会有该日志的完整源代码），注意：也可以直接打印在显示器上，但用日志更规范。

在这里插入图片描述

3创建并填充结构体

这里需要注意的是，填port时要使用htons函数转换成网络字节序（也就是大端），同时ip也要从字符串类型转换成int类型(有多种函数，这里选择inet_aton)。具体原因可以看上一篇博客（Udp）。

在这里插入图片描述

4.绑定内核

在这里插入图片描述

参数：1.绑定的套接字，2.绑定的结构体，3.结构体大小。

在这里插入图片描述

5.进行监听

TCP与UDP不同的是，它是面向连接的，服务器一般是比较“被动”的，服务器一直要处于等待连接的状态，我们一般称为监听。

在这里插入图片描述

在这里插入图片描述

6.对main函数进行构建，使用命令行传参方式传入端口号

在这里插入图片描述

7.接着编写Start部分代码

主要分为两步：1.获取新连接，2.根据新连接来通信。

在这里插入图片描述

这里的三个参数不必多说，关键在它的返回值也是一个套接字。它与最开始创建的套接字的功能划分不同，返回的这个套接字才是主要提供服务的。而最开始的套接字是帮助创建监听的，所以一般称它为listensock_。

在这里插入图片描述

8.编写服务代码

由于Tcp是面向字节流的，所以我们可以直接使用文件操作函数进行操作。

在这里插入图片描述

9.进行阶段性测试

由于还没有写客户端，所以我们可以使用telnet，它可以指定服务远程登陆，ip：127.0.0.1表示本地环回，端口号8888。如果没有该命令，可以yum -y install telnet。注意：下面我将Main.cc文件编译成了Tcpserver，启动该文件，在后面跟上端口号8888.

在这里插入图片描述

接着ctrl+6+]，然后回车，就可以发消息了。

在这里插入图片描述

退出：ctrl+6+]，输入quit。

在这里插入图片描述

二.编写Tcp客户端

1.创建套接字

在这里插入图片描述

2.绑定

客户端需要进行绑定吗？答案是需要的，但是不需要像服务器一样显示的绑定。因为无论是Udp还是Tcp，它都是socket进行通信，一定需要ip+port来进行区别，这样多个主机间才能进行区分。对于服务器来说，这个端口号要确定，因为其它客户端要对服务器发消息，就需要知道服务器的端口号。对于客户端来说，这个端口号是多少不重要，重要的是唯一，因为客户端对服务器发消息后，服务器就能通过结构体知道你的端口号和ip，所以客户端不需要显示的绑定。

Udp是在第一次发消息时绑定，而Tcp在发起connect时进行绑定。

在这里插入图片描述

在生活中，我们通过各种广告推广或者商店来获取服务器的ip和port，在这里我们修改一下main函数来收到传入服务器的ip和port。

在这里插入图片描述

3.测试

在这里插入图片描述

在这里插入图片描述

这样算是完成了一个框架，但有一个问题是目前是单进程，也就是说同时只能有一个客户端，很明显不符合预期，接下来改成多进程版。

三.多进程

在这里插入图片描述

在这里插入图片描述

首先为什么要close(listensockfd_)呢？因为我们只需要父进程一个提供监听功能就行了。为什么要close(sockfd)呢？因为我们将具体的服务功能交给了子进程，所以父进程就不需要这个fd了。当然这并没有完成多进程版，因为父进程会一直阻塞，有多种解决办法，这里选择再创建孙子进程，让子进程直接释放，孙子进程交给OS管理，这样父进程就不会阻塞了。（不了解的可以看看博客进程等待）

在这里插入图片描述

但是这种创建进程的成本实在太高了，一般连个三四十个就无了，所以为了高性能，我们可以搞一个多线程版本。

四.多线程版本

在创建线程后，我们使用pthread_detach，将主线程和其它线程分离，这样在其它线程提供服务时，主线程依然能自主运行。（不了解该函数的可以看博客线程（二））

在这里插入图片描述

在这里插入图片描述

对于线程创建不熟悉的可以看看博客线程（一），这里因为线程函数是在类内创建的，会自带一个this指针，不符合参数要求，所以改成静态的。接下来给线程函数进行传参。（由于线程函数是静态的，不能直接使用类内函数，所以我们可以将Tcpserver类一并当参数传入）

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

显然创建线程依然有代价，服务器在运行时一直有用户进入退出，所以会不断创建销毁，那么我们如何将线程多次利用呢？下面来线程池版。

五.线程池版+完整源代码

具体线程池代码如何写，可以看我的博客线程池，这里就直接使用了。简单来说就是向线程池里不断push任务，然后多个线程去竞争任务。 可以使用该命令检测线程个数ps -aL | head -1 && ps -aL | grep 程序名。

注意：为了保证服务器不被长时间连接，当前服务是只提供一次，使用客户端发消息时，每发一条就会重新建立一个连接。

在这里插入图片描述

makefile

.PHONY:all
all:Tcpserver Tcpclient

Tcpserver:Main.cc
	g++ -o $@ $^ -std=c++11 -lpthread
Tcpclient:Tcpclient.cc
	g++ -o $@ $^ -std=c++11


.PHONY:clean
clean:
	rm -f Tcpclient Tcpserver

log.hpp

#pragma once

#include <iostream>
#include <time.h>
#include <stdarg.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>

#define SIZE 1024

#define Info 0
#define Debug 1
#define Warning 2
#define Error 3
#define Fatal 4

#define Screen 1
#define Onefile 2
#define Classfile 3

#define LogFile "log.txt"

class Log
{
public:
  Log()
  {
    printMethod = Screen;
    path = "./log/";
  }
  void Enable(int method)
  {
    printMethod = method;
  }
  std::string levelToString(int level)
  {
    switch (level)
    {
    case Info:
      return "Info";
    case Debug:
      return "Debug";
    case Warning:
      return "Warning";
    case Error:
      return "Error";
    case Fatal:
      return "Fatal";
    default:
      return "None";
    }
  }

  void printLog(int level, const std::string &logtxt)
  {
    switch (printMethod)
    {
    case Screen:
      std::cout << logtxt << std::endl;
      break;
    case Onefile:
      printOneFile(LogFile, logtxt);
      break;
    case Classfile:
      printClassFile(level, logtxt);
      break;
    default:
      break;
    }
  }
  void printOneFile(const std::string &logname, const std::string &logtxt)
  {
    std::string _logname = path + logname;
    int fd = open(_logname.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0666); // "log.txt"
    if (fd < 0)
      return;
    write(fd, logtxt.c_str(), logtxt.size());
    close(fd);
  }
  void printClassFile(int level, const std::string &logtxt)
  {
    std::string filename = LogFile;
    filename += ".";
    filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
    printOneFile(filename, logtxt);
  }

  ~Log()
  {
  }
  void operator()(int level, const char *format, ...)
  {
    time_t t = time(nullptr);
    struct tm *ctime = localtime(&t);
    char leftbuffer[SIZE];
    snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d %d:%d:%d]", levelToString(level).c_str(),
             ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday,
             ctime->tm_hour, ctime->tm_min, ctime->tm_sec);

    va_list s;
    va_start(s, format);
    char rightbuffer[SIZE];
    vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
    va_end(s);

    // 格式：默认部分+自定义部分
    char logtxt[SIZE * 2];
    snprintf(logtxt, sizeof(logtxt), "%s %s", leftbuffer, rightbuffer);

    // printf("%s", logtxt); // 暂时打印
    printLog(level, logtxt);
  }

private:
  int printMethod;
  std::string path;
};

Log lg;

ThreadPool.hpp

#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <queue>
#include <pthread.h>
#include <unistd.h>

struct ThreadInfo
{
  pthread_t tid;
  std::string name;
};

static const int defalutnum = 5;

template <class T>
class ThreadPool
{
public:
  void Lock()
  {
    pthread_mutex_lock(&mutex_);
  }
  void Unlock()
  {
    pthread_mutex_unlock(&mutex_);
  }
  void Wakeup()
  {
    pthread_cond_signal(&cond_);
  }
  void ThreadSleep()
  {
    pthread_cond_wait(&cond_, &mutex_);
  }
  bool IsQueueEmpty()
  {
    return tasks_.empty();
  }
  std::string GetThreadName(pthread_t tid)
  {
    for (const auto &ti : threads_)
    {
      if (ti.tid == tid)
        return ti.name;
    }
    return "None";
  }

public:
  static void *HandlerTask(void *args)
  {
    ThreadPool<T> *tp = static_cast<ThreadPool<T> *>(args);
    std::string name = tp->GetThreadName(pthread_self());
    while (true)
    {
      tp->Lock();

      while (tp->IsQueueEmpty())
      {
        tp->ThreadSleep();
      }
      T t = tp->Pop();
      tp->Unlock();

      t();
    }
  }
  void Start()
  {
    int num = threads_.size();
    for (int i = 0; i < num; i++)
    {
      threads_[i].name = "thread-" + std::to_string(i + 1);
      pthread_create(&(threads_[i].tid), nullptr, HandlerTask, this);
    }
  }
  T Pop()
  {
    T t = tasks_.front();
    tasks_.pop();
    return t;
  }
  void Push(const T &t)
  {
    Lock();
    tasks_.push(t);
    Wakeup();
    Unlock();
  }
  static ThreadPool<T> *GetInstance()
  {
    if (nullptr == tp_) // ???
    {
      pthread_mutex_lock(&lock_);
      if (nullptr == tp_)
      {
        std::cout << "log: singleton create done first!" << std::endl;
        tp_ = new ThreadPool<T>();
      }
      pthread_mutex_unlock(&lock_);
    }

    return tp_;
  }

private:
  ThreadPool(int num = defalutnum) : threads_(num)
  {
    pthread_mutex_init(&mutex_, nullptr);
    pthread_cond_init(&cond_, nullptr);
  }
  ~ThreadPool()
  {
    pthread_mutex_destroy(&mutex_);
    pthread_cond_destroy(&cond_);
  }
  ThreadPool(const ThreadPool<T> &) = delete;
  const ThreadPool<T> &operator=(const ThreadPool<T> &) = delete; // a=b=c
private:
  std::vector<ThreadInfo> threads_;
  std::queue<T> tasks_;

  pthread_mutex_t mutex_;
  pthread_cond_t cond_;

  static ThreadPool<T> *tp_;
  static pthread_mutex_t lock_;
};

template <class T>
ThreadPool<T> *ThreadPool<T>::tp_ = nullptr;

template <class T>
pthread_mutex_t ThreadPool<T>::lock_ = PTHREAD_MUTEX_INITIALIZER;

Task.hpp

#pragma once
#include <iostream>
#include <string>
#include <string.h>
#include "log.hpp"

extern Log lg;

class Task
{
public:
  Task(int sockfd, const std::string &clientip, const uint16_t &clientport)
      : sockfd_(sockfd), clientip_(clientip), clientport_(clientport)
  {
  }
  Task()
  {
  }
  void run()
  {
    // 测试代码，收一个消息再发回去
    char buffer[4096];
    ssize_t n = read(sockfd_, buffer, sizeof(buffer));
    if (n > 0)
    {
      buffer[n] = 0;
      std::cout << "client say#" << buffer << std::endl;
      std::string echo_string = "tcpserver echo#";
      echo_string += buffer;

      n=write(sockfd_, echo_string.c_str(), echo_string.size());
      if(n<0)
      {
        lg(Warning, "write error,errorno:%d,errstring:%s", errno, strerror(errno));
      }
    }
    else if (n == 0) // 结束服务
    {
      lg(Info, "quit,sever close sockfd:%d", sockfd_);
    }
    else // 出错
    {
      lg(Warning, "read error,sockfd:%d,client port:%d,client ip:%s", sockfd_, clientport_, clientip_.c_str());
    }
    close(sockfd_);
  }
  void operator()()
  {
    run();
  }
  ~Task()
  {
  }

private:
  int sockfd_;
  std::string clientip_;
  uint16_t clientport_;
};

Tcpserver.hpp

#pragma once

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstring>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <signal.h>
#include <signal.h>
#include "Task.hpp"
#include "log.hpp"
#include "ThreadPool.hpp"
const int defaultfd = -1;
const std::string defaultip = "0.0.0.0";
const int backlog = 10; // 一般不要设置太大



// 枚举错误代码，方便查阅
enum
{
  UseageError = 1,
  SocketError,
  BindError,
  ListenError,
};


// //线程传参
// class ThreadData
// {
// public:
//   ThreadData(int fd,const std::string &ip,uint16_t &p,TcpServer*tp): sockfd(fd),clientip(ip),clientport(p),tsvr(tp)
//   {}
// public:
//   int sockfd;
//   std::string clientip;
//   uint16_t clientport;
//   TcpServer* tsvr;
// };


class TcpServer
{
public:
  TcpServer(const uint16_t &port, const std::string &ip = defaultip) : listensockfd_(defaultfd), port_(port), ip_(ip)
  {
  }
  void InitServer()
  {
    listensockfd_ = socket(AF_INET, SOCK_STREAM, 0);
    if (listensockfd_ < 0) // 创建失败
    {
      lg(Fatal, "create listensockfd,errno:%d,errstring:%s", errno, strerror(errno));
      exit(SocketError);
    }

    // 如果成功，打印成功信息
    lg(Info, "create listensockfd sucess:%d", listensockfd_);

    // 创建并填充结构体
    struct sockaddr_in local;                  // 创建结构体
    memset(&local, 0, sizeof(local));          // 将内部清零
    local.sin_family = AF_INET;                // 填充类型
    local.sin_port = htons(port_);             // 填充端口号
    inet_aton(ip_.c_str(), &(local.sin_addr)); // 填充ip地址

    // 绑定
    if (bind(listensockfd_, (struct sockaddr *)&local, sizeof(local))) // 如果绑定失败
    {
      lg(Fatal, "bind listensockfd,errno:%d,errstring:%s", errno, strerror(errno));
      exit(BindError);
    }

    // 监听
    if (listen(listensockfd_, backlog) < 0) // 如果失败
    {
      lg(Fatal, "listen error,errno:%d,errstring:%s", errno, strerror(errno));
      exit(ListenError);
    }
    lg(Info, "listen sucess,listensockfd:%d", listensockfd_);
  }

  // //线程函数
  // static void* Routine(void*args)
  // {
  //   pthread_detach(pthread_self());//分离线程

  //   ThreadData*td=static_cast<ThreadData*>(args);
  //   td->tsvr->Serverce(td->sockfd,td->clientip,td->clientport);//提供服务
  //   delete td;
  //   return nullptr;
  // }

  void Start()
  {
    signal(SIGPIPE,SIG_IGN);
    ThreadPool<Task>::GetInstance()->Start();//启动线程池
    lg(Info, "tcpServer if running.....");
    while (true)
    {
      // 1.获取新连接
      struct sockaddr_in client;
      socklen_t len = sizeof(client);
      int sockfd = accept(listensockfd_, (struct sockaddr *)&client, &len);
      if (sockfd < 0)
      {
        lg(Warning, "accept error,errorno:%d,errstring:%s", errno, strerror(errno));
        continue;
      }

      // 接收客户端的port和ip
      uint16_t clientport = ntohs(client.sin_port);
      char clientip[32];
      inet_ntop(AF_INET, &(client.sin_addr), clientip, sizeof(clientip));

      // 2.根据新连接进行通信
      lg(Info, "get a new link,sockfd:%d,client port:%d,client ip:%s", sockfd, clientport, clientip);

      // 3.服务
      //3.1 单进程版
      //Serverce(sockfd, clientip, clientport);
      //close(sockfd);

      //3.2 多进程版
      // pid_t id=fork();
      // if(id==0)//子进程
      // {
      //   close(listensockfd_);
      //   if(fork()>0) exit(0);//创建孙子进程，释放子进程
      //   Serverce(sockfd, clientip, clientport);//孙子进程提供服务
      //   close(sockfd);//服务完成，关闭服务
      //   exit(0);//退出进程
      // }
      // //父进程
      // close(sockfd);
      // pid_t rid=waitpid(id,nullptr,0);
      // (void)rid;

      //3.3多线程版本
      // ThreadData*td=new ThreadData(sockfd,clientip,clientport,this);
      // pthread_t tid;
      // pthread_create(&tid,nullptr,Routine,td);

      //3.4线程池版本
      Task t(sockfd, clientip, clientport);
      ThreadPool<Task>::GetInstance()->Push(t);

    }
  }

  // void Serverce(const int sockfd, const std::string &clientip, const uint16_t clientport)
  // {
  //   // 测试代码，收一个消息再发回去
  //   while (true)
  //   {
  //     char buffer[4096];
  //     ssize_t n = read(sockfd, buffer, sizeof(buffer));
  //     if (n > 0)
  //     {
  //       buffer[n] = 0;
  //       std::cout << "buffer say#" << buffer << std::endl;
  //       std::string echo_string = "tcpserver echo#";
  //       echo_string += buffer;

  //       write(sockfd, echo_string.c_str(), echo_string.size());
  //     }
  //     else if(n==0)//结束服务
  //     {
  //       lg(Info,"quit,sever close sockfd:%d",sockfd);
  //       break;
  //     }
  //     else//出错
  //     {
  //       lg(Warning, "read error,sockfd:%d,client port:%d,client ip:%s", sockfd, clientport, clientip.c_str());
  //       break;
  //     }
  //   }
  // }

  ~TcpServer()
  {
  }

private:
  int listensockfd_; // 监听套接字
  std::string ip_;   // ip地址
  uint16_t port_;    // 端口号
};

Tcpclient.cc

#include <iostream>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

void Usage(char *proc)
{
  std::cout << "\n\rUsage:" << proc << "severip serverport" << std::endl;
}

int main(int argc, char *argv[])
{
  if (argc != 3)
  {
    Usage(argv[0]);
    exit(1);
  }

  // 获取服务器的ip和port
  std::string serverip = argv[1];
  uint16_t serverport = std::stoi(argv[2]);

  // 填充结构体
  struct sockaddr_in server;
  memset(&server, 0, sizeof(server));

  server.sin_family = AF_INET;
  server.sin_port = htons(serverport);
  inet_pton(AF_INET, serverip.c_str(), &(server.sin_addr));

  while (true)
  {

    // 创建套接字
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0)
    {
      std::cerr << "socket error" << std::endl;
      return 1;
    }

    // 进行连接
    int n = connect(sockfd, (struct sockaddr *)&server, sizeof(server));
    if (n < 0) // 如果连接失败
    {
      std::cerr << "connect error...." << std::endl;
      return 2;
    }

    // 测试代码
    std::string message;

    std::cout << "Please Enter#";
    getline(std::cin, message);

    n = write(sockfd, message.c_str(), message.size());
    if (n < 0)
    {
      std::cerr << "write error....." << std::endl;
      continue;
    }

    char buffer[4096];
    n = read(sockfd, buffer, sizeof(buffer));
    if (n > 0)
    {
      buffer[n] = 0;
      std::cout << buffer << std::endl;
    }
    close(sockfd);
  }
  return 0;
}

Main.cc

#include"Tcpserver.hpp"
#include<memory>

void Usage(std::string proc)
{
  std::cout<<"\n\rUsage:"<<proc<<"port[1024+]\n"<<std::endl;
}

int main(int argc,char*argv[])
{
  if(argc!=2)//如果传参数不对，提醒一下
  {
    Usage(argv[0]);
    exit(UseageError);
  }
  uint16_t port=std::stoi(argv[1]);
  std::unique_ptr<TcpServer> tcp_svr(new TcpServer(port));
  tcp_svr->InitServer();
  tcp_svr->Start();

  return 0;
}

六.使用示例

在这里插入图片描述

咸蛋挞
关注
专栏目录
tcp套接字
Unique-You的博客
03-26 675
tcp套接字中不会阻塞的是：正确答案: D   你的答案: 空 (错误)readwriteacceptbind首先，服务器端启动进程，调用Socket创建一个基于TCP协议的流套接字描述符。其次，服务进程调用bind命名套接字，将套接字描述符绑定到本地地址和本地端口上。        再次，服务器端调用listen，开始侦听客户端的Socket连接请求。        接下来阻塞，直到收到了客户端...
C++网络编程（一）：TCP套接字编程
weixin_44164489的博客
09-16 4263
目录TCP服务器端的默认函数调用顺序TCP客户端的默认函数调用情况TCP网络编程主要流程 TCP服务器端的默认函数调用顺序 int Socket( int domain, int type,int protocol) 功能：创建一个新的套接字，返回套接字描述符 参数说明： domain：域类型，指明使用的协议栈，如TCP/IP使用的是 PF_INET ，其他还有AF_INET6、AF_UNIX type:指明需要的服务类型, 如 SOCK_DGRAM:数据报服务，UDP协议 SOCK_S
TCP套接字
Ftworld21的专栏
09-18 224
TCP套接字类主要对底层的读写，压缩，加密等进行了封装，提供了一个比较通过的接口，通过这个类就可以实现数据的接收与发送。 //封装了一个缓冲区，用于TCP套接口接收到发送的缓冲区 template <typename T> class Buffer { public: ... private: ... T buffer; }; typedef Buffer<std::vector<unsigned char> > Buffer_t; clas...
Tcp套接字
最新发布
2302_78814792的博客
09-13 744
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。TCP套接字（Socket）是实现TCP协议进行网络通信的关键机制。TCP套接字广泛应用于各种需要可靠传输数据的网络应用程序中，如Web服务器（HTTP）、文件传输（FTP）、远程登录（SSH）等。：当客户端断开连接后，与客户端相连接的Socket对象也应当被关闭，否则其将会占用文件描述符表，导致资源浪费。在编程中，TCP套接字的实现依赖于操作系统提供的套接字API。
Python网络编程之TCP套接字简单用法示例
01-20
本文实例讲述了Python网络编程之TCP套接字简单用法。分享给大家供大家参考，具体如下： 上学期学的计算机网络，因为之前还未学习python，而java则一知半解，C写起来又麻烦，所以一直都没有真正实现过TCP套接字编程。...
网络编程套接字 - TCP套接字
09-08
在计算机网络编程中，套接字（Socket）是应用程序与网络通信的基础接口，它允许程序通过网络发送和接收数据。TCP（Transmission Control Protocol）套接字是基于传输层的TCP协议实现的，提供了面向连接、可靠的、...
套接字tcp_linux下网络通信tcp套节字例程_
10-01
本教程将深入探讨如何在Linux环境下使用C语言编写TCP套接字（socket）程序，实现客户端与服务器之间的网络通信。 首先，我们从服务器端（server.c）开始。在服务器端，你需要做以下步骤： 1. **创建套接字**：调用...
TCP的套接字
changsoon
05-22 8275
TCP的套接字
TCP网络套接字
m0_74910646的博客
08-09 1428
这里还有一个小细节，子进程会继承父进程的文件描述符表，我们知道每一个客户端会对应一个sockfd，而文件描述符表本质就是一个数组，也是有数量大小的，当客户端的数量比较多了的话文件描述符表可能就会被占满，其次父进程不关心业务执行什么，也就是父进程不关心sockfd，所以每当创建一个子进程建议父进程将sockfd关掉，也建议子进程将listenfd也关掉方式误操作，这样不论有多少个客户端，其对应的文件描述符永远是4。这样，当套接字进行通信时，就可以使用这个指定的地址作为通信的源地址。
TCP实现之：套接字
qq_17045267的博客
06-16 2014
TCP实现之：套接字 套接字的数据结构按照域的不同可以分为三种：用户态套接字、socket和sock，其中socket结构体是内核中的与用户态相似的套接字数据结构，可以理解为它是为用户态提供的一种接口，而sock结构体比较复杂，它是内核用来进行数据传输的数据结构，可以理解为它是套接字的实现。这三种套接字可谓息息相关。 struct socket 这里的socket又被称为BSD socket（伯克利套接字），它对应着网络模型中的表示层，其定义比较简单，只有7个字段，如下： struct socket {
基本的TCP套接字
magic_jiayu的博客
11-02 573
基本的TCP套接字 IPv4 TCP客户 典型的TCP客户的通信涉及四个步骤： 使用socket()创建TCP套接字。 使用connect()建立到达服务器的连接。 使用send()和recv()通信。 使用close()关闭连接。 一. 应用程序建立与参数解析 (一)包括文件：声明了API的标准函数与常量。参考文档，了解用于系统上的套接字函数和数据结构的合适的包括文件。利用了自己的包括文件P...
TCP基本套接字
qq_26646107的博客
08-15 912
TCP客户端和服务器编程离不开基本的套接字函数，学习TCP基本套接字很重要，下面学习一下基本的套接字接口，并实现一个简单的客户端和服务器程序。 socket函数 为了执行网络IO，一个进程要做的第一件事情就是要创建套接字。 在这里插入代码片 #include <sys/socket.h> int socket(int family, int type, int protocol) 返回：成功返回非负描述符，失败返回-1 family: AF_INET->IPV4协议 AF_INET6-&g
网络编程——Tcp套接字
学代码的咸鱼的博客
07-03 529
TCP套接字的简单实现！
【网络】套接字 -- TCP
qq_59456417的博客
03-02 2265
TCP套接字服务器端和TCP客户端的简单实现。
TCP套接字编程
写博客记录分享学习笔记
04-13 931
Linux操作系统下TCP套接字编程
C#网络编程入门：TCP套接字详解
"这篇内容主要探讨C#中的Socket网络编程，包括TCP协议的基本概念和套接字在C#中的应用。" 在C#网络编程中，Socket是关键的组件，它使得应用程序能够利用TCP/IP协议栈进行通信。TCP（Transmission Control Protocol...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

咸蛋挞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值