【网络编程】demo版TCP网络服务器实现

最新推荐文章于 2024-03-30 08:45:00 发布
最新推荐文章于 2024-03-30 08:45:00 发布
阅读量1.8k 收藏 39
点赞数 36
分类专栏： 网络 文章标签： 网络 tcp/ip 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66314292/article/details/130781612
版权

文章目录

一、引入

UDP和TCP的区别：

对于TCP协议有几个特点：

1️⃣ 传输层协议
2️⃣ 有连接（正式通信前要先建立连接）
3️⃣ 可靠传输（在内部帮我们做可靠传输工作）
4️⃣ 面向字节流

对于UDP协议有几个特点：

1️⃣ 传输层协议
2️⃣ 无连接
3️⃣ 不可靠传输
4️⃣ 面向数据报

可以看到TCP对比UDP会建立链接。

其他的接口跟UDP其实没什么区别：【网络编程】demo版UDP网络服务器实现

二、服务端实现

2.1 创建套接字socket

在通信之前要先把网卡文件打开。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int socket(int domain, int type, int protocol);

RETURN VALUE
On success, a file descriptor for the new socket is returned.  
On error, -1 is returned, and errno is set appropriately.

这个函数的作用是打开一个文件，把文件和网卡关联起来。

参数介绍：

domain：一个域，标识了这个套接字的通信类型（网络或者本地）。
在这里插入图片描述
只用关注上面两个类，第一个AF_UNIX表示本地通信，而AF_INET表示网络通信。
type：套接字提供服务的类型。
在这里插入图片描述
这一章我们讲的式TCP，所以使用SOCK_STREAM。
protocol：想使用的协议，默认为0即可，因为前面的两个参数决定了，就已经决定了是TCP还是UDP协议了。

返回值：

成功则返回打开的文件描述符（指向网卡文件），失败返回-1。

而从这里我们就联想到系统中的文件操作，未来各种操作都要通过这个文件描述符，所以在服务端类中还需要一个成员变量表示文件描述符。

#pragma once

#include <iostream>
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include "log.hpp"

class TCPServer
{
static const uint16_t gport = 8080;
public:
    TCPServer(cosnt uint16_t& port = gport)
        : _sock(-1)
        , _port(port)
    {}

    void InitServer()
    {
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if(_sockfd == -1)
        {
            std::cerr << "create socket error" << std::endl;
            exit(1);
        }
        std::cout << "create socket success" << std::endl;
    }

    void start()
    {}
private:
    int _sock;
    uint16_t _port;
};

2.2 绑定bind

#include <sys/socket.h>

int bind(int socket, const struct sockaddr *address,
       socklen_t address_len);

RETURN VALUE
Upon successful completion, bind() shall return 0; 
otherwise, -1 shall be returned and errno set to indicate the error.

参数介绍：

socket：创建套接字的返回值。
address：通用结构体（【网络编程】socket套接字有详细介绍）。
address_len：传入结构体的长度。

所以我们要先定义一个sockaddr_in结构体填充数据，在传递进去。
在这里插入图片描述
然后就是跟UDP一样，先初始化结构体，再处理IP和端口。
要注意IP要绑定任意IP也就是INADDR_ANY。
至于为什么再上一章【网络编程】demo版UDP网络服务器实现有过详细讲解。

void InitServer()
{
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if(_sockfd == -1)
    {
        std::cerr << "create socket error" << std::endl;
        exit(1);
    }
    std::cout << "create socket success" << std::endl;
    struct sockaddr_in si;
    // 初始化结构体
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(_port);// 主机转网络序列
    si.sin_addr.s_addr = INADDR_ANY;
    if(bind(_sock, (struct sockaddr*)&si, sizeof si) < 0)
    {
        std::cout << "bind socket error" << std::endl;
        exit(1);
    }
    std::cout << "bind socket success" << std::endl;
}

2.3 设置监听状态listen

TCP跟UDP的不同在这里就体现了出来。
要把socket套接字的状态设置为listen状态。只有这样才能一直获取新链接，接收新的链接请求。

举个例子：
我们买东西如果出现了问题会去找客服，如果客服不在那么就回复不了，所以规定了客服在工作的时候必须要时刻接收回复消息，这个客服所处的状态就叫做监听状态。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int listen(int sockfd, int backlog);

RETURN VALUE
On success, zero is returned.  
On error, -1 is returned, and errno is set appropriately.

关于第二个参数backlog后边讲TCP协议的时候介绍，目前先直接用。

static const int gbacklog = 10;

void InitServer()
{
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if(_sock == -1)
    {
        std::cerr << "create socket error" << std::endl;
        exit(1);
    }
    std::cout << "create socket success" << std::endl;
    struct sockaddr_in si;
    // 初始化结构体
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(_port);// 主机转网络序列
    si.sin_addr.s_addr = INADDR_ANY;
    if(bind(_sock, (struct sockaddr*)&si, sizeof si) < 0)
    {
        std::cout << "bind socket error" << std::endl;
        exit(1);
    }
    std::cout << "bind socket success" << std::endl;
    // 设置监听状态
    if(listen(_sock, gbacklog) < 0)
    {
        std::cout << "listen socket error" << std::endl;
        exit(1);
    }
    std::cout << "listen socket success" << std::endl;
}

2.4 获取新链接accept

上面初始化完毕，现在开始就是要运行服务端，而TCP不能直接发数据，因为它是面向链接的，必须要先建立链接。

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

RETURN VALUE
On success, these system calls return a nonnegative integer that is a descriptor for the accepted socket.  
On error, -1 is returned, and errno is set appropriately.

参数介绍：

sockfd文件描述符，找到套接字
addr输入输出型参数，是一个结构体，用来获取客户端的信息。
addrlen输入输出型参数，客户端传过来的结构体大小。

返回值：

成功返回一个文件描述符
失败返回-1

而我们知道sockfd本来就是一个文件描述符，那么这个返回的文件描述符是什么呢？
举个例子：

我们去吃饭的时候会发现每个店铺门口都会有人来招揽顾客，这个人把我们领进去门店后，然后他就会继续站在门口继续招揽顾客，而我们会有里面的服务员来招待我们，给我们提供服务。

这里的揽客的人就是sockfd，而服务员就是返回值的文件描述符。
意思就是sockfd的作用就是把链接从底层获取上来，返回值的作用就是跟客户端通信。

从这里就知道了成员变量中的_sock并不是通信用的套接字，而是获取链接的套接字。为了方便观察，我们可以把所有的_sock换成_listensock。

void start()
{
    while(1)
    {
        // 获取新链接
        struct sockaddr_in si;
        socklen_t len = sizeof si;
        int sock = accept(_listensock, (struct sockaddr*)&si, &len);
        if(sock < 0)
        {
            // 获取链接失败无影响，继续获取即可
            std::cout << "accept error, continue" << std::endl;
            continue;
        }
        std::cout << "accept a new link success" << std::endl;
        std::cout << "sock: " << sock << std::endl;
    }
}

2.5 获取信息与返回信息（文件操作）

上面获取到了通信用的套接字sock，而因为TCP通信是面向字节流的，所以后续通信全部是用文件操作（IO），因为文件也是面向字节流的。

IO的操作我们可以封装一个函数。

void ServerIO(int sock)
{
    char buf[1024];
    // 接收消息       
    while(1)
    {
        ssize_t n = read(sock, buf, sizeof buf - 1);
        if(n > 0)
        {
            buf[n] = '\0';
            std::cout << "read a message: " << buf << std::endl;
            // 把消息发送回去
            std::string outbuf;
            outbuf += "Server[echo]#";
            outbuf += buf;
            write(sock, outbuf.c_str(), outbuf.size());
        }
        else if(n == 0)
        {
            // 代表客户端退出
            std::cout << "Client quit" << std::endl;
            break;
        }
    }
}

当IO完后要记得关闭文件描述符sock，不然会导致可用描述符越来越少。
在这里插入图片描述
验证发现可以运行
在这里插入图片描述在这里插入图片描述

三、客户端实现

3.1 创建套接字socket

Socket可以看成在两个程序进行通讯连接中的一个端点，一个程序将一段信息写入Socket中，该Socket将这段信息发送给另外一个Socket中，使这段信息能传送到其他程序中。
所以客户端也需要一个套接字。

void initClient()
{
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if(_sock < 0)
    {
        std::cout << "create socket error" << std::endl;
        exit(1);
    }
    std::cout << "create socket success" << std::endl;
}

3.2 绑定问题

跟上一章一样要绑定，但是不能显示绑定。

3.3 发起链接connect

#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

int connect(int sockfd, const struct sockaddr *addr,
            socklen_t addrlen);
            
RETURN VALUE
If the connection or binding succeeds, zero is returned.  
On error, -1 is returned, and errno is set appropriately.

参数说明：

这里的addr和addrlen填入的是服务端信息。

在UDP通信中，客户端在sendto的时候会自动绑定IP和port，TCP这里就是在connect的时候绑定。

void start()
{
    struct sockaddr_in si;
    bzero(&si, sizeof si);
    si.sin_family = AF_INET;
    si.sin_port = htons(_serverport);
    si.sin_addr.s_addr = inet_addr(_serverip.c_str());
    if(connect(_sock, (struct sockaddr*)&si, sizeof si) < 0)
    {
        std::cout << "connect socket error" << std::endl;
    }
    else
    {
        std::string msg;
        while(1)
        {
            std::cout << "Please Enter#";
            std::getline(std::cin, msg);
            write(_sock, msg.c_str(), msg.size());
            // 从服务端读取数据
            char buf[1024];
            int n = read(_sock, buf, sizeof buf - 1);
            if(n > 0)
            {
                buf[n] = '\0';
                std::cout << buf << std::endl;
            }
            else
            {
                break;
            }
        }
    }
}

最后在析构的时候要关掉文件描述符。

~TCPClient()
{
    if(_sock >= 0)
    {
        close(_sock);
    }  
}

服务端：
在这里插入图片描述
客户端：
在这里插入图片描述
但此时如果我们在用一个客户端链接，会发现无法通信，除非第一个客户端退出。
在这里插入图片描述
这是因为获取新链接后会进入ServerIo中死循环。只要这个客户端不退出，就会一直给这个客户端提供服务。

那怎么保证多个客户端并行呢？

3.4 客户端并行

3.4.1 多进程版

因为fork后子进程会复制父进程的文件描述符。
这里注意子进程并不需要_listensock文件描述符，所以最好关闭。

pid_t id = fork();
if(id == 0)// child
{
    close(_listensock);
    ServerIO(sock);
    close(sock);
    exit(1);
}

接下来父进程怎么办呢？是等待吗？
如果父进程等待的话又会导致上面的情况，子进程不退出父进程就一直等待。

子进程退出时，会给父进程发送一个SIGCHLD，17号信号。所以有一种解决办法就是用signal函数，在回调函数中把waitpid的参数设置为-1（等待任意进程），就可以回收。

现在我们不用这种办法，我们可以这么写：

pid_t id = fork();
if(id == 0)// child
{
    close(_listensock);
    if(fork() > 0) exit(1);
    ServerIO(sock);
    close(sock);
    exit(1);
}
// father
pid_t ret = waitpid(id, nullptr, 0);
if(ret > 0)
{
    std::cout << "wait success" << ret << std::endl;
}

这里的意思就是创建孙子进程，父进程直接退出，让孙子进程执行ServerIO，此时孙子进程就会被操作系统收养，不用我们管，而父进程退出，外边的父进程也等待成功了。

结果演示：
客户端：
在这里插入图片描述
在这里插入图片描述
服务端：
在这里插入图片描述
其实下面的等待可以不用等待，因为SIGCHLD信号默认的处理方式是忽略。
在这里插入图片描述
在这里插入图片描述
这里看到客户端退出了但是文件描述符并没有被回收。
这里的原因是我们只关闭了子进程的文件描述符，没有关闭父进程：
在这里插入图片描述

3.4.2 多线程版

struct ThreadData
{
    TCPServer* _self;
    int _sock;
};

void start()
{
    while(1)
    {
        // 获取新链接
        struct sockaddr_in si;
        socklen_t len = sizeof si;
        int sock = accept(_listensock, (struct sockaddr*)&si, &len);
        if(sock < 0)
        {
            // 获取链接失败无影响，继续获取即可
            std::cout << "accept error, continue" << std::endl;
            continue;
        }
        std::cout << "accept a new link success" << std::endl;
        std::cout << "sock: " << sock << std::endl;
        // 多线程
        pthread_t tid;
        ThreadData* td = new ThreadData({this, sock});
        pthread_create(&tid, nullptr, thread_start, td);
    }
}

static void* thread_start(void* args)
{
    // 线程分离
    pthread_detach(pthread_self());
    ThreadData* tp = static_cast<ThreadData*>(args);
    tp->_self->ServerIO(tp->_sock);
    close(tp->_sock);
    delete tp;
}

3.4.3 线程池版

前面我们写过线程池【linux】基于单例模式实现线程池，这里直接拿来用即可。
这里就要修改一下代码，因为ServerIO可以不属于类，所以可以把ServerIO放在任务Task.hpp中。

// Task.hpp
#pragma once

#include <iostream>
#include <string>
#include <functional>
#include <cstdio>

void ServerIO(int sock)
{
    char buf[1024];
    // 接收消息       
    while(1)
    {
        ssize_t n = read(sock, buf, sizeof buf - 1);
        if(n > 0)
        {
            buf[n] = '\0';
            std::cout << "read a message: " << buf << std::endl;
            // 把消息发送回去
            std::string outbuf;
            outbuf += "Server[echo]#";
            outbuf += buf;
            write(sock, outbuf.c_str(), outbuf.size());
        }
        else if(n == 0)
        {
            // 代表客户端退出
            std::cout << "Client quit" << std::endl;
            break;
        }
    }
}

class Task
{
    typedef std::function<void(int)> func_t;
public:
    Task()
    {}

    Task(int sock, func_t func)
        : _sock(sock)
        , _func(func)
    {}

    void operator()()
    {
        _func(_sock);
    }

    std::string tostringTask()
    {
        char buf[64];
        snprintf(buf, sizeof buf, "%d %c %d = ?", _x, _op, _y);
        return buf;
    }
private:
    int _sock;
    func_t _func;
};

// ThreadPool.hpp
#pragma once

#include <vector>
#include <queue>
#include <mutex>
#include "mythread.hpp"
#include "mymutex.hpp"
#include "Task.hpp"

using std::cout;
using std::endl;

const int N = 5;

template <class T>
class ThreadPool;

template <class T>
struct ThreadData
{
    ThreadPool<T>* _tp;
    std::string _name;
    ThreadData(ThreadPool<T>* tp, const std::string& name)
        : _tp(tp)
        , _name(name)
    {}
};

template <class T>
class ThreadPool
{
private:
    static void* handlerTask(void* args)
    {
        ThreadData<T>* tdp = static_cast<ThreadData<T>*>(args);
        while(true)
        {
            tdp->_tp->lockqueue();
            while(tdp->_tp->isqueueempty())
            {
                tdp->_tp->threadwait();
            }
            T t = tdp->_tp->pop();
            tdp->_tp->unlockqueue();
            t();
        }
        delete tdp;
    }

    void lockqueue() volatile
    {
        pthread_mutex_lock(&_mutex);
    }

    void unlockqueue() volatile
    {
        pthread_mutex_unlock(&_mutex);
    }

    bool isqueueempty() volatile
    {
        return _tasks.empty();
    }

    void threadwait() volatile
    { 
        pthread_cond_wait(&_cond, &_mutex);
    }

    T pop() volatile
    {
        T res = _tasks.front();
        _tasks.pop();
        return res;
    }

    ThreadPool(int num = 5)
        : _num(num)
    {
        pthread_mutex_init(&_mutex, nullptr);
        pthread_cond_init(&_cond, nullptr);
        // 创建线程
        for(int i = 0; i < _num; i++)
        {
            _threads.push_back(new Thread());
        }
    }

    ThreadPool(const ThreadPool<T>& ) = delete;
    ThreadPool<T> operator=(const ThreadPool<T>&) = delete;

public:

    void start() volatile
    {
        for(auto& t : _threads)
        {
            ThreadData<T>* td = new ThreadData<T>(this, t->GetName());
            t->start(handlerTask, td);
        }
    }

    void push(const T& in) volatile
    {
        LockAuto lock(&_mutex);
        _tasks.push(in);
        // 唤醒池中的一个线程
        pthread_cond_signal(&_cond);
    }

    ~ThreadPool()
    {
        pthread_mutex_destroy(&_mutex);
        pthread_cond_destroy(&_cond);
        for(auto & e : _threads)
        {
            delete e;
        }
    }

    volatile static ThreadPool<T>* GetSingle()
    {
        if(_tp == nullptr)
        {
            _singlelock.lock();
            if(_tp == nullptr)
            {
                _tp = new ThreadPool<T>();
            }
            _singlelock.unlock();
        }
        return _tp;
    }

private:
    int _num;// 线程数量
    std::vector<Thread*> _threads;
    std::queue<T> _tasks;// 任务队列
    pthread_mutex_t _mutex;// 保护任务队列
    pthread_cond_t _cond;
    volatile static ThreadPool<T>* _tp;
    static std::mutex _singlelock;
};

template <class T>
volatile ThreadPool<T>* ThreadPool<T>::_tp = nullptr;

template <class T>
std::mutex ThreadPool<T>::_singlelock;

// TCPServer.hpp
#pragma once

#include <iostream>
#include <string>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <strings.h>
#include <cstdlib>
#include <sys/wait.h>
#include <pthread.h>
#include "ThreadPool.hpp"
#include "log.hpp"

class TCPServer;
struct ThreadData
{
    TCPServer* _self;
    int _sock;
};

class TCPServer
{
static const uint16_t gport = 8080;
static const int gbacklog = 10;
public:
    TCPServer(const uint16_t& port = gport)
        : _listensock(-1)
        , _port(port)
    {}

    void InitServer()
    {
        _listensock = socket(AF_INET, SOCK_STREAM, 0);
        if(_listensock == -1)
        {
            std::cerr << "create socket error" << std::endl;
            exit(1);
        }
        std::cout << "create socket success" << std::endl;
        struct sockaddr_in si;
        // 初始化结构体
        bzero(&si, sizeof si);
        si.sin_family = AF_INET;
        si.sin_port = htons(_port);// 主机转网络序列
        si.sin_addr.s_addr = INADDR_ANY;
        if(bind(_listensock, (struct sockaddr*)&si, sizeof si) < 0)
        {
            std::cout << "bind socket error" << std::endl;
            exit(1);
        }
        std::cout << "bind socket success" << std::endl;
        // 设置监听状态
        if(listen(_listensock, gbacklog) < 0)
        {
            std::cout << "listen socket error" << std::endl;
            exit(1);
        }
        std::cout << "listen socket success" << std::endl;
    }

    void start()
    {
        // 线程池初始化
        ThreadPool<Task>::GetSingle()->start();
        while(1)
        {
            // 获取新链接
            struct sockaddr_in si;
            socklen_t len = sizeof si;
            int sock = accept(_listensock, (struct sockaddr*)&si, &len);
            if(sock < 0)
            {
                // 获取链接失败无影响，继续获取即可
                std::cout << "accept error, continue" << std::endl;
                continue;
            }
            std::cout << "accept a new link success" << std::endl;
            std::cout << "sock: " << sock << std::endl;
            // 线程池
            ThreadPool<Task>::GetSingle()->push(Task(sock, ServerIO));


            // 多线程
            // pthread_t tid;
            // ThreadData* td = new ThreadData({this, sock});
            // pthread_create(&tid, nullptr, thread_start, td);
            
            // 多进程
            // pid_t id = fork();
            // if(id == 0)// child
            // {
            //     close(_listensock);
            //     if(fork() > 0) exit(1);
            //     ServerIO(sock);
            //     close(sock);
            //     exit(1);
            // }
            // close(sock);
            // father
            // pid_t ret = waitpid(id, nullptr, 0);
            // if(ret > 0)
            // {
            //     std::cout << "wait success " << ret << std::endl;
            // }


            // ServerIO(sock);
            // // 关闭使用完的文件描述符
            // close(sock);
        }
    }

    static void* thread_start(void* args)
    {
        // 线程分离
        pthread_detach(pthread_self());
        ThreadData* tp = static_cast<ThreadData*>(args);
        tp->_self->ServerIO(tp->_sock);
        close(tp->_sock);
        delete tp;
    }

private:
    int _listensock;
    uint16_t _port;
};

四、总结

对比UDP服务器，TCP服务器多了获取新链接和监听的操作，而因为TCP是面向字节流的，所以接收和发送数据都是IO操作，也就是文件操作。

命由己造～
关注
  • 36
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 28
    评论
专栏目录
STM32单片机作TCP服务器，实现PC多客户端连接Demo
10-12
STM32作TCP服务器，实现PC多客户端连接的模板。本模板是基于正点原子的STM32F750开发板上实现的，多连接处理部分的代码在tcp_server_demo.c中，其他型号型号可参考修改。
tcp客户端demo
Bei_Chen的博客
02-23 369
【代码】tcp客户端demo。
TCP/IP通信demo
最新发布
qq_45445740的博客
03-30 561
提供一个TCP 服务端和TCP 客户端的最小demo，便于和海康VisionMaster软件进行通信测试。
C# TCP/IP 连接实现数据收发 Demo （Visual Studio）
热门推荐
lxk7280的专栏
11-08 3万+
添加using指令集: using System.Net.Sockets; using System.Threading; using System.Net; 添加定义（IP地址 IP接口 berkeley套接字接口）： private IPAddress serverIP = IPAddress.Parse("127.0.00.1"); private IPEndPoint serverF
网络编程学习笔记（三）TCP协议及客户端与服务端交互Demo
Megustas_JJC的博客
05-28 2775
TCP的一些基本概念TCP（Transmission Control Protocol 传输控制协议）是一种面向连接的、可靠的、基于字节流（当应用层向TCP层发送用于网间传输的、用8位字节表示的数据流）的传输层通信协议。TCP为了保证不发生丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收。然后接收端实体对已成功收到的包发回一个相应的确认（ACK）；如果发送端实体在合理的往返时
Qt tcp通信之小demo
kchmmd的博客
11-03 969
TCP模型 大致流程图： 首先使用TCP通信需要在.pro文件中加入：QT += network 一、服务端实现步骤： 1、创建QTcpSever套接字对象 m_Server = new QTcpServer(); 2、侦听一个端口，使得客户端可以使用这个端口来访问服务器 m_Server->listen(QHostAddress::Any,port); 3、当服务器被客户端访问时，会发出newConnection()信号，并用一个QTcpSocket对象接受客户端访问，然后关联客户端
TCP简单demo
佐杰的博客
02-26 972
客户端: package com.yfy.net; import java.io.BufferedWriter; import java.io.IOException; import java.io.OutputStream; import java.io.OutputStreamWriter; import java.net.Socket; public class TCPClient {...
Linux下的Tcp通信项目范例【demo】
caiji667788的博客
10-21 1442
设计一个可以符合多用户进行线上查阅乐器的商城，要求可以多个用户查看，管理员可随时修改内容，普通用户仅可查看，需要相应密码权限操作。
TCP协议发送/接收数据实现[TCP/IP协议入门]
PHPer技术栈
05-19 4152
背景 Demo 基于 Java 实现简单的 TCP 传输 / 接收协议 词义百科 TCP 协议 (传输控制协议) TCP 协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，再传输数据。它提供了两台计算机之间的可靠无差错的数据传输。在 TCP 连接中必须要明确客户端与服务器，由客户端向服务器发送连接请求，每次连接的创建都需要经过 “三次握手” 三次握手：TCP 协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠 第一次握手：客户端向服务器发出连接请求，等待服务
socket编程1 tcp基本api接口与基础编程demo
随风的博客
09-15 456
TCP socket编程 学习TCP socket编程API接口，基于此入门，并编写一个TCP网络服务器与通讯客户机。 keyword: TCP socket API接口 #include <sys/socket.h> int socket(int family, int type, int protocal); // 创建一个套接字，并配置 int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen)
TCP协议Demo
AaronWang0920的博客
09-09 591
package cn.itcast.tcp;import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.InetAddress; import java.net.Socket; import java.net.UnknownHostException;/* U
TCPServerDemo
10-29
在过去的项目中，在涉及网络通信的项目中，我一直使用的是UDP通信，因为UDP通信开发起来比较方便，一直没有使用过TCP/IP进行通信，在这个Demo中我写了一个TCP的Server供大家参考。
C#网络编程Demo(客户端+服务器端+同步+异步).zip
05-21
C#网络编程Demo(客户端+服务器端+同步+异步)，经过VS2013编译，包含exe执行文件，如果有其他的问题可以查看博主的博客
Qt 多线程的网络时间服务器Tcp demo
12-01
实现一个多线程的网络时间服务器，介绍如何综合运用多线程技术编程。每当有客户请求到达是，服务器将启动一个新线程为它返回当前时间，服务完毕后这个线程将自动退出，同时，用户界面会显示当前已接收请求的次数。
Python 网络编程之TCP客户端/服务端功能示例【基于socket套接字】
01-01
本文实例讲述了Python 网络编程之TCP客户端/服务端功能。分享给大家供大家参考，具体如下： demo.py（TCP客户端）： import socket def main(): # 1. 创建tcp的套接字 tcp_socket = socket.socket(socket.AF_INET...
Socket编程TCP粘包Demo.zip
05-22
利用网络通信中，经常会出现粘包的问题，围绕着这个问题说原因和解决的蛮多帖子的，但是给出粘包代码的就好少，为了便于大家更好的理解粘包的问题，这里对客户端和服务器端出现的粘包问题进行模拟
基于Java原生TCPSocket实现的小型服务器源码+项目说明.zip
07-05
基于Java 原生TCPSocket实现的小型服务器Demo，能够访问开放目录下的文件夹及文件内容，支持断点续传。 文件大小约1M大小哦。 特性 * 参照Http协议进行实现， * 支持Http Basic授权认证（Demo级实现，账户名admin/...
Boost.asio学习之Tcp异步通信Demo
Lasuerte的博客
05-31 2177
一、服务器1.服务器自己创建io_service，endpoint，设定ip与port；2.创建两个类，一个接受连接，其中acceptor使用io_service与endpoint两个参数初始化，类成员变量io_service需要用引用。开始async_accept后会阻塞在这里，其中socket参数由session类getSocket获取，当有客户端连接后启用回调函数，回调函数判断是否连接成功，...
网络通讯-Socket-TCP-demo(C语言版)
qq_33329316的博客
05-05 1519
流程图 TCP server 服务端 步骤如图所示 1 创建Socket 指定使用什么协议 socket_fd = socket(AF_INET,SOCK_STREAM,0); 2 将Socket与地址和端口绑定 //set socket address local_addr.sin_family = AF_INET; local_addr.sin_port = htons(PORT); local_addr.sin_addr.s_addr = INADDR_ANY; bzero(&(lo
c++ tcp通信demo
06-22
总之，TCP通信demo是一个重要的网络编程示例程序，它可以帮助我们了解TCP协议的工作原理和应用场景，提高我们的网络编程技能和调试能力。 ### 回答2： TCP通信是计算机网络中重要的传输层协议，用于在两个设备之间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 28
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

命由己造～

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

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

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

打赏作者

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

抵扣说明：

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

余额充值