网络学了点socket,写个聊天室,还得改进

已于 2024-06-18 16:33:10 修改
阅读量588 收藏 10
点赞数 9
分类专栏： Linux 操作系统 C++ 文章标签： 网络 c++ linux 开发语言 学习
于 2024-06-09 15:13:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_78660611/article/details/139559965
版权
Linux 同时被 3 个专栏收录
7 篇文章 0 订阅
订阅专栏
C++
6 篇文章 0 订阅
订阅专栏
操作系统
2 篇文章 0 订阅
订阅专栏

目录

第一版:

common

服务端:

客户端

第一版问题总结:

第二版

服务端:

客户端:

改进:

Windows客户端

一些小问题

还可以进行的改进

这篇文章我就先不讲网络基础的东西了,我讲讲在我进行制作我这个拉跨聊天室中遇到的问题,并写了三版代码.

第一版:

common

#pragma once
#include <iostream>
#include <fstream>
#include <cstdio>
#include <string>
#include <ctime>
#include <cstdarg>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "LockGuard.hpp"
enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    USAGE_ERROR
};

void Setserver(struct sockaddr_in &server,std::string &serverip,uint16_t &serverport)
{
    bzero(&server, sizeof(server));
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    server.sin_family=AF_INET;
}


class InetAddr
{
    void GetAddress(uint16_t *Port, std::string *Ip)
    {
        *Port = ntohs(_Addr.sin_port);
        *Ip = inet_ntoa(_Addr.sin_addr);
    }

public:
    InetAddr(struct sockaddr_in &Addr)
        : _Addr(Addr)
    {
        GetAddress(&_Port, &_Ip);
    }
    uint16_t Port()
    {
        return _Port;
    }
    std::string Ip()
    {
        return _Ip;
    }

private:
    struct sockaddr_in _Addr;
    uint16_t _Port;
    std::string _Ip;
};

服务端:

#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "log.hpp"
#include "Common.hpp"
const static int defaultfd = -1;

class Udpserver
{

public:
    Udpserver(uint16_t port)
        : _socketfd(defaultfd), _prot(port), _isrunning(false)
    {
    }
    void InitServer()
    {
        _socketfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_socketfd < 0)
        {
            LOG(WARNING, "%s", "sockfd创建失败");
        }
        LOG(INFO, "%s", "sock创建成功");
        // 填充sockaddr_in结构
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;    // 设置家族协议
        local.sin_port = htons(_prot); // 设置端口号 换成网络序列
        // port要经过网络传输给对面，先到网络，_port：主机序列-> 主机序列，转成网络序列
        // a. 字符串风格的点分十进制的IP地址转成 4 字节IP
        // b. 主机序列，转成网络序列
        // in_addr_t inet_addr(const char *cp) -> 同时完成 a & b
        // local.sin_addr.s_addr = inet_addr(_ip.c_str()); // "192.168.3.1" -> 字符串风格的点分十进制的IP地址 -> 4字节IP
        local.sin_addr.s_addr = INADDR_ANY; // 随机ip地址 一般不能绑定确定ip地址

        // 开始绑定
        int n = bind(_socketfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0)
        {
            LOG(FATAL, "%s", "bind error");
            exit(BIND_ERROR);
        }
        LOG(INFO, "%s", "bind success");
    }

    void Start()
    {
        _isrunning = true;
        while (_isrunning)
        {
            char Inbuffer[1024];
            struct sockaddr_in peer;
            socklen_t socklen = sizeof(peer); // 初始化为sock
            // 让server收取数据 获取客户端socket
            ssize_t n = recvfrom(_socketfd, Inbuffer, sizeof(Inbuffer), 0, (struct sockaddr *)&peer,&socklen); // 接受
            if (n > 0)
            {
                std::cout <<"client say:";
                std::cout << Inbuffer << std::endl; // 成功就打印出来

                // sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
                LOG(DEBUG, "建立 客户IP:%s 连接端口:%s", netAddr.Ip().c_str(), netAddr.Port());
                // sendto(_socketfd,buffer,sizeof(buffer),0,(struct sockaddr*)&sockaddr_in,socklen);//发送
            }
            //
            ///发/
            //
            InetAddr netAddr(peer);
            std::string message;
            std::cout << "server:";
            getline(std::cin, message);
            sendto(_socketfd, message.c_str(), message.size(), 0, (struct sockaddr *)&peer, socklen); // 发送
        }
        _isrunning = false;
    }

private:
    int _socketfd;
    uint16_t _prot;
    bool _isrunning;
};

客户端

#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include "log.hpp"
#include "Common.hpp"

static bool isrunning = false;
static std::string Clientname;
void useagge(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        useagge(argv[0]);
        exit(USAGE_ERROR);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::atoi(argv[2]);
    std::cout << "你是?" << std::endl;
    std::cin >> Clientname;
    // 创建socket;
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        LOG(WARNING, "%s", "Sock错误创建失败");
    }
    LOG(INFO, "%s", "sock创建成功");
    isrunning = true;
    struct sockaddr_in server;
    Setserver(server, serverip, serverport);
    struct sockaddr_in local;
    bzero(&local, sizeof(local));
    std::cout << "可以进行通信了!" << std::endl;
    
    while (isrunning)
    {
      
        std::cout << "server:";
        std::string message;
        getline(std::cin, message);
        sendto(sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&server, socklen); // 发送
        
        struct sockaddr_in peer;
        socklen_t socklen = sizeof(peer); // 初始化为sock
        char buffer[1024];
        ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &socklen);
        if (n > 0)
        {
            buffer[n] = 0;
            std::cout << "server: " << buffer << std::endl;
        }
    }
    return 0;
}

第一版问题总结:

我一开始是想着这个流程,因为一开始服务端只是接受客户端,服务端不会发消息给客户端,所以我想在原基础上,让两端都可以接受和发送,当时就有想可以多线程实行接受和发的任务,但是觉得上线程太麻烦就决定是服务端发->客户端收->客户端发->服务器收,这一条链路实行,但是问题是,我把收发是写在循环里,而 recvfrom是非阻塞等待的,所以双方实际上永远等不到对方信息

所以实际上仍然是要让多线程实行接受和发的任务

第二版

服务端:

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <thread>
#include <mutex>
#include "log.hpp"
#include "Common.hpp"
const static int defaultfd = -1;
 public:
    Udpserver(uint16_t port)
        : _socketfd(defaultfd), _prot(port), _isrunning(false)
    {
        _socklen = sizeof(_peer);
        InitServer();
    }
    void InitServer()
    {
        _socketfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_socketfd < 0)
        {
            LOG(WARNING, "%s", "sockfd创建失败");
        }
        LOG(INFO, "%s", "sock创建成功");
        // 填充sockaddr_in结构
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;    // 设置家族协议
        local.sin_port = htons(_prot); // 设置端口号 换成网络序列
        // port要经过网络传输给对面，先到网络，_port：主机序列-> 主机序列，转成网络序列
        // a. 字符串风格的点分十进制的IP地址转成 4 字节IP
        // b. 主机序列，转成网络序列
        // in_addr_t inet_addr(const char *cp) -> 同时完成 a & b
        // local.sin_addr.s_addr = inet_addr(_ip.c_str()); // "192.168.3.1" -> 字符串风格的点分十进制的IP地址 -> 4字节IP
        local.sin_addr.s_addr = INADDR_ANY; // 随机ip地址 一般不能绑定确定ip地址

        // 开始绑定
        int n = bind(_socketfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0)
        {
            LOG(FATAL, "%s", "bind error");
            exit(BIND_ERROR);
        }
        LOG(INFO, "%s", "bind success");
        _isrunning = true;
    }

    void Start()
    void receive()
    {
        _isrunning = true;
        while (_isrunning)
        {
            
            char Inbuffer[1024] = {0}; // 初始化缓冲区
            struct sockaddr_in tempPeer;
            socklen_t tempSocklen = sizeof(tempPeer);
            ssize_t n = recvfrom(_socketfd, Inbuffer, sizeof(Inbuffer) - 1, 0, (struct sockaddr *)&tempPeer, &tempSocklen);
            if (n > 0)
            {
                std::cout <<"client say:";
                std::cout << Inbuffer << std::endl; // 成功就打印出来

                // sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
                LOG(DEBUG, "建立 客户IP:%s 连接端口:%s", netAddr.Ip().c_str(), netAddr.Port());
                // sendto(_socketfd,buffer,sizeof(buffer),0,(struct sockaddr*)&sockaddr_in,socklen);//发送
                Inbuffer[n] = 0;
                std::lock_guard<std::mutex> lock(_peerMutex);
                _peer = tempPeer;
                _socklen = tempSocklen;
                std::cout << "client says:" << Inbuffer << std::endl;
            }
            //
            ///发/
            //
            InetAddr netAddr(peer);
            else
            {
                perror("recvfrom error");
            }
        }
    }
    void sent()
    {
        while (_isrunning)
        {
            std::string message;
            std::cout << "server: ";
            std::cin >> message;
            std::lock_guard<std::mutex> lock(_peerMutex);
            ssize_t sent = sendto(_socketfd, message.c_str(), message.size(), 0, (struct sockaddr *)&_peer, _socklen);
            if (sent == -1)
            {
                perror("sendto error");
            }
        }
        _isrunning = false;
    }
    void Start()
    {
        std::thread recvThread(&Udpserver::receive, this);
        std::thread sendThread(&Udpserver::sent, this);

        recvThread.detach();
        sendThread.detach();
        while (_isrunning)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        close(_socketfd);
    }

private:
    int _socketfd;
    uint16_t _prot;
    bool _isrunning;
    //
    struct sockaddr_in _peer;
    socklen_t _socklen;

    std::mutex _peerMutex;
};

客户端:

#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <memory>
#include <thread>
#include "log.hpp"
#include "Common.hpp"

static bool isrunning = false;
static std::string Clientname;

class Client
{
public:
    Client(const std::string &server_ip, uint16_t server_port)
    {
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd == -1)
        {
            perror("socket creation failed");
            exit(EXIT_FAILURE);
        }

        memset(&_serverAddr, 0, sizeof(_serverAddr));
        _serverAddr.sin_family = AF_INET;
        _serverAddr.sin_port = htons(server_port);
        if (inet_pton(AF_INET, server_ip.c_str(), &_serverAddr.sin_addr) <= 0)
        {
            perror("inet_pton failed");
            close(_sockfd);
            exit(EXIT_FAILURE);
        }

        _isrunning = true;
    }
    void start()
    {
        std::cout << "你是? ";
        std::cin >> _clientName;
        std::cout << "可以进行通信了!" << std::endl;

        std::thread recvThread(&Client::receive, this);
        std::thread sendThread(&Client::send, this);

        recvThread.detach();
        sendThread.detach();

        while (_isrunning)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }

        close(_sockfd);
    }

private:
    void receive()
    {
        while (_isrunning)
        {
            char buffer[1024] = {0};
            struct sockaddr_in peer;
            socklen_t socklen = sizeof(peer);

            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &socklen);
            if (n > 0)
            {
                buffer[n] = 0;
                std::cout << "server: " << buffer << std::endl;
            }
            else if (n == -1)
            {
                perror("recvfrom error");
            }
        }
    }
    void send()
    {
        while (_isrunning)
        {
            std::cout << _clientName << ": ";
            std::string message;
            std::cin >> message;

            ssize_t sent = sendto(_sockfd, message.c_str(), message.size(), 0, (struct sockaddr *)&_serverAddr, sizeof(_serverAddr));
            if (sent == -1)
            {
                perror("sendto error");
            }
        }
    }

private:
    int _sockfd;
    struct sockaddr_in _serverAddr;
    bool _isrunning;
    std::string _clientName;
};

改进:

这一版上,我添加了多线程和锁,能让客户端服务端进行并发的运行,并收发消息

Windows客户端

由于我想让Windows朋友也能与我建立通信,所以我在客户端上进行了修改成Windows版本

 #define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <winsock2.h>
#include <ws2tcpip.h>
#include <thread>
#include <memory>

#pragma comment(lib, "Ws2_32.lib")

static bool isrunning = false;
static std::string Clientname;

class Client
{
public:
    Client(const std::string& server_ip, uint16_t server_port)
    {
        WSADATA wsaData;
        int result = WSAStartup(MAKEWORD(2, 2), &wsaData);
        if (result != 0)
        {
            std::cerr << "WSAStartup failed: " << result << std::endl;
            exit(EXIT_FAILURE);
        }

        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd == INVALID_SOCKET)
        {
            std::cerr << "socket creation failed: " << WSAGetLastError() << std::endl;
            WSACleanup();
            exit(EXIT_FAILURE);
        }

        memset(&_serverAddr, 0, sizeof(_serverAddr));
        _serverAddr.sin_family = AF_INET;
        _serverAddr.sin_port = htons(server_port);
        if (inet_pton(AF_INET, server_ip.c_str(), &_serverAddr.sin_addr) <= 0)
        {
            std::cerr << "inet_pton failed: " << WSAGetLastError() << std::endl;
            closesocket(_sockfd);
            WSACleanup();
            exit(EXIT_FAILURE);
        }

        _isrunning = true;
    }

    void start()
    {
        std::cout << "你是? ";
        std::cin >> _clientName;
        std::cout << "可以进行通信了!" << std::endl;

        std::thread recvThread(&Client::receive, this);
        std::thread sendThread(&Client::send, this);

        recvThread.detach();
        sendThread.detach();

        while (_isrunning)
        {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }

        closesocket(_sockfd);
        WSACleanup();
    }

private:
    void receive()
    {
        while (_isrunning)
        {
            char buffer[1024] = { 0 };
            struct sockaddr_in peer;
            int peerlen = sizeof(peer);

            int n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr*)&peer, &peerlen);
            if (n > 0)
            {
                buffer[n] = 0;
                std::cout << "server: " << buffer << std::endl;
            }
            else if (n == SOCKET_ERROR)
            {
                std::cerr << "recvfrom error: " << WSAGetLastError() << std::endl;
            }
        }
    }

    void send()
    {
        while (_isrunning)
        {
            std::cout << _clientName << ": ";
            std::string message;
            std::cin >> message;

            int sent = sendto(_sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)&_serverAddr, sizeof(_serverAddr));
            if (sent == SOCKET_ERROR)
            {
                std::cerr << "sendto error: " << WSAGetLastError() << std::endl;
            }
        }
    }

private:
    SOCKET _sockfd;
    struct sockaddr_in _serverAddr;
    bool _isrunning;
    std::string _clientName;
};

void useagge(const std::string& proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
        << std::endl;
}

int main()
{
    std::string serverip;
    std::string portStr;
    std::cout << "输入服务器ip: ";
    std::cin >> serverip;
    std::cout << "输入服务器端口号: ";
    std::cin >> portStr;

    uint16_t serverport;
    try
    {
        serverport = static_cast<uint16_t>(std::stoi(portStr));
    }
    catch (const std::exception& e)
    {
        std::cerr << "无效的端口号: " << e.what() << std::endl;
        return EXIT_FAILURE;
    }

    std::unique_ptr<Client> csvr = std::make_unique<Client>(serverip, serverport); // C++14
    csvr->start();
    return 0;
}

一些小问题

由于我用的云服务器,大部分端口号是默认禁用的,所以端口号要自己进行开放,我用的阿里云,开放端口的地方在这里

还可以进行的改进

1.目前服务端和客户端仍然是1对1的关系,如果有第二个用户上线,就会挤占第一个用户,所以这里可以用一个vector来对用户的ip进行管理,来统一收所有用户消息

2.目前还没有将用户的名字传输给服务端,后续可以加上

return0的达瓦里氏
关注
  • 9
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java进阶：基于TCP的网络实时聊天室（socket通信案例）
陆海潘江的博客
11-07 1万+
开门见山，系列文章不断完善C/S架构的Socket通信，本篇Java进阶：基于TCP的网络实时聊天室（socket通信案例），使用客户端-服务器（C/S架构），结合多线程技术，模拟类似QQ、微信聊天功能，实现一个网络实时聊天室。学习到的知识有：多线程、线程池、Socket通信编程、TCP、JavaFX等。首先是实现了Server和Client的互相通信，接着使用多线程技术解决客户端实时接收信息的问题，后来到了服务器端，发现多用户连接服务器的“先到先得”问题，所以再使用线程池技术解决了多用户服务器的问题。
socket(java) 搭建一个多人在线聊天室
dragonylee的博客
07-01 6039
目录说明Socket及java编程方法功能结构共享类服务器端客户端效果展示代码 说明 今年由于疫情原因只能在家里学习，今年学校有一门很重要的课程《面向对象》，学习了java中的编程思想、多线程、JML、UML等等东西，为了检验自己学习得好不好，再加上听说 java 很适合 socket 编程，并且阿里云的服务器一年才九十多块钱，我就决定（其实以上都不是主要原因，主要原因就是考完试在家闲的发慌）决定搭建一个多人在线聊天室，并且从中也可以学习 Swing、socket 等等。 后面代码中所有GUI界面布局的
网络程序设计：基于Socket和epoll的网络聊天室
weixin_46108475的博客
12-25 1079
该函数用于创建一个套接字。返回值:成功返回文件描述符，失败返回-1domain:协议域，AF_INET代表使用IPv4type:socket类型，代表使用TCP传输protocol:协议，0表示使用默认协议本实验中采用Socket API和epoll实现了可并发的聊天服务器，虽然使用epoll相较于使用select来说代码更加复杂，但是提高了处理的效率。在本学期的网络程序设计中，我对于网络编程有了更深入的认识。
java udp socket 聊天室_新手网络编程之UDP实现「实时聊天室」
weixin_30747571的博客
02-24 407
新手网络编程之UDP实现聊天室实时在线互动聊天上一篇文章我使用了TCP协议实现了一个非常非常简单的聊天，存在客户端和服务端，客户端和服务端必须要相互连接成功才能进行数据传输。(就像“打电话”，接通了才能互相收到语音)；而UDP协议就不同了，它不需要服务端，发出去的文件也不需要确定与对方是否连接成功！(就像发短信，时时刻刻都可以发，无论对方状态如何)。简介聊天室最重要的是能够相互发送消息，接收消息，...
基于TCP的网络实时聊天室（socket通信案例）
Java团长的博客
12-10 3555
来源：https://blog.csdn.net/Charzous开门见山比较系统地学习基于TCP协议实现网络通信，也是计算机网络中重中之重，TCP/IP属于网络层，在java中，对该层...
[Socket]Python用UDP协议建立带有私聊功能的网络聊天室-建立聊天工具
Bartender_VA11的博客
09-02 6073
如何用Python写一个socket编程带有私聊功能的UDP网络聊天室，UDP/TCP多线程聊天工具
Java网络聊天室系统的设计与实现
热门推荐
weixin_40228600的博客
06-09 1万+
摘要：计算机现在对我们的生活而言十分重要，不管是生活还是工作都需要用到计算机，可想而知，未来的人类会十分依赖计算机技术，用计算机上网的人毋庸置疑会越来越多，可想而知，不断会有人来改进和完善物联网技术，来提高自己的生活水平。就计算机的编程而言，互联网软件开发逐渐以Java为核心而全面发展，之前的编程技术已经慢慢满足不了我们的需求，java正在以恐怖的速度发展。人们日常所要面对的各种问题，如吃饭，娱乐，工作，休息还有现在大家所逐渐接受的网络游戏都在使用面向对象的技术。而且企业的开发成本和开发人员的开发时间和难度
计算机网络-聊天室的设计与实现
weixin_43846708的博客
04-21 8711
计算机网络实践一、实践设计的目的和意义二、实践设计的内容和要求三、设计用设备仪器四、实践设计的相关技术五、项目设计与实践1、设计思路2、模块描述运行结果六、结束语 一、实践设计的目的和意义 在互联网如此发达的今天，即时通信工具已经成为我们如今日常生活中必不可少的一部分。 人们对网络的依赖越来越多，越来越离不开网络，而由此产生的聊天工具也越来越多，类似有QQ、MSN、微信等，网络聊天使网络聊天系统发展的日新月异，由此产生制作了一个简单的聊天功能的网络聊天程序，由此此设计我们还可以更好的学习网络软件的编程知识。
Socket多人聊天MFC版
_ACME_的博客
10-31 8119
源码下载地址： https://github.com/coderxj/Socket-Group-Chat 包括前面C语言版的1V1 和 多人聊天源码都有。coding 环境：VS2015 WIN10测试环境：VM虚拟机–>XP系统、2003server和主机WIN10语言：C++,类库MFC功能：基于服务器转发消息的多人聊天。主要原理：server给每个连上的client都创建一个线程单独管理，
Java基于socket实现简易聊天室实例
09-03
【Java基于socket实现简易聊天室】的实例是一个基础的网络通信应用，用于演示如何通过Java的Socket编程在服务器端和客户端之间实现简单的文本聊天功能。在这个实例中，我们使用了两个核心类：`SendDemo` 和 `...
基于socket.io聊天室功能
10-25
在这个“基于socket.io聊天室功能”的项目中，我们将探讨如何使用 Socket.IO 构建一个简单的聊天室应用。 1. **Socket.IO 的基本概念** - **事件驱动**：Socket.IO 的通信基于事件模型，客户端和服务器通过发送和...
基于C#的一个Socket聊天室实例
01-12
总之，基于C#的Socket聊天室实例是一个很好的学习资源，它涵盖了网络编程的核心概念和技巧，对于想要深入理解网络通信和C#编程的开发者来说，是一个宝贵的实践机会。通过分析和改进这个实例，你可以提升自己的编程...
基于-linux网络聊天室设计.doc
11-28
在本文档中，我们探讨了基于Linux的网络聊天室的设计，这是一个旨在巩固和提升学生Linux操作系统编程技能的课程设计项目。这个项目不仅关注基础技术，如进程和线程通信、同步技术，还涉及socket网络通信，这些都是...
网络聊天室课程设计（含课程报告和代码）.rar
12-28
【网络聊天室课程设计】是一项常见的计算机科学与技术专业课程实践项目，旨在让学生掌握网络编程的基本原理和实际应用。在这个项目中，学生们通常会利用TCP/IP协议栈进行网络通信，实现一个基本的实时在线聊天平台。...
软考数据库——第五章网络基础知识（知识点介绍和历年真题）
分享关于数据的知识。
07-06 184
第五章网络基础知识
Mac虚拟机跑Windows流畅吗 Mac虚拟机连不上网络怎么解决 mac虚拟机网速慢怎么解决
最新发布
2401_82916694的博客
07-10 575
选择Shared模式，你的Mac会当作虚拟机的路由器。一般来说，拥有更高性能的Cpu（如Apple M2或M3芯片）、更大的内存（建议16GB以上）、以及足够的存储空间可以显著提升虚拟机中Windows的运行流畅度。Mac的防火墙或其他安全设置可能阻止虚拟机访问网络，如果你的Mac主机可以访问网络，并且排查了上文介绍的情况，那么可以尝试关闭Mac电脑防火墙，再检查虚拟机是否可以连接网络。使用Mac虚拟机运行Windows是否流畅，取决于几个关键因素：硬件配置、虚拟机软件的选择以及虚拟机的设置。
Zabbix自动发现
Lzcsfg的博客
07-08 738
在 Zabbix 中，自动发现（Auto Discovery）是一种强大的功能，用于自动识别和监控网络设备、服务或应用程序中的动态变化。通过自动发现功能，Zabbix 可以自动添加、配置和监控新的网络节点或服务，大大简化了管理和监控大规模环境的复杂性。
从零开始做题：logtime
weixin_44626085的博客
07-10 202
给出1个pcapng文件。
基于Java聊天室的socket设计和实现.docx
05-09
论文还详细阐述了Java Socket编程的实现原理、步骤和技巧，以及Java聊天室的需求分析、系统架构设计、功能实现和性能优化。在测试与部署部分，论文介绍了测试方法、结果分析和部署策略。最后，论文展望了Java聊天室...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值