网络——套接字编程TCP

目录

服务端

创建套接字（socket）

服务端绑定（bind）

服务端监听（listen）

服务器接收（accept）

服务端处理（read & write）

客户端

创建套接字（socket）

客户端连接（connect）

客户端处理（send & recv）​​​​​​​

多进程代码测试

捕获忽略SIGCHLD信号

子进程创建子进程

多线程代码测试    

线程池代码测试

服务端

创建套接字（socket）

        我们继续将TCP服务器封装成一个类，TCP创建套接字只有第二个参数不同，所需要的服务类型是SOCK_STREAM，这就是一个可靠的、需要链接的、全双工的、面向字节流的协议。

class TcpServer
{
public:
    TcpServer(uint16_t port, std::string ip = "")
        :_port(port)
        ,_ip(ip)
        ,_sock(-1)
    {}

    void initServer()
    {
        // 创建socket
        _sock = socket(AF_INET, SOCK_STREAM, 0);
        if (_sock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "sock: %d", _sock);
    }

    ~TcpServer()
    {
        if (_sock > 0)
            close(_sock);
    }
private:
    uint16_t _port;
    std::string _ip;
    int _sock;
};

服务端绑定（bind）

        绑定的操作和UDP是差不多的，想要详细了解可以翻看上一篇。

    // 创建套接字
    // ...    

    // bind
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
        exit(3);
    }

服务端监听（listen）

        至此，创建套接字和绑定与UDP没有太大的差别，而TCP是面向连接的，客户端发送数据要先与TCP建立连接，然后才能通信。

        所以TCP要注意，随时都有可能从客户端发来连接请求，此时就需要将TCP服务器创建的套接字设置为监听状态，用到的函数就是listen。

参数：

  • sockfd：需要设置为监听状态的套接字文件描述符
  • backlog：全连接队列的最大长度，具体是什么后面再说，一般设置为5、10或20就可以

返回值：监听成功返回0，失败返回-1，错误码被设置。

        至此，我的服务器初始化任务已经完成了。

const static int g_backlog = 20;

void initServer()
{
    // 创建socket
    _sock = socket(AF_INET, SOCK_STREAM, 0);
    if (_sock < 0)
    {
        logMessage(FATAL, "%d:%s", errno, strerror(errno));
        exit(2);
    }
    logMessage(NORMAL, "sock: %d", _sock);

    // bind
    struct sockaddr_in local;
    memset(&local, 0, sizeof(local));
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
    if (bind(_sock, (struct sockaddr*)&local, sizeof(local)) < 0)
    {
        logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
        exit(3);
    }
    logMessage(NORMAL, "bind success ...");

    // tcp面向连接的，通信前要先建立连接，设置为监听状态，listen
    if (listen(_sock, g_backlog) < 0)
    {
        logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
        exit(4);
    }
    logMessage(NORMAL, "listen success ...");

    logMessage(NORMAL, "init server success");
}

服务器接收（accept）

        TCP服务器在与客户端进行通信之前，服务器需要先获取到客户端的连接请求，获取的函数就是accept。

参数：

  • sockfd：从该套接字中获取连接
  • addr：输出型参数，获取对端的网络属性信息
  • addrlen：输入输出型参数，返回实际读到的addr结构体的长度、

返回值：获取连接成功的对端套接字的文件描述符，失败返回-1，错误吗被设置。

accept返回值 vs sockfd：

  • sockfd是我们绑定的监听套接字，它只负责帮我们把获取的连接拿过来。
  • 而真正执行IO的就是accept返回的对端的套接字。

所以我们上述的_sock也叫做监听套接字listensock（_sock->listensock）。

void start()
{
    while (true)
    {
        // 获取连接accept
        struct sockaddr_in src; // 客户端addr
        socklen_t len = sizeof(src);
        int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
        if (servicesock < 0)
        {
            logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
            // 接收失败也不影响，继续接收
            continue;
        }

        // 获取连接成功
        uint16_t client_port = ntohs(src.sin_port);
        std::string client_ip = inet_ntoa(src.sin_addr);
        logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n",
                    servicesock, client_ip.c_str(), client_port);

        // 处理任务

        close(servicesock);
    }
}

服务端处理（read & write）

static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{
    // echo
    char buffer[1024];
    while (true)
    {
        // read和write可以直接使用
        // 读取数据
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的消息当做字符串
            std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 代表对端关闭连接
            logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
            break; // 跳出循环结束通信
        }
        else
        {
            logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
            break;
        }

        // 写回数据
        write(sock, buffer, sizeof(buffer));
    }
}

// 获取连接成功
// ...

service(servicesock, client_ip, client_port);

close(servicesock);

        直接使用read和write就可以进行IO了，但是就有一个问题，当一个连接被接收到了，这个函数就是一个死循环，对端不退出会一直执行，那么如果此时再来一个连接那就会被阻塞。

        那我们就可以使用多进程，子进程负责处理接收的文件描述符，父进程负责接收描述符。

void start()
{
    signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态
    while (true)
    {
        // 获取连接accept
        // ...

        // 获取连接成功
        // ...

        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            // 子进程
            // 子进程也会继承父进程的文件与文件fd
            // 子进程提供服务，他不用管监听的事，所以要关闭
            close(listensock);
            service(servicesock, client_ip, client_port);
            exit(0);
        }
        // 父进程
        // 父进程只需要接收sock，所以要关闭服务sock
        close(servicesock);
    }
}

客户端

创建套接字（socket）

        初始化客户端，而客户端唯一要做的就是创建套接字，它不需要bind，也不需要listen，因为没有人会去连接客户端，那就更不需要accept接收了，它只需要知道服务端的IP和PORT就可以了。

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

客户端连接（connect）

        向服务端发起连接请求，使用的函数就是connect。

参数：

  • sockfd：通过该套接字发起连接请求
  • addr：服务端网络属性信息
  • addrlen：传入的addr结构体的长度

返回值：连接成功返回0，失败返回-1，错误码被设置。

        客户端不需要bind，当客户端向服务端发起连接请求，操作系统会自动给客户端分配端口号。

// 不需要显示绑定bind，OS自动选择port
// 2.向服务端发起建立连接的请求connect
struct sockaddr_in server;
memset(&server, 0, sizeof(server));
server.sin_family = AF_INET;
server.sin_port = htons(serverport);
server.sin_addr.s_addr = inet_addr(serverip.c_str());

if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
{
    std::cerr << "connect error" << std::endl;
    exit(3);
}

客户端处理（send & recv）

        send和recv是TCP用来通信的接口，但是read和write也可以使用。

作用：发送数据到对端

ssize_t send(int sockfd, const void *buf, size_t len, int flags);

参数：

  • sockfd：向创建的套接字写入
  • buf：要把哪个缓冲区中的数据写入
  • len：缓冲区的长度
  • flags：一般默认为0

返回值：成功返回发送的数据个数，失败返回-1，错误码被设置。

 

作用：接收对端的数据

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

参数：

  • sockfd：从哪个套接字中接收数据
  • buf：将接收的数据放到的缓冲区
  • len：缓冲区的长度
  • flags：一般设置为0

返回值：成功返回接收的个数，失败返回-1，错误码被设置。

while (true)
{
    std::string line;
    std::cout << "请输入: ";
    std::getline(std::cin, line);

    send(sock, line.c_str(), line.size(), 0);

    char buffer[1024];
    ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
    if (s > 0)
    {
        buffer[s] = 0;
        std::cout << "server echo: " << buffer << std::endl;
    }
    else if (s == 0)
    {
        // 对端关闭
        break;
    }
    else
    {
        break;
    }
}

多进程代码测试

捕获忽略SIGCHLD信号

// tcp_server.hpp

#pragma once
#include <iostream>
#include <string>

#include <cerrno>
#include <cstdio>
#include <cstring>
#include <cassert>

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

#include "log.hpp"

static void service(int sock, const std::string& clientip, const uint16_t& clientport)
{
    // echo
    char buffer[1024];
    while (true)
    {
        // read和write可以直接使用
        // 读取数据
        ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
        if (s > 0)
        {
            buffer[s] = 0; // 将发过来的消息当做字符串
            std::cout << clientip << " : " << clientport << "# " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 代表对端关闭连接
            logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
            break; // 跳出循环结束通信
        }
        else
        {
            logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
            break;
        }

        // 写回数据
        write(sock, buffer, strlen(buffer));
    }
}


class TcpServer
{
    const static int g_backlog = 20;

public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port), _ip(ip), listensock(-1)
    {}

    void initServer()
    {
        // 创建socket
        listensock = socket(AF_INET, SOCK_STREAM, 0);
        if (listensock < 0)
        {
            logMessage(FATAL, "%d:%s", errno, strerror(errno));
            exit(2);
        }
        logMessage(NORMAL, "sock: %d", listensock);

        // bind
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = _ip.empty() ? INADDR_ANY : inet_addr(_ip.c_str());
        if (bind(listensock, (struct sockaddr *)&local, sizeof(local)) < 0)
        {
            logMessage(FATAL, "bind error, %d:%s", errno, strerror(errno));
            exit(3);
        }
        logMessage(NORMAL, "bind success ...");

        // tcp面向连接的，通信前要先建立连接，设置为监听状态，listen
        if (listen(listensock, g_backlog) < 0)
        {
            logMessage(FATAL, "listen error, %d:%s", errno, strerror(errno));
            exit(4);
        }
        logMessage(NORMAL, "listen success ...");

        logMessage(NORMAL, "init server success");
    }

    void start()
    {
        signal(SIGCHLD, SIG_IGN); // 子进程退出向父进程发送SIGCHLD，直接忽略这个信号，子进程退出就自动释放僵尸状态
        while (true)
        {
            // 获取连接accept
            struct sockaddr_in src; // 客户端addr
            socklen_t len = sizeof(src);
            int servicesock = accept(listensock, (struct sockaddr *)&src, &len);
            if (servicesock < 0)
            {
                logMessage(ERROR, "accept error, %d:%s", errno, strerror(errno));
                // 接收失败也不影响，继续接收
                continue;
            }

            // 获取连接成功
            uint16_t client_port = ntohs(src.sin_port);
            std::string client_ip = inet_ntoa(src.sin_addr);
            logMessage(NORMAL, "link success, servicesock: %d | %s : %d|\n", servicesock, client_ip.c_str(), client_port);

            // v1 -- 单进程循环版
            // service(servicesock, client_ip, client_port);

            // v2 -- 多进程版
            pid_t id = fork();
            assert(id != -1);
            if (id == 0)
            {
                // 子进程
                // 子进程也会继承父进程的文件与文件fd
                // 子进程提供服务，他不用管监听的事，所以要关闭
                // 这是不是很像匿名管道呢
                close(listensock);
                service(servicesock, client_ip, client_port);
                exit(0);
            }
            // 父进程
            // 父进程只需要接收sock，所以要关闭服务sock
            close(servicesock);
        }
    }

    ~TcpServer()
    {
        if (listensock > 0)
            close(listensock);
    }

private:
    uint16_t _port;
    std::string _ip;
    int listensock;
};
// tcp_server.cc

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

void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " port\n" << std::endl;
}

// ./tcp_server port
int main(int argc, char* argv[])
{
    if (argc != 2)
    {
        usage(argv[0]);
        exit(1);
    }

    uint16_t port = atoi(argv[1]);
    std::unique_ptr<TcpServer> svr(new TcpServer(port));

    svr->initServer();

    svr->start();

    return 0;
}
// tcp_client.cc

#include <iostream>
#include <unistd.h>
#include <string>

#include <cstring>

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


void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ip port\n" << std::endl;
}


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

    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);

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

    // 不需要显示绑定bind，OS自动选择port
    // 2.向服务端发起建立连接的请求connect
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());
    if (connect(sock, (struct sockaddr*)&server, sizeof(server)) < 0)
    {
        std::cerr << "connect error" << std::endl;
        exit(3);
    }

    // 连接成功
    std::cout << "connect success" << std::endl;
    while (true)
    {
        std::string line;
        std::cout << "请输入: ";
        std::getline(std::cin, line);

        send(sock, line.c_str(), line.size(), 0);
        char buffer[1024];
        ssize_t s = recv(sock, buffer, sizeof(buffer) - 1, 0);
        if (s > 0)
        {
            buffer[s] = 0;
            std::cout << "server echo: " << buffer << std::endl;
        }
        else if (s == 0)
        {
            // 对端关闭
            break;
        }
        else
        {
            break;
        }
    }
    close(sock);
    return 0;
}

子进程创建子进程

        其实多进程还有一种写法，我们再来看看这种写法是怎么实现的，这种写法没有用子进程退出向父进程发送SIGCHLD信号的特性。

void start()
{
    while (true)
    {
        // 获取连接accept
        // ...

        // 获取连接成功
        // ...

        pid_t id = fork();
        assert(id != -1);
        if (id == 0)
        {
            // 子进程
            close(listensock);
            if (fork() > 0) exit(0); // 子进程fork创建孙子进程，子进程exit退出了
            // 孙子进程就变成了孤儿进程，孤儿进程会被系统领养，执行完后由操作系统释放
            service(servicesock, client_ip, client_port);
            exit(0);
        }
        // 父进程
        close(servicesock);
        waitpid(id, nullptr, 0); //阻塞式等待子进程退出
    }
}

多线程代码测试    

        创建进程的成本是很高的，创建进程时需要创建该进程对应task_struct、进程地址空间（mm_struct）等数据结构。而创建线程的成本就会会小得多，线程本质是在进程地址空间内运行，创建出来的线程会共享该进程的大部分资源，因此在实现多执行流的服务器时最好采用多线程进行实现。

class ThreadData
{
public:
    int sock;
    uint16_t port;
    std::string ip;
};

class TcpServer
{
    static void *threadRoutine(void *args)
    {
        pthread_detach(pthread_self()); // 线程分离，就不用join了
        ThreadData *td = (ThreadData *)args;
        service(td->sock, td->ip, td->port);

        delete td;

        return nullptr;
    }

private:
    void start()
    {
        while (true)
        {
            // 获取连接accept
            // ...

            // 获取连接成功
            // ...

            ThreadData *td = new ThreadData();
            td->sock = servicesock;
            td->ip = client_ip;
            td->port = client_port;
            pthread_t tid;
            // 多线程就不用关闭listensock文件描述符了，线程共享这些文件描述符
            pthread_create(&tid, nullptr, threadRoutine, (void *)td);
            close(servicesock);
        }
    }
};

再查看一下线程信息。

线程池代码测试

        当有新连接到来时，服务端的主线程都会重新为该客户端创建新线程，当服务结束后，将该线程销毁，在短时间内创建与销毁线程，这样做不仅麻烦，而且效率低，创建线程和销毁线程也是有成本的。
        所以为了解决这样的问题我们就可以引入线程池，客户端有发来任务，线程就为他服务，服务完后可以让线程休眠，再有任务来时再将线程唤醒。

        创建的线程也不能太多，要不然CPU的压力也会过大。如果这一批线程都在服务客户，再来一个客户端的连接就不能创建线程，应该让这个新来的连接请求在连接队列中排队，有空闲线程后再获取请求的连接为它提供服务。

        当有新的任务到来的时候，就Push到线程池中的任务队列中，多线程就不断检测任务队列中是否有任务，通过封装的任务类，调用仿函数执行相应的操作。

        这次我们想要实现一个网络词典的功能。

class TcpServer
{
public:
    TcpServer(uint16_t port, std::string ip = "")
        : _port(port)
        , _ip(ip)
        , listensock(-1)
        , _threadpool_ptr(ThreadPool<Task>::getThreadPool()) // 获取线程池
    {}

    void start()
    {
        _threadpool_ptr->run();

        while (true)
        {
            // 获取连接accept
            // ...

            // 获取连接成功
            // ...

            Task t(servicesock, client_ip, client_port, dictOnline);
            _threadpool_ptr->pushTask(t);
        }
    }
private:
    // ...
    std::unique_ptr<ThreadPool<Task>> _threadpool_ptr; // 线程池指针
};

        添加成员变量_threadpool_ptr，用智能指针维护，在构造函数的初始化列表中调用getThreadPool获取线程池，因为线程池用了单例模式。当TCP服务端初始化完成后，调用start函数，首先就要启动线程池，当accept接受到对端的sock文件描述符后就可以制作任务，并push到任务队列中。

// Task.hpp

typedef std::function<void (int, const std::string&, const uint16_t&, const std::string&)> func_t;

class Task
{
public:
    Task(){}
    Task(int sock, const std::string& ip, const uint16_t port, func_t func)
        :_sock(sock)
        ,_ip(ip)
        ,_port(port)
        ,_func(func)
    {}
    void operator()(const std::string& name)
    {
        _func(_sock, _ip, _port, name);
    }    
public:
    int _sock;
    std::string _ip;
    uint16_t _port;
    func_t _func;
};

         我们想要实现一个从客户端接收一个英文单词，在单词的map中找，找到了就返回，没有找到就告知客户端词库中没有这个单词。

        这次我们采用短连接的方式，这个dictOnline函数就是修改了service函数，service函数使用的是死循环，一个线程对应一个客户端，如果这个客户端已经连接上了，它一直死循环不退出地做某件事，那么服务器接收的连接数就被限制了，所以来一个连接就服务一个，服务完之后，双方都断开连接。

static void dictOnline(int sock, const std::string &clientip, const uint16_t &clientport, const std::string &thread_name)
{
    // 网络词典
    static unordered_map<std::string, std::string> dict = {
        {"apple", "苹果"},
        {"banana", "香蕉"},
        {"process", "进程"},
        {"thread", "线程"}}; // 简易字典
    char buffer[1024];
    // read和write可以直接使用
    // 读取数据
    ssize_t s = read(sock, buffer, sizeof(buffer) - 1);
    if (s > 0)
    {
        buffer[s] = 0; // 将发过来的消息当做字符串
        std::cout << thread_name << " | " << clientip << " : " << clientport << "# " << buffer << std::endl;
        std::string message;
        auto iter = dict.find(buffer);
        if (iter == dict.end())
            message = "词库中无此单词";
        else
            message = iter->second;
        // 写回数据
        write(sock, message.c_str(), message.size());
    }
    else if (s == 0)
    {
        // 代表对端关闭连接
        logMessage(NORMAL, "%s:%d shutdown , me too", clientip.c_str(), clientport);
    }
    else
    {
        logMessage(ERROR, "read sock error, %d:%s", errno, strerror(errno));
    }
    close(sock);
}

        所以采用短连接，客户端可以死循环，每次执行完后就要关闭套接字，再一次连接的时候就要创建套接字。

void usage(std::string proc)
{
    std::cout << "\nUsage: " << proc << " ip port\n"
              << std::endl;
}

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

    std::string serverip = argv[1];
    uint16_t serverport = atoi(argv[2]);
    int sock = 0;
    std::string line;

    while (true)
    {
        // 1.创建套接字
        sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0)
        {
            std::cerr << "socket error" << std::endl;
            exit(2);
        }

        // 不需要显示绑定bind，OS自动选择port
        // 2.向服务端发起建立连接的请求connect
        struct sockaddr_in server;
        memset(&server, 0, sizeof(server));
        server.sin_family = AF_INET;
        server.sin_port = htons(serverport);
        server.sin_addr.s_addr = inet_addr(serverip.c_str());
        if (connect(sock, (struct sockaddr *)&server, sizeof(server)) < 0)
        {
            std::cerr << "connect error" << std::endl;
            exit(3);
        }
        // 连接成功
        std::cout << "connect success" << std::endl;

        std::cout << "请输入英文: ";
        std::getline(std::cin, line);
        if (line == "quit")
            break;

        ssize_t s = send(sock, line.c_str(), line.size(), 0);
        if (s > 0)
        {
            char buffer[1024];
            s = recv(sock, buffer, sizeof(buffer) - 1, 0);
            if (s > 0)
            {
                buffer[s] = 0;
                std::cout << "中文: " << buffer << std::endl;
            }
        }
        close(sock);
    }
    return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/501772.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

抖店不出单怎么办？关键在选品！想要选到”好品”就必须这样做！

抖店不出单怎么办？关键在选品！想要选到”好品”就必须这样做！

哈喽~我是电商月月 做抖音小店在新手眼里&#xff0c;最难的是什么&#xff1f;有好多都说是&#xff0c;找达人 但其实不是&#xff0c;最难的就是找品&#xff0c;一个好的产品是自带流量的 我们可以这样理解&#xff1a;你见到的那些有能力的主播她是一个人做起来的吗&am…
阅读更多...
GT收发器第四篇_QPLL和CPLL工作原理

GT收发器第四篇_QPLL和CPLL工作原理

文章目录 前言一、CPLL工作原理二、QPLL工作原理 前言 每个channel的时钟结构如图&#xff1a; Transceiver内部时钟来源可以是QPLL也可以是自己的CPLL。其内部TX 和 RX 时钟分频器可以单独从 QPLL 或 CPLL 中选择时钟&#xff0c;允许 TX和 RX 数据通道使用不同的参考时钟输入…
阅读更多...
公司官网怎么才会被百度收录

公司官网怎么才会被百度收录

在互联网时代&#xff0c;公司官网是企业展示自身形象、产品与服务的重要窗口。然而&#xff0c;即使拥有精美的官网&#xff0c;如果不被搜索引擎收录&#xff0c;就无法被用户发现。本文将介绍公司官网如何被百度收录的一些方法和步骤。 1. 创建和提交网站地图 创建网站地图…
阅读更多...
用MATLAB编写一个简易的贪吃蛇游戏

用MATLAB编写一个简易的贪吃蛇游戏

编写一个贪吃蛇游戏的MATLAB代码需要涉及到游戏逻辑、图形用户界面(GUI)的创建、事件监听&#xff08;如键盘操作&#xff09;和游戏状态更新等。以下是一个简化的贪吃蛇游戏MATLAB代码示例&#xff0c;展示了基本的游戏框架和逻辑。 此代码创建了一个游戏窗口&#xf…
阅读更多...
【Qt】常用控件（多元素控件）

【Qt】常用控件（多元素控件）

目录 一、概述二、QListWidget三、QTableWidget四、QTreeWidget 一、概述 Qt中提供的多元素控件有&#xff1a; QListWidgetQListViewQTableWidgetQTableViewQTreeWidgetQTreeView xxWidget 和 xxView 的区别 以 QTableView 和 QTableView 为例 QTableView 是基于 MVC 设计的…
阅读更多...
Type-C接口取电解决方案LDR6500

Type-C接口取电解决方案LDR6500

随着科技的不断进步&#xff0c;Type-C接口已经成为现代电子设备中不可或缺的一部分。作为一种全新的接口标准&#xff0c;Type-C以其独特的设计和强大的功能&#xff0c;在数据传输和电力传输领域展现出了巨大的潜力。特别是在取电应用方面&#xff0c;Type-C接口正逐渐改变着…
阅读更多...
Linux重点思考(上）--权限/解压/定时任务/性能

Linux重点思考(上）--权限/解压/定时任务/性能

Linux重点思考(上&#xff09;--权限/解压/定时任务 权限修改格式chmod使用 打包解压tar -zcvf ab.tar&#xff08;打包&#xff09;tar -xvf ab.tar -C/usr &#xff08;解压&#xff09; 系统防火墙service iptables statussystemctl status iptables区别 定时任务定时任务-c…
阅读更多...
SpringBoot2.6.3 + knife4j-openapi3

SpringBoot2.6.3 + knife4j-openapi3

1.引入项目依赖&#xff1a; <dependency><groupId>com.github.xiaoymin</groupId><artifactId>knife4j-openapi3-spring-boot-starter</artifactId><version>4.5.0</version> </dependency> 2.新增配置文件 import io.swag…
阅读更多...
第3集《唯识学概要》

第3集《唯识学概要》

诸位法师慈悲&#xff0c;陈会长慈悲&#xff0c;诸位菩萨&#xff0c;阿弥陀佛&#xff01; 请大家打开讲义第九面。 第九面&#xff0c;它谈到了我们众生的两种缘起。那么佛陀在大乘经典把我们生命的缘起分成两大块&#xff0c;一个是属于一种清净的缘起&#xff0c;一种是属…
阅读更多...
【独立开发前线】Vol.26 【独立开发产品】吉光卡片-让你的文字变得酷炫起来

【独立开发前线】Vol.26 【独立开发产品】吉光卡片-让你的文字变得酷炫起来

今天给大家分享一下 独立开发前线 社区成员张小吉 的作品 吉光卡片&#xff1b; 这是一款iOS的APP&#xff0c;下载&#xff1a;吉光卡片&#xff0c;主要功能是帮你制作酷炫的文字卡片&#xff0c;用精美的卡片让你的文字生动起来。 展示效果如下&#xff1a; 你可以用它制作…
阅读更多...
vite+vue3使用模块化批量发布Mockjs接口

vite+vue3使用模块化批量发布Mockjs接口

在Vue3项目中使用Mock.js可以模拟后端接口数据&#xff0c;方便前端开发和调试。下面是使用vitevue3使用模块化批量发布Mockjs接口的步骤&#xff1a; 1. 安装Mock.js 在Vue3项目的根目录下&#xff0c;使用以下命令安装Mock.js&#xff1a; npm install mockjs --save-dev …
阅读更多...
vue3编写倒计时效果

vue3编写倒计时效果

说明&#xff1a;来自CSDN-问答板块&#xff0c;题主提问。 需求&#xff1a;如何通过表单控制倒计时开始时间&#xff0c;比如设定倒计时五分钟&#xff0c;循环几次&#xff0c;点击开始倒计时按钮&#xff0c;就让他从5分00秒&#xff0c;开始每秒减少&#xff0c;然后到0分…
阅读更多...
001搭建前端环境—“01红C”的java项目【苍穹外卖】

001搭建前端环境—“01红C”的java项目【苍穹外卖】

整个项目是采用前后端分离的方式开发的 1. 前端工程基于nginx 2. 启动nginx&#xff0c;访问测试 双击 nginx.exe 即可启动 nginx 服务&#xff0c;访问端口号为 80 http://localhost:80
阅读更多...
头歌 实验一 关系数据库标准语言SQL湖北汽车工业学院 ）

头歌 实验一 关系数据库标准语言SQL湖北汽车工业学院 ）

头歌 实验一 关系数据库标准语言SQL 制作不易&#xff01;点个关注呗&#xff01;为大家创造更多的价值&#xff01; 目录 头歌 实验一 关系数据库标准语言SQL**制作不易&#xff01;点个关注呗&#xff01;为大家创造更多的价值&#xff01;** 第一关&#xff1a;创建数据库第…
阅读更多...
AI：155-基于深度学习的股票价格预测模型

AI：155-基于深度学习的股票价格预测模型

本文收录于专栏：精通AI实战千例专栏合集 从基础到实践，深入学习。无论你是初学者还是经验丰富的老手，对于本专栏案例和项目实践都有参考学习意义。 每一个案例都附带关键代码，详细讲解供大家学习，希望可以帮到大家。正在不断更新中~ 一.基于深度学习的股票价格预测模型 …
阅读更多...
基于STC12C5A60S2系列1T 8051单片机的一个按键长按开关机后一个按键单击长按都增加数值另一个按键单击长按都减少数值应用

基于STC12C5A60S2系列1T 8051单片机的一个按键长按开关机后一个按键单击长按都增加数值另一个按键单击长按都减少数值应用

基于STC12C5A60S2系列1T 8051单片机的一个按键长按开关机后一个按键单击长按都增加数值另一个按键单击长按都减少数值应用 STC12C5A60S2系列1T 8051单片机管脚图STC12C5A60S2系列1T 8051单片机I/O口各种不同工作模式及配置STC12C5A60S2系列1T 8051单片机I/O口各种不同工作模式介…
阅读更多...
物流监控升级，百递云·API开放平台助力某电商平台实现高效物流管理

物流监控升级，百递云·API开放平台助力某电商平台实现高效物流管理

不论是电商平台自身还是消费者&#xff0c;都有着对物流监控的强烈需求。 消费者下单后be like: 每十分钟看一次快递轨迹 放心&#xff0c;电商平台也一样关心物流状态&#xff01;怎样第一时间向用户传递物流状态&#xff1f; 怎么减少重复的提问和投诉&#xff1f;怎样监管…
阅读更多...
rhcsa复习4

rhcsa复习4

文件权限 文件的权限针对三类对象进行定义 owner 属主&#xff0c;缩写 u group 属组&#xff0c;缩写 g other 其他&#xff0c;缩写 o 每个文件针对每类访问者定义了三种主要权限 r &#xff1a; Read 读 - 文本文件 cat tac more less head tail paste d ls -l 列…
阅读更多...
每天五分钟计算机视觉：使用神经网络完成人脸的特征点检测

每天五分钟计算机视觉：使用神经网络完成人脸的特征点检测

本文重点 我们上一节课程中学习了如何利用神经网络对图片中的对象进行定位，也就是通过输出四个参数值bx、by、bℎ和bw给出图片中对象的边界框。 本节课程我们学习特征点的检测，神经网络可以通过输出图片中对象的特征点的(x,y)坐标来实现对目标特征的识别，我们看几个例子。…
阅读更多...
【公示】2023年度青岛市级科技企业孵化器拟认定名单

【公示】2023年度青岛市级科技企业孵化器拟认定名单

根据《青岛市科技企业孵化器管理办法》&#xff08;青科规〔2023〕1号&#xff09;&#xff08;以下简称《管理办法》&#xff09;、《关于开展2023年度市级科技企业孵化器认定申报工作的通知》&#xff0c;经申报受理、区市推荐、形式审查、专家评审及现场核查等程序&#xff…
阅读更多...
最新文章

Copyright @ 2022~2023