ArronHC的博客

muduo学习笔记

Fri, 19 Dec 2025 19:31:23 GMT

为了精进自己的后端开发能力，打算深入陈硕大佬的 muduo 项目，学习网络编程中的Reactor 多线程并发模型，如何处理高并发的情况。

动起来！

我们在拆解“发动机”之前，不妨先看看这个“发动机”动起来是什么样的：

1. 安装依赖

sudo apt-get update
sudo apt-get install git cmake g++ gcc
# 安装 boost 库
sudo apt-get install libboost-dev libboost-test-dev libboost-program-options-dev libboost-system-dev libboost-filesystem-dev

2. 下载并编译

陈硕老师提供了编译脚本

# 克隆仓库
git clone https://github.com/chenshuo/muduo.git
cd muduo

# 运行构建脚本
./build.sh

3. 看一下效果

我们以老师提供的例子之一 Echo Server（回显服务器，你发什么他回什么）来看一下效果：

建立服务端：

./echoserver_unittest

建立客户端：

nc 127.0.0.1 2000

可以看到，这是个回显服务器~

解剖

下一步，我们要了解这背后的原理，其大致由一下核心部分组成，我们用银行来举例子：

EventLoop：银行的大堂经理，用来唤醒柜台干活，一个银行有且仅有一个大堂经理
Poller：取号机，客户从这里取号，知道要去哪个柜台处理业务
Channel：处理具体事务这里需要说明的是，Channel 本身不处理事务，比方说客户要来存钱，Channel 只负责按下“存钱”按钮，至于按钮控制的是“存钱”还是发射核弹，Channel 一概不知
TcpConnection：这是负责把具体操作绑定到“按钮”上的人，Channel 把状态传过来之后，TcpConnection 只负责把“包裹”拿进来放到 InputBuffer 中，然后告诉 User 有你的包裹！放在 InputBuffer 了，接收时间是 xx！TcpConnection 仍然不知道这个包裹装的是什么，只管接收就好了。

此外，我们还需要了解主线程、子线程群：

主线程：银行总门口，只进行“迎宾”（Accept）操作，把客户领进门后直接分发到子银行
子线程群：负责具体业务的银行，也就是上面我们提到的这些业务

这样，我们就实现了完整的流程。下面，我们看一下每个核心的核心代码：

Eventloop

这段代码是 muduo 的绝对核心，所有的操作都是在这个死循环中进行的，是子线程群的业务逻辑。

void EventLoop::loop()
{
  assert(!looping_);
  assertInLoopThread();
  looping_ = true;
  quit_ = false;  // FIXME: what if someone calls quit() before loop() ?
  LOG_TRACE << "EventLoop " << this << " start looping";

  while (!quit_)
  {
    activeChannels_.clear();
    pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);
    ++iteration_;
    if (Logger::logLevel() <= Logger::TRACE)
    {
      printActiveChannels();
    }
    // TODO sort channel by priority
    eventHandling_ = true;
    for (Channel* channel : activeChannels_)
    {
      currentActiveChannel_ = channel;
      currentActiveChannel_->handleEvent(pollReturnTime_);
    }
    currentActiveChannel_ = NULL;
    eventHandling_ = false;
    doPendingFunctors();
  }

  LOG_TRACE << "EventLoop " << this << " stop looping";
  looping_ = false;
}

我们来拆解这段绝对核心：

1. 阻塞与等待（The wait）

pollReturnTime_ = poller_->poll(kPollTimeMs, &activeChannels_);

Eventloop 问：在最近 kPollTimeMs 这段时间，有哪些窗口有事儿要做？
假如没有事件，这个线程就会挂起，直到有“客户”再进行处理，而挂起的时候不占用 CPU
假如有事件，那么就会把需要进行业务的 Channels 收集到 activeChannels_ 中，再进行接下来的操作

2. 处理网络事件（The Action）

for (Channel* channel : activeChannels_)
    {
      currentActiveChannel_ = channel;
      currentActiveChannel_->handleEvent(pollReturnTime_);
    }

其实很简单吧！一下就能看懂，遍历每个有事件的窗口，每个窗口“按一下对应的按钮”就可以了

3. 处理“任务队列”（The Pending Tasks）

pending: 代办的

doPendingFunctors();

Eventpoll在等待客户（休眠状态），但是这个时候另外一个线程想让这个这个线程干点事情，如何调用Eventpoll？就用这个函数：外面的线程把任务塞到一个队列里，然后把Eventpoll叫醒，Eventpoll醒来之后，处理完网络事件，走到这里，就会把队列里的任务执行一遍

Channel

Channel 只用考虑这个业务的状态就可以了，而不用管这个业务是什么，这个具体业务由 TcpConnection 负责而这些状态是 Linux 中写死的东西，不会增不会减： POLLIN（可读）、POLLOUT（可写）、POLLHUP（挂断）、POLLERR（错误）

void Channel::handleEventWithGuard(Timestamp receiveTime)
{
  eventHandling_ = true;
  LOG_TRACE << reventsToString();
  if ((revents_ & POLLHUP) && !(revents_ & POLLIN))
  {
    if (logHup_)
    {
      LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLHUP";
    }
    if (closeCallback_) closeCallback_();
  }

  if (revents_ & POLLNVAL)
  {
    LOG_WARN << "fd = " << fd_ << " Channel::handle_event() POLLNVAL";
  }

  if (revents_ & (POLLERR | POLLNVAL))
  {
    if (errorCallback_) errorCallback_();
  }
  if (revents_ & (POLLIN | POLLPRI | POLLRDHUP))
  {
    if (readCallback_) readCallback_(receiveTime);
  }
  if (revents_ & POLLOUT)
  {
    if (writeCallback_) writeCallback_();
  }
  eventHandling_ = false;
}

Channel 要干的事情很无脑，就是个分类的活，在接到 Poller递过来的events 之后，去按对应的按钮就行了，至于具体的逻辑，我们留给 TcpConnection考虑

TcpConnection

TcpConnection::TcpConnection(EventLoop* loop,
                             const string& nameArg,
                             int sockfd,
                             const InetAddress& localAddr,
                             const InetAddress& peerAddr)
  : loop_(CHECK_NOTNULL(loop)),
    name_(nameArg),
    state_(kConnecting),
    reading_(true),
    socket_(new Socket(sockfd)),
    channel_(new Channel(loop, sockfd)),
    localAddr_(localAddr),
    peerAddr_(peerAddr),
    highWaterMark_(64*1024*1024)
{
  channel_->setReadCallback(
      std::bind(&TcpConnection::handleRead, this, _1));
  channel_->setWriteCallback(
      std::bind(&TcpConnection::handleWrite, this));
  channel_->setCloseCallback(
      std::bind(&TcpConnection::handleClose, this));
  channel_->setErrorCallback(
      std::bind(&TcpConnection::handleError, this));
  LOG_DEBUG << "TcpConnection::ctor[" <<  name_ << "] at " << this
            << " fd=" << sockfd;
  socket_->setKeepAlive(true);
}

我们拿出其中一条来看看是怎么干活的：

channel_->setReadCallback(
      std::bind(&TcpConnection::handleRead, this, _1));

bind 函数是用来写“委托书”的
handleRead 委托 handleRead 来干活！
this 我们还需要传一下调用者过去，告诉是哪个对象的 handleRead
_1 占位符，用来存储时间戳

其实就是告诉这个 TcpConnection 对象，假如我们有一个 read 请求发过来了，你就调用 handleRead 函数就好

接下来看看 handleRead 干了啥：

void TcpConnection::handleRead(Timestamp receiveTime)
{
  loop_->assertInLoopThread();
  int savedErrno = 0;
  ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno);
  if (n > 0)
  {
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }
  else if (n == 0)
  {
    handleClose();
  }
  else
  {
    errno = savedErrno;
    LOG_SYSERR << "TcpConnection::handleRead";
    handleError();
  }
}

首先，n：用来看我们这个“包裹”的字节数，当然有 >0, =0, <0 三种状态，对应三种不同的处理，我们来看 >0 的情况：

if (n > 0)
  {
    messageCallback_(shared_from_this(), &inputBuffer_, receiveTime);
  }

shared_from_this：连接数据本身，假如要回传数据就找这个对象
inputBuffer_：存满数据的包裹
receiveTime：包裹到达的时间至此，大致流程就很清晰了：
注册阶段：我在写某一个服务的，把 onMessage 这个函数（也就是 “callback”的对象）塞给了 TcpConnection
等待阶段：由 Eventloop 等待着客户
触发阶段：客户拿到号，找到对应的窗口（channel），Channel 触发信号，TcpConnection 开始 handleRead
回调阶段：TcpConnection “callback”了我留下的 onMessage，其实就是调用了我留给 TcpConnection 的代码可以看得出来，这是一个通用的网络库，我们只要传入不同的 callback，就能实现不同的功能

好了，我们基本上搞清楚这个业务逻辑了，最后来看看具体的业务onMessage 是怎么处理的，我们还是拿 EchoServer 来举例子：

void EchoServer::onMessage(const muduo::net::TcpConnectionPtr& conn,
                           muduo::net::Buffer* buf,
                           muduo::Timestamp time)
{
  muduo::string msg(buf->retrieveAllAsString());
  LOG_INFO << conn->name() << " echo " << msg.size() << " bytes, "
           << "data received at " << time.toString();
  conn->send(msg);
}

干了两件事：

  muduo::string msg(buf->retrieveAllAsString());

这里，我们把之前“包裹”里面的数据装到 msg 里面

conn->send(msg);

然后这不是个回显服务器吗，直接把数据发送回 Channel 就可以了，这里，Muduo 会启动 Channel 的 POLLOUT 写事件，等 socket 准备好了，EventLoop 会自动帮你发出去，而用户只管把没发送完的数据放到缓存区，就可以离开了。

串起来看看！

现在，让我们把时间轴动起来。假设一个客户端发来了 "Hello"。

第一幕：沉睡与唤醒 (Monitoring)

静默：EventLoop (经理) 正在休息（阻塞在 Poller::poll）。
到达：网线上传来电信号，操作系统把 "Hello" 放入了内核缓冲区。Socket (进货口) 的红灯亮了（Readable）。
感知：Poller (监控) 瞬间捕捉到红灯，立马把 EventLoop 摇醒：“经理！3号门有动静！”

第二幕：分发与搬运 (Dispatch & Read)

分发：EventLoop 醒来，找到负责3号门的 Channel (安保)，说：“去处理一下。”
回调：Channel 看到是“读事件”，立刻按下按钮，调用了 TcpConnection::handleRead。
搬运：TcpConnection (专员) 跑过来，手里拿着 Buffer (篮子)，调用 inputBuffer_.readFd()，把 "Hello" 从内核搬到了应用的内存里。

第三幕：决策与执行 (Business Logic)

上报：货搬完了，TcpConnection 拿出你一开始给它的“电话号码” (onMessage)，打了过去。
处理：你 (EchoServer) 接到电话。
- 你：“收到啥了？”
- 专员：“Hello”。
- 你：“行，给它转成大写，发回去。” (逻辑处理)
- 你调用 conn->send("HELLO")。

第四幕：发送与离场 (Send & Loop)

发送：TcpConnection 尝试直接把 "HELLO" 塞回 Socket。
- 如果一次塞完了，结束。
- 如果塞不完，就把剩下的暂存在 OutputBuffer，并让 Channel 关注“写事件”。
回归：一切处理完毕，EventLoop 看看表（更新时间），发现没别的事了，又回到 Poller 那里继续打盹，等待下一个信号。

从零开始自己造

前置知识：

protected/private

前者可以被子类访问，后者只能自己访问

static

用 static 修饰的函数，表示这个类可以直接调用，不用声明对象，比方说

Timestamp::now();

我们在类中使用 static const 来定义常量，比方说

static const int kNoneEvent;

const

放在函数定义后面，表示这个函数不会修改类中的任何数据
放在函数定义前面，修饰这个函数的返回值，表示这个返回值不可修改

explicit

用于修饰构造函数，防止编译器进行隐式类型转换，防止出现不必要的 bug 为了防止这种情况发生：

class Socket {
public:
    Socket(int fd) { /* ... */ } // 注意：这里没加 explicit
};

void checkSocket(Socket s) { /* ... */ }

int main() {
    // 编译器会悄悄把 10 转换成 Socket(10)
    // 这在语义上很奇怪：10 只是个数字，怎么就变成对象了？
    checkSocket(10); 
    
    // 甚至允许这种写法：
    Socket s = 20; 
}

类中的私有变量

比方说 Socket 类中的 sockfd_，我们习惯性地在私有变量后面加上 _

using

typedef 的现代化写法我们可以这样来新建一个类型：

using ChannelList = std::vector<Channel*>;

很好懂，意思是我们建立一个新的类型 ChannelList，这个类型实际上是一个 Channel 指针的 vector

继承

当 B 类是 A 类时，我们使用继承，比方说狗是动物，就可以狗继承动物

// 父类（基类）
class Animal {
public:
    void eat() { std::cout << "正在进食..." << std::endl; }
};

// 子类（派生类）继承自 Animal
class Dog : public Animal {
public:
    void bark() { std::cout << "汪汪叫！" << std::endl; }
};

有 public 继承、protected 继承、private 继承，主要改变的就是 public 和 protected 的访问权限

🌟我们可以在父类中设置虚函数，利用 virtual 关键字，可以在子类中重构父类的虚函数，使用 final 关键词可以阻止某个函数被继承

class Shape {
public:
    // 虚函数：允许子类重写
    virtual void draw() { std::cout << "画一个图形" << std::endl; }
    // 纯虚函数：该类变为“抽象类”，不能实例化，子类必须实现
    virtual void area() = 0; 
    
    // 核心点：虚析构函数（防止内存泄漏）
    virtual ~Shape() {} 
};

class Circle : public Shape {
public:
    // C++11 建议加上 override 明确表示重写
    void draw() override { std::cout << "画一个圆" << std::endl; }
    void area() override { /* 实现逻辑 */ }
};

static_cast<类型>

用来进行强制类型准换，用法：

double pi = 3.14159;
int num = static_cast<int>(pi); // 去掉小数部分，变为 3

接下来我们按照顺序来构建每个类：

Noncopyable 类

这个类是一个继承类，许多不可复制的类可以直接继承它

Noncopyable. h

#pragma once
/*
NonCopyable类
所有继承了这个类的类都无法被拷贝
*/
class NonCopyable
{
public:
    //删除拷贝构造函数
    NonCopyable(const NonCopyable&) = delete;
    //删除复制运算符
    NonCopyable& operator=(const NonCopyable&) = delete;

protected:
    NonCopyable() = default;
    ~NonCopyable() = default;
};

InetAddress 类

这个类的主要作用就是把底层繁琐的网络地址数据封装起来，屏蔽了复杂的字节序转换和结构体操作

在 Linux 底层，网络地址使用结构体来实现的（比方说 sockaddr_in 用于 ipv4），直接操作的话很麻烦，于是用 InetAddress 把它封装起来，极大简化了代码量

InetAddress.h

#pragma once

#include <arpa/inet.h>
#include <netinet/in.h>
#include <string>

class InetAddress
{
public:
    explicit InetAddress(uint16_t port, std::string ip = "127.0.0.1");

    explicit InetAddress(const struct sockaddr_in& addr)
        : addr_(addr)
    {}

    void setSockAddr(const struct sockaddr_in& addr) { addr_ = addr; }
    
    std::string toIp() const;

    std::string toIpPort() const;

    uint16_t toPort() const;

    const struct sockaddr_in* getSockAddr() const { return &addr_; }

private:
    struct sockaddr_in addr_;
};

InetAddress.cc

#include "InetAddress.h"
#include <strings.h>
#include <string.h>

InetAddress::InetAddress(uint16_t port, std::string ip)
{
    bzero(&addr_, sizeof addr_);

    addr_.sin_family = AF_INET;

    addr_.sin_port = htons(port);

    inet_pton(AF_INET, ip.c_str(), &addr_.sin_addr.s_addr);
}

std::string InetAddress::toIp() const
{
    char buf[64] = {0};
    ::inet_ntop(AF_INET, &addr_.sin_addr, buf, sizeof buf);
    return buf;
}

std::string InetAddress::toIpPort() const
{
    char buf[64] = {0};
    ::inet_ntop(AF_INET, &addr_.sin_addr, buf, sizeof buf);
    size_t end = strlen(buf);
    uint16_t port = ntohs(addr_.sin_port);
    sprintf(buf+end, ":%u", port);
    return buf;
}

uint16_t InetAddress::toPort() const
{
    return ntohs(addr_.sin_port);
}

这里稍微理解一下就行，以后当做底层工具来调用就好了

Timestamp 类

这个类也是用来封装底层复杂逻辑的类，用处就是获取时间戳

Timestamp.h

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

class Timestamp 
{
public:
    Timestamp();
    explicit Timestamp(int64_t microSecondsSinceEpoch);
    static Timestamp now();
    std::string toString() const;
    int64_t microSecondsSinceEpoch() const { return microSecondsSinceEpoch_;}

private:
    int64_t microSecondsSinceEpoch_;
};

Timestamp.cc

#include "Timestamp.h"
#include <time.h>

Timestamp::Timestamp() : microSecondsSinceEpoch_(0) {}

Timestamp::Timestamp(int64_t microSecondsSinceEpoch)
    : microSecondsSinceEpoch_(microSecondsSinceEpoch)
{}

Timestamp Timestamp::now()
{
    return Timestamp(time(NULL));
}

std::string Timestamp::toString() const
{
    char buf[128] = {0};
    time_t seconds = static_cast<time_t>(microSecondsSinceEpoch_);
    struct tm *tm_time = localtime(&seconds);
    snprintf(buf, sizeof(buf), "%4d/%02d/%02d %02d:%02d:%02d",
             tm_time->tm_year + 1900,
             tm_time->tm_mon + 1,
             tm_time->tm_mday,
             tm_time->tm_hour,
             tm_time->tm_min,
             tm_time->tm_sec);
    return buf;
}

同样是直接调用就好了，简化代码用的。

🌟Socket 类

[!note] socket 是什么？ socket（网络连接）是传输层和应用层之间的桥梁，把复杂的 TCP/IP 协议隐藏在 socket 接口后面。socket 相当于一个电话机，用来接发文件的

在 linux 中，“一切皆文件”，socket 也不例外，每个 socket 都和一个 fd（文件描述符，其实就是个 ID）一一对应

socket 的作用就是绑定 IP 地址、接发数据包

Socket. h

#pragma once

#include "NonCopyable.h"

class InetAddress;

class Socket : NonCopyable
{
public:
    explicit Socket(int sockfd)
        : sockfd_(sockfd)
    {}

    ~Socket();

    int fd() const { return sockfd_; }

    void bindAddress(const InetAddress& localaddr);

    void listen();

    int accept(InetAddress* peeraddr);

    void setReuseAddr(bool on);

private:
    const int sockfd_;
};

Socket.cc

#include "Socket.h"
#include "InetAddress.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/tcp.h>

Socket::~Socket()
{
    ::close(sockfd_);
}

void Socket::bindAddress(const InetAddress& localaddr)
{
    int ret = ::bind(sockfd_,
                    (const struct sockaddr*)localaddr.getSockAddr(),
                    sizeof(struct sockaddr_in));
    if(ret<0)
    {
        perror("bind sockfd error!");
    }
}

void Socket::listen()
{
    int ret = ::listen(sockfd_, 1024);
    if(ret<0)
    {
        perror("listen sockfd error!");
    }
}

int Socket::accept(InetAddress* peeraddr)
{
    struct sockaddr_in addr;
    socklen_t len = sizeof addr;

    int connfd = ::accept(sockfd_, (struct sockaddr*)&addr, &len);

    if(connfd >= 0)
    {
        peeraddr->setSockAddr(addr);
    }

    return connfd;
}

void Socket::setReuseAddr(bool on)
{
    int optval = on ? 1 : 0;
    ::setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval);
    
}

在这里我们就能看出 RAII（Resource Acquisition Is Initialization，资源获取即初始化）原则，将资源的生命周期与对象作绑定，对象死了资源自动释放，构造函数中请求资源，析构函数中释放资源（C++在函数结束、抛出异常等情况保证能调用析构函数），防止了内存泄漏，不用再手动管理资源了

这里面讲几个点：

Ip 地址

在 linux 内核中，用 strcut sockaddr 来存储地址，这是个通用接口，长这样：

struct sockaddr {
    unsigned short sa_family; // 地址族 (如 AF_INET 代表 IPv4)
    char sa_data[14];         // 包含 IP 和端口的原始数据（难以直接读写）
};

另外还有个便于程序员读写的、专为 IPv4 设计的 strcut sockaddr_in，长这样：

struct sockaddr_in {
    short            sin_family;   // 地址族 (固定为 AF_INET)
    unsigned short   sin_port;     // 16位端口号 (必须是网络字节序 htons)
    struct in_addr   sin_addr;     // 32位 IP 地址结构
    char             sin_zero[8];  // 填充位，为了和 sockaddr 长度保持一致
};

那么我们在设置 IP 的时候就这样：在 sockaddr_in 中设好参数，在强制类型转换成 sockaddr 供程序底层使用，也就有了这个代码：

void Socket::bindAddress(const InetAddress& localaddr)
{
    int ret = ::bind(sockfd_,
                    (const struct sockaddr*)localaddr.getSockAddr(),
                    sizeof(struct sockaddr_in));
    if(ret<0)
    {
        perror("bind sockfd error!");
    }
}

🌟Channel 类

每个 socket 都对应一个 Channel，Channel 选择监听哪些信息，但是 Channel 本身不负责监听，他只是列个表，然后由 Poller 监听 socket 是否传输了表中的内容。 Poller 监听到之后，再汇报给 EventLoop，EventLoop 拿到 activeChannels 清单，对照着清单一一唤醒Channels Channel 被唤醒之后，再去叫别的类去进行接下来的操作我们不直接拿 Channel 去监听 socket，因为这样的话，一万个 scoket 就对应一万个 Channel，每个 Channel 始终监视着 socket，会占用极大的内存我们用One Loop Per Thread（一个线程一个循环）原则，能让一个线程同时处理成千上万的链接

Channel.h

#pragma once

#include "NonCopyable.h"
#include <functional>
#include <memory>

class EventLoop;

class Channel : NonCopyable
{
public:
    using EventCallback = std::function<void()>;

    Channel(EventLoop* loop, int fd);
    ~Channel();

    void handleEvent();

    void setReadCallback(EventCallback cb) { readCallback_ = std::move(cb); }
    void setWriteCallback(EventCallback cb) { writeCallback_ = std::move(cb); }
    void setErrorCallback(EventCallback cb) { errorCallback_ = std::move(cb); }
    void setCloseCallback(EventCallback cb) { closeCallback_ = std::move(cb); }


    int index() { return index_; }
    void set_index(int idx) { index_ = idx; }

    int fd() const { return fd_; }
    //获取我要关注的事件都有哪些
    int events() const { return events_; }

    void set_revents(int revt) { revents_ = revt; }

    bool isNoneEvents() const { return events_ == kNoneEvent; }

    //自己更新，然后再让EventLoop去更新Poller
    void enableReading() { events_ |= kReadEvent; update(); }
    void disableReading() { events_ &= ~kReadEvent; update(); }
    void enableWriting() { events_ |= kWriteEvent; update(); }
    void disableWriting() { events_ &= ~kWriteEvent; update(); }
    void disableAll() { events_ = kNoneEvent; update(); }

    //你开启监听/写入了吗
    bool isWriting() const { return events_ & kWriteEvent; }
    bool isReading() const { return events_ & kReadEvent; }

private:
    void update();

    static const int kNoneEvent;
    static const int kReadEvent;
    static const int kWriteEvent;

    EventLoop* loop_;
    const int fd_;

    int events_;
    int revents_;

    //表示channel在Poller中的状态
    int index_;

    EventCallback readCallback_;
    EventCallback writeCallback_;
    EventCallback errorCallback_;
    EventCallback closeCallback_;
};

Channel.cc

#include "Channel.h"
#include "EventLoop.h"
#include <sys/epoll.h>
#include <iostream>

const int Channel::kNoneEvent = 0;
const int Channel::kReadEvent = EPOLLIN | EPOLLPRI;
const int Channel::kWriteEvent = EPOLLOUT;

Channel::Channel(EventLoop* loop, int fd)
    : loop_(loop),
      fd_(fd),
      events_(0),
      revents_(0),
      index_(-1)
{}

Channel::~Channel()
{

}

void Channel::update()
{
    loop_->updateChannel(this);

    std::cout<<"Channel updated: fd="<< fd_ << " events="<<events_<<std::endl;

}

void Channel::handleEvent()
{
    std::cout << "Channel::handleEvent revents: " << revents_ << std::endl;

    if((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN)) 
    {
        if(closeCallback_) closeCallback_();
    }

    if(revents_ & EPOLLERR) 
    {
        if(errorCallback_) errorCallback_();
    }

    if(revents_ & (EPOLLIN | EPOLLPRI)) 
    {
        if(readCallback_) readCallback_();
    }

    if(revents_ & EPOLLOUT)
    {
        if(writeCallback_) writeCallback_();
    }

}

可以看出，Channel 的作用就是设置自己需要响应的事件、响应事件 讲几个点：

kReadEvent

其中 k 是 const 的缩写，代码中是这么定义的：

const int Channel::kNoneEvent = 0;

const int Channel::kReadEvent = EPOLLIN | EPOLLPRI;

const int Channel::kWriteEvent = EPOLLOUT;

这其实相当于 01 开关，通过位运算来控制我们监听的事件，这么用：

	void enableReading() { events_ |= kReadEvent; update(); }

    void disableReading() { events &= ~kReadEvent; update(); }

    void enableWriting() { events_ |= kWriteEvent; update(); }

    void disableWriting() { events_ &= ~kWriteEvent; update(); }

    void disableAll() { events_ = kNoneEvent; update(); }

这样来添加或者删减 Channel 监听的类型

update ()

其实只需要明确一点就明白了： Channel 的 events 是自己想要监听的内容，但是需要把这个内容发给 Poller，由他来监听，自然需要 update 一下了

🌟Poller 类、EpollPoller 类

Poller 提供接口，EpollPoller 提供底层逻辑

用处：

轮询（epoll_wait），直到有活动 channel，抓取到 activeChannels 列表，把当前事件传给每个 channel 的 revents_；唤醒 EventLoop，EventLoop 去让列表中的 channels 去 handleEvent()
维护 epoll 红黑树，其中维护的是 channel 的 fd、指针、愿望清单

Poller.h

#pragma once

#include "NonCopyable.h"
#include <vector>
#include <unordered_map>

class Channel;
class EventLoop;

class Poller : NonCopyable
{
public:
    using ChannelList = std::vector<Channel*>;

    Poller(EventLoop* loop);
    virtual ~Poller();

    //不停轮询，寻找active的channel
    virtual void poll(int timeoutMs, ChannelList* activeChannel) = 0;

    //更新channel的愿望清单
    virtual void updateChannel(Channel* channel) = 0;

    //移除channel
    virtual void removeChannel(Channel* channel) = 0;

    //有没有这个Channel
    bool hasChannel(Channel* channel) const;

    static Poller* newDefaultPoller(EventLoop* loop);

protected:
    //维护Poller的监听channel都有哪些
    //channel的fd和channel本身指针作对应
    using ChannelMap = std::unordered_map<int, Channel*>;
    ChannelMap channels_;//由Poller负责

private:
    EventLoop* loop_;
};
/*
Poller:
1、维护监听的channel列表
2、轮询，看哪些channel active了
*/

Poller.cc

#include "Poller.h"
#include "EpollPoller.h"
#include "Channel.h"

Poller::Poller(EventLoop* loop)
    : loop_(loop)
{}

Poller::~Poller() = default;

bool Poller::hasChannel(Channel* channel) const
{
    auto it = channels_.find(channel->fd());
    return it != channels_.end() && it->second == channel;
}

Poller* Poller::newDefaultPoller(EventLoop* loop)
{
    return new EpollPoller(loop);
}

EpollPoller.h

#pragma once

#include "Poller.h"
#include <vector>
#include <sys/epoll.h>

class EpollPoller : public Poller
{
public:
    EpollPoller(EventLoop* loop);
    ~EpollPoller() override;

    void poll(int timeoutMs, ChannelList* activeChannels) override;
    void updateChannel(Channel* channel) override;
    void removeChannel(Channel* channel) override;

private:
    //填activeChannels
    void fillActiveChannel(int numEvents, ChannelList* activeChannels) const;
    //具体的在epoll中更新channel愿望清单的方式
    void update(int operation, Channel* channel);

    int epollfd_;

    //即将发生事件的列表
    using EventList = std::vector<struct epoll_event>;
    EventList events_;

    //Channel在Poller中的状态
    static const int kNew;//没有在红黑树注册过
    static const int kAdded;//注册了，且在工作
    static const int kDeleted;//注册了，但是没有在工作
};

/*
EpollPoller：
使用epoll进行活跃channel的维护
1、维护channel在epoll中的状态
2、找到活跃的channel
*/

EpollPoller.cc

#include "EpollPoller.h"
#include "Channel.h"
#include <iostream>
#include <unistd.h>
#include <string.h>

const int EpollPoller::kNew = -1;
const int EpollPoller::kAdded = 1;
const int EpollPoller::kDeleted = 2;

/*
epoll是socket管理器，用的是红黑树
每一个节点存了一份详细的监听清单，对应一个socket
节点中有：
1、节点信息，包含父子节点指针以及颜色(struct rb_node rbn)
2、socket的fd以及对应的指针(struct epoll_filefd ffd)
3、关注的事件，存用户关注的事件(struct epoll_event event)
4、就绪链表指针，socket活跃时就把这个指针挂载到就绪链表中(struct list_head rdllink)
5、等待队列项，这里面设置了回调函数，用来触发挂载到活跃链表的操作 (wait_queue_t pwq)
6、容器引用，指向节点所属的epoll实例 (struct eventpoll *ep)
*/

EpollPoller::EpollPoller(EventLoop* loop)
    : Poller(loop),
      epollfd_(::epoll_create1(EPOLL_CLOEXEC)),
      events_(16)
{
    if(epollfd_ < 0)
    {
        perror("epoll_create1 error");
    }
}


EpollPoller::~EpollPoller()
{
    ::close(epollfd_);
}

//轮询的逻辑
void EpollPoller::poll(int timeoutMs, ChannelList* activeChannels)
{
    //把epoll中的活跃socket填到events_，再返回活跃数量
    //events_是using EventList = std::vector<struct epoll_event>类型的
    int numEvents = ::epoll_wait(epollfd_,
                                 &*events_.begin(),
                                 static_cast<int>(events_.size()),
                                 timeoutMs);
    
    int saveErrno = errno;

    if(numEvents>0)
    {
        fillActiveChannel(numEvents, activeChannels);

        //已经把这个events_列表填满了
        if(numEvents == static_cast<int>(events_.size()))
        {
            events_.resize(events_.size()*2);
        }
    }
    else if(numEvents==0)
    {
        std::cout << "nothing happened" << std::endl;
    }
    else 
    {
        //假如不是interrupt（自行暂停），那就是真出错了
        if(saveErrno != EINTR)
        {
            perror("EpollPoller::poll Error!");
        }
    }
}

//填充activeChannels，这些channels活跃了，要处理事件了
void EpollPoller::fillActiveChannel(int numEvents, ChannelList* activeChannels) const
{
    for(int i=0;i<numEvents;i++)
    {
        Channel* channel = static_cast<Channel*>(events_[i].data.ptr);

        channel->set_revents(events_[i].events);

        activeChannels->push_back(channel);
    }
}

//把channel的清单更新同步到内核中（channel活跃了）
void EpollPoller::updateChannel(Channel* channel)
{
    //看看状态是啥，怎么更新
    const int index = channel->index();

    if(index==kNew||index==kDeleted)//epoll里没有这个channel，加进来
    {
        if(index==kNew)
        {
            int fd = channel->fd();
            channels_[fd] = channel;
        }

        channel->set_index(kAdded);
        update(EPOLL_CTL_ADD, channel);
    }
    else//kAdded，有了，更新一下清单
    {
        if(channel->isNoneEvents())
        {
            update(EPOLL_CTL_DEL,channel);
            channel->set_index(kDeleted);
        }
        else 
        {
            update(EPOLL_CTL_MOD, channel);
        }
    }
}

void EpollPoller::removeChannel(Channel* channel)
{
    int fd = channel->fd();
    channels_.erase(fd);

    int index = channel->index();
    if(index == kAdded)
    {
        update(EPOLL_CTL_DEL, channel);
    }
    //Channel被移除了，直接注销了
    channel->set_index(kNew);
}

//具体怎么更新？
void EpollPoller::update(int operation, Channel* channel)
{
    //组装事件包
    struct epoll_event event;
    bzero(&event, sizeof event);

    event.events = channel->events();
    event.data.ptr = channel;

    int fd = channel->fd();
    //把愿望清单发给内核
    if (::epoll_ctl(epollfd_, operation, fd, &event) < 0)
    {
        perror("epoll_ctl error");
    }

}

🌟EventLoop 类

这个类主要起到命令别的类的作用，操控者程序的主循环。被 Poller 唤醒，再让 Channel 处理事件；Channel 让 EventLoop 更新 Channel 自己的愿望清单，EventLoop 让 Poller 更新愿望清单

EventLoop.h

#pragma once

#include <vector>
#include <atomic>
#include <memory>

#include "NonCopyable.h"
#include "Timestamp.h"
#include "CurrentThread.h"

class Channel;
class Poller;

class EventLoop : NonCopyable
{
public:
    using ChannelList = std::vector<Channel*>;

    EventLoop();
    ~EventLoop();

    void loop();

    void quit();

    void updateChannel(Channel* channel);
    void removeChannel(Channel* channel);
    bool hasChannel(Channel* channel);

    bool isInLoopThread() const;

private:
    void abortNotInLoopthread();

    std::atomic_bool looping_;
    std::atomic_bool quit_;

    const pid_t threadId_;

    std::unique_ptr<Poller> poller_;
    ChannelList activeChannels_;
};

EventLoop.cc

#include "EventLoop.h"
#include "Poller.h"
#include "Channel.h"
#include "CurrentThread.h"
#include <iostream>

__thread EventLoop* t_loopInThisThread = nullptr;

const int kPollTimeMs = 100000;
EventLoop::EventLoop()
    : looping_(false),
     quit_(false),
     threadId_(CurrentThread::tid()),
     poller_(Poller::newDefaultPoller(this))
{
    std::cout << "EventLoop created " << this << " in thread " << threadId_ << std::endl;

    if(t_loopInThisThread)
    {
        std::cerr << "Another EventLoop " << t_loopInThisThread 
                  << " exists in this thread " << threadId_ << std::endl;
        exit(1); // 严禁一个线程搞两个 Loop
    }
    else 
    {
        t_loopInThisThread = this;
    }
}

EventLoop::~EventLoop()
{
    looping_ = false;
    t_loopInThisThread = nullptr;
}

void EventLoop::loop()
{
    looping_ = true;
    quit_ = false;

    std::cout << "EventLoop " << this << " start looping" << std::endl;

    while(!quit_)
    {
        activeChannels_.clear();

        poller_->poll(kPollTimeMs,&activeChannels_);

        for(Channel* channel : activeChannels_)
        {
            channel->handleEvent();
        }
    }

    std::cout << "EventLoop " << this << " stop looping" << std::endl;
    looping_=false;
}

void EventLoop::quit()
{
    quit_=true;
}

void EventLoop::updateChannel(Channel* channel)
{
    if(isInLoopThread())
    {
        poller_->updateChannel(channel);
    }
    else 
    {
        std::cerr << "EventLoop::updateChannel called from different thread!" << std::endl;
    }
}

void EventLoop::removeChannel(Channel* channel)
{
    if(isInLoopThread())
    {
        poller_->removeChannel(channel);
    }
}

bool EventLoop::hasChannel(Channel* channel)
{
    return poller_->hasChannel(channel);
}

bool EventLoop::isInLoopThread() const
{
    return threadId_ == CurrentThread::tid();
}

整体流程图：

记录倒腾服务器的全过程

Mon, 08 Dec 2025 10:20:49 GMT

这几天看到阿里云的新人优惠活动，38 块钱一年！果断下单！

但是：

在倒腾服务器之前，我得先解决我的一个痛点——博客图片我的博客是放在 github 上，通过 vercel 部署的，其中的包含的图片也一并上传到了 github，这必然会拖慢我的 git 速度，也会导致很多人看我的博客加载不出图片来！

我用阿里云 OSS（对象存储）完美解决了这个痛点，OSS 采用键值对的方式存储数据，1 次存 N 次取，而且量大管饱还便宜，一年一杯奶茶钱！因此，OSS 非常适合用来做图床

[!note] 提醒！由于通过外网访问 OSS 资源需要产生流量资费（0.15 元/G），所以建议先在账户中留一些钱，按照 pay as you go 来扣费

当然由此会衍生出一个痛点：每次都要执行上传到图床-复制链接-写Markdown，步骤变得繁琐了，为了解决这个问题，我找到了 picList 这个开源软件再配合插件，就可以无感使用图床来放图片啦！

另外关于博客是放在 vercel 部署还是放在服务器，我最后的选择还是 vercel，vercel 能免费部署、自带全球 DNS 加速，SSL 证书自动续期，而且极其稳定，能保证至少在未来几年内能保证访问

好了，接下来就正式开始倒腾服务器啦：

这次试试 Termius 这个终端如何

界面确实要清爽漂亮很多，目前用下来没什么大问题

上次建站使用的是宝塔，这次用 1Panel 看看效果如何

首先安装一个 alist 试试水：在这过程中就遇到不少问题：

镜像无法拉取： 需要去阿里云的官网找加速镜像地址进行加速
无法通过端口访问： 需要开放阿里云的防火墙、1Panel 的防火墙，这两者相当于保安大门和家里的大门，缺一不可，能有效避免被爬虫被扫
明明安装了 docker，为什么在命令行中还是提示找不到？ 因为 1Panel 给这些终端的命名逻辑是 1Panel-alist-XXXX，所以需要先去找一下名字，再做对应指令，或者直接使用 1Panel 中的终端会更方便一些
明明在 cf 设置了 DNS 解析，为什么还是不能通过域名+端口访问？ 问题就出在 cf 的代理上，小橙云只允许几个标准端口通过（比如 443、80），遇到 5244 自然通过不了，我们可以通过关闭代理、或者使用反向代理来解决，这里我选择用反向代理。

[!note] DNS？反向代理？ DNS 解析用来告诉浏览器，遇到这个域名要去对应的 IP 找！浏览器拿着这个域名找到服务器，服务器看了看反向代理，发现是找 alist.arronhc.cyou 的，于是就把内部的 127.0.0.1:5244 发送给浏览器

[!danger] 注意注意！解析到阿里云的云服务器的域名需要先备案！过程比较繁琐，要留足时间... 在验证过程中需要取消 DNS 解析，建议备案后再设置解析

【转载】华为手机安装GMS最终教程

Thu, 20 Nov 2025 13:26:16 GMT

华为设备 microG 安装教程（鸿蒙 4.2 / EMUI 13.2+）

因为华为手机现在很难安装原生谷歌框架，microG 这一替代方案 已逐渐被大众接受。
本教程会长期更新，同步 microG 的开发进度，持续优化教程内容。

本教程主要解决：

华为手机无法使用海外应用
无法安装谷歌全家桶
无法使用依赖 GMS 服务的软件

🔍 microG 是什么？

microG 是 Google 专有库的自由、开源实现，
由德国开发者 Marvi…（原文略）开发。

本教程支持 纯手机操作，无需电脑。

✅ 支持设备范围

鸿蒙 4.2 版本
EMUI 13.2 版本及以上

⚠️ 只要您的设备符合上述条件，
无论平板或手机都可以使用本方法安装。

❌ 非华为手机或平板：
一律不要尝试本教程，不适用。

🚨 声明与版权

本教程 全网首发 于 Alan's Blog
任何形式的 转载 / 扩散 / 复制 / 下载
必须注明原文链接，以尊重原创作者
本教程内容 完全免费
严禁任何形式的 收费行为
请广大网友提高警惕，谨防上当受骗

📊 功能对比表（更新时间：2025-07-25）

| 功能 / 方法 | 原生谷歌三件套 | microG + Play 商店 / 第三方商店 | | ----------------------------- | ---------------------------------------- | ------------------------------------------- | | 解决认证弹窗 | 🟢 | 🟢 | | 正常使用 GMS 应用 | 🟢 | 🟢 | | 应用分身 | 🟢 | 🟢 | | ChatGPT | 🟢 | 🟡 暂时不稳定，但能用 | | 更新系统 | 🟢 能用就别更新* | 🟢 | | 稳定程度 | 🟢 | 🟢 | | Google Play 商店 | 🟢 | 🟢 Play 商店 / 第三方商店 | | Google Play 服务 | 🟢 原生服务 | 🟢 microG 代替* | | 玩谷歌游戏 | 🟢 少部分不支持 | 🟢 部分不支持 | | 消息后台推送 | 🟢 FCM 推送*（支持国内直连） | 🟢 GCM 云端推送（不支持国内直连） | | 应用内购 | 🟢 4.3 不支持* | 🟢 部分不支持、4.3 不支持* | | 继续添加谷歌账号 | ⛔️ | 🟢 | | 登录提示验证 | 🟢 | 🟢 | | 谷歌 Passkey 密码填充 | 🟢 | ⛔️ | | 附近分享 | 🟢 | ⛔️ | | Google location services | ⛔️ | 🟢 | | 设备定位 | ⛔️ | 🟢 部分应用不精准，地图精准 | | 谷歌企业服务 | ⛔️ | ⛔️ | | Google Pay | ⛔️ | ⛔️ | | 支持型号？ | 仅手机（国行版）且 4.2 及以下 | 手机、平板且系统 4.2 及以上 |

注：🟢 全支持、🟡 不稳定、⛔️ 不支持、❔ 未测试

ℹ️ 重要说明与补充

microG 并不是所有原生功能都支持，原生框架体验整体优于 microG。
如果你的平板 / 手机是 2019 年之前，且是老麒麟芯片，可以直接安装谷歌三件套，获得原生 GMS 体验。

关于消息推送（非常重要）

消息推送是一个非常重要的功能，例如使用：

WeChat
WhatsApp
Telegram

如果应用不在后台运行，就不会有消息通知。
锁屏或清理后台后，很容易错过消息。

为了解决这个问题：

谷歌通过 GMS 在后台常驻
华为通过 HMS 在后台常驻

它们作为中间服务器：

收到消息
再拉起对应应用

这样既不会错过重要信息，又能降低电量消耗。

📥 下载链接

不知道怎么下载？继续往下看安装教程，会有提示。

MicroG相关安装包以及备份文件

✅ 安装教程总览

无论之前装过本教程还是其他教程，
准备工作和清理一定要做好。

⚠️ 注意：本教程需要电脑辅助
如果没有电脑，无法使用最新版 Google 服务。

Tips：

应用分身记得关闭

微信建议用电脑登录备份，后续可迁移回来

0. 安装前准备

如果你不能访问谷歌，请先解决网络问题，否则不要继续。

在系统中做以下设置：

关闭悬浮导航
- 设置 → 系统和更新 → 系统导航方式 → 更多 → 悬浮导航：关闭
关闭纯净模式增强防护
- 设置 → 系统和更新 → 纯净模式：关闭增强防护
关闭隐私空间
- 设置 → 隐私 → 隐私空间：右上角关闭隐私空间
关闭应用分身
- 设置 → 应用和服务 → 应用分身：关闭
关闭省电模式
- 设置 → 电池 → 省电模式：关闭

以上功能在安装完成后都可以重新开启。

1. 清除谷歌应用数据 / 卸载相关组件

需要清除 / 卸载以下应用：

Google Play 商店
Google 通讯录同步
Google Play 服务
Google 服务框架
Google 账户管理程序
com.google.android.gms.policy_sidecar_aps
SharedLibrary（就是这个名字，其他不用管）
谷歌服务助手
microG（只要名字中包含 microg 的都卸载）

操作路径：

方式一：系统应用管理
- 设置 → 应用和服务 → 应用管理
- 右上角「三个点」→ 勾选「显示系统程序」
- 搜索上述应用 → 清除数据或卸载（为所有用户卸载）
方式二：通过应用市场
- 打开「应用市场」→ 我的 → 卸载管理
- 搜索以上软件 → 有则卸载（为所有用户卸载）

2. 激活谷歌服务助手（仅手机操作，平板忽略）

2.1 下载并导入备份

下载下方的 backup 压缩包（解压后放到 Huawei 目录）：

backup文件
解压后，将 Backup 文件夹 复制到：

内部存储根目录 / Huawei / Backup

建议先删除原来的 Backup 文件夹，再复制新的进去。

⚠️ 常见错误：

复制错位置（必须是 内部存储根目录 下的 Huawei 文件夹）
若没有 Huawei 文件夹，可手动创建一个

2.2 修改系统日期到 2019 年

路径：

设置 → 系统和更新 → 日期和时间
关闭「自动设置」
手动将日期改为 2019 年

2.3 从内部存储恢复备份

路径：

设置 → 系统和更新 → 备份和恢复
- 如果没有此项：
  - 打开应用市场 → 搜索「备份」→ 下载并安装官方备份应用
打开「备份与恢复」：
- 点击右上角四个点 → 选择「从内部存储恢复」
- 选择 toalan.com 备份
- 输入密码：a12345678
- 执行恢复

如果没有「从内部存储恢复」选项：

可以先点「从外部存储」，把权限全部打开

返回再进入「备份和恢复」，检查是否出现

仍然没有，则说明 Backup 目录导入不成功（请回到 0 步检查路径）

2.4 激活谷歌服务助手

恢复完成后，先把时间调回正常：
- 设置 → 系统和更新 → 日期和时间 → 打开「自动设置」
在桌面找到 谷歌服务助手 并打开：
- 点击「激活」
- 授权所有需要的权限

⚠️ 提示说明：

若提示：当前设备不支持 → 基本无解，可以放弃
若提示：网络连接异常 → 表示仍有希望
- 需要通过 ADB 降级「备份和恢复」版本，具体教程参考原站说明

激活后 不需要 点击「开始下载」，直接返回桌面即可。

3. 安装下载好的软件（核心三件）

平板和手机安装包不完全相同，请仔细看文件名。

为减少维护，文章中不再写版本号后缀，
实际文件名中会带有版本后缀，例如：

文章写：com.google.android.gms
文件实际为：com.google.android.gms-250932018-hw.apk

必装的 3 个 APK（缺一不可）

Google Play Store（Play 商店）
com. google. android. gms（microG 服务）
com. google. android. gsf-8（microG 框架）

如果系统版本过低或为非国行手机，
通常会在文件夹中提供其他版本可供选择。

4. 授予 microG 权限

打开：设置 → 应用和服务 → 应用管理
搜索：microG 服务
打开应用 → 权限
将所有权限全部允许，确保全部打勾 ✅

特别注意：

定位权限必须为：始终允许
否则无法实现精准定位

5. 检测 microG 是否支持

打开 microG 设置界面：
- 在 microG 中点击右上角齿轮 ⚙️
点击最上方的「自我检查」
检查每一项是否全部 ✔️

🚨 如果全部通过，可以继续下一步。
若有未通过项，请根据提示逐项排查。

7. 登录谷歌账号

返回 microG 设置
点击「Google 账号」
选择「添加 Google 账号」
登录自己的谷歌账号

8. 使用 Play 商店或第三方商店

手机：
直接使用 Play 商店
- 若打开报错，可先清理后台，再重新进入应用
平板：
推荐使用第三方应用商店，例如：
- Aurora 最新版
- uptodown
- GBox 虚拟 Play 商店（可在其中的 Play 商店下载原生应用）
- APKPure

9. ChatGPT 怎么用？

建议通过 Aurora 或 uptodown 获取 ChatGPT。

步骤一：安装 Chrome 浏览器

安装 Chrome（一般会装两次，第一次是依赖库）
打开设置 → 搜索「默认应用」
将默认浏览器设置为：Chrome

教程提供了最新版 Chrome 安装包，在「其他 APP」文件夹里。

步骤二：安装 ChatGPT

在第三方应用商店中搜索并安装 ChatGPT

使用 ChatGPT 时的一些小知识

香港节点通常无法使用 ChatGPT（DNS 解锁除外）
即使使用其他地区节点，也不一定能解锁 APP：
- 有可能只解锁了网页版，并不支持 APP
请尽量确保：
- 使用 非香港地区 节点
- 该节点是 完整解锁 的

常见情况：

打开 ChatGPT 提示错误：
- 可以点击「注销」，再重新登录
加载时间较长：
- 属正常现象，耐心等待即可
无法进入：
- 可多试几次，或更换节点

🎉 教程结束 & 致谢

🎉🎉🎉 至此，本教程全部步骤结束！

研究技术和整理图文教程非常耗费时间与精力——
如果本教程对你有所帮助：

欢迎真金白银支持一下（原文底部通常会有打赏按钮）
白嫖也完全没问题，但推荐你：
- 评论分享你的 成功时间
- 标注 设备型号 + 系统版本

如果你有任何优化建议：

非常欢迎在评论区提出
你的每一次互动，都可以帮助后来者获得更好的教程体验

✨ 常见问题（FAQ）

1. 可以使用 Google 钱包和 Android Auto / Auto Car 吗？

❌ 不可以。

2. 手机上可以用 Play 商店替代第三方商店吗？

✅ 可以。

具体做法：

卸载 microG Companion
安装 Google Play 商店
- Play 商店版本可以从类似 Google Play Store 44.1.17 的资源中获取
如果 Play 商店打开闪退：
- 很可能是 谷歌服务助手没有激活
- 请重新检查激活步骤（参考手机相关教程）

之后你可以：

安装 Chrome 和 ChatGPT 即可正常使用
并可尝试把 Play 商店设置为「手动管理」，
因为 ChatGPT 依赖于 Play 商店的后台运行

高统期末复习

Wed, 19 Nov 2025 14:59:14 GMT

一些常见术语的解释

方差

$$ E(\sum_{i=1}^n(X-\mu)^2) $$

对于根据训练数据集训练出的模型，其方差越大，对于训练集的微小变化就越敏感，泛化能力越弱
方差体现的是所设定模型自身的性质（对训练集数据的敏感性）
自由度越高的模型其方差越高，偏差越小

残差平方和 RSS (Residual Sum of Squares)

$$ \sum_{i=1}^n (y_i - \hat{y}_i)^2 $$ 用来衡量误差的指标

最小二乘法

通过寻找最小的 RSS，寻找拟合度最高的线

均方误差 MSE (mean squared error)

对于数据集 Tr： $$ MSE_{T_r}=Ave_{i∈{T_r}}[y_i-\hat{f}(x_i)]=\frac{RSS}{n} $$ 是回归中最常用的评价准则

[!note] 为什么不用 RSS？因为数据集越大，RSS 就会越大，不能跨数据集，相比之下 MSE 更直观、不用考虑数据集大小

方差 vs 偏差

偏差是不可消除的，体现的是“假设”的模型与“真实”模型之间的本质差异
方差越大，说明我们拟合的模型对输入数据越敏感，细微的变化就会得到不同的拟合输出结果
模型太简单 → 高偏差、低方差 → 拟合不够
模型太复杂 → 低偏差、高方差 → 过拟合所以平衡偏差/误差就是一个重要问题

标准误差 SE (Standard Error)

估计量的标准差，表示这个估计在重复抽样时会晃动的多厉害
实际上也就是重复抽样得到的每次结果的标准差
标准误差越小，说明估计的“抖动”越小，越精准 $$ SE=\frac{s}{\sqrt{n}} $$

残差标准误差 RSE (Residual Standard Error)

在线性回归中： $$ y=X\beta+\epsilon,\epsilon\sim N(0,\sigma^2) $$ RSE 是对误差项标准差 $\sigma$ 的估计： $$ RSE=\hat{\sigma}=\sqrt{\frac{RSS}{df}}=\sqrt{\frac{RSS}{n-p-1}} $$ 其中 p+1 是参数个数（含截距） RSE 统计的是误差项的标准差 $\sigma$，体现的是模型的整体噪声大小

[!note]

标准差（SD）反应的是数据的波动程度，是方差开根号的结果

标准误差（SE）是在数据中随机抽 n 个样本，n 个样本的估计量的标准差，反应的是估计的稳定程度

残差是估计值与实际值的差值

残差标准误差（RSE）是对误差项 $\epsilon$ 标准差（SD）的估计总结：

标准差(SD)：数据的乱度

标准误差(SE)：估计的晃动程度

残差标准误差(RSE)：回归模型噪声的典型大小

t 统计量

$$ t=\frac{\bar{X}-\mu_0}{SE} $$ 比较样本均值与总体均值的差异

t 值（判断H0 假设，绝对值越大，假设越不成立）

线性回归中，我们要判断某一个系数究竟是不是 0（有没有关系），常采用零假设 $H_0$，而 t 值就是用来判断这个假设检验的。公式： $$ t_j=\frac{\hat{\beta}j-\beta{j,0}}{SE(\hat{\beta}_j)} $$ 其中： $\hat{\beta}j$ 表示估计值 $\beta{j, 0}$ 表示在 $H_0$ 假设下的系数值（通常为 0）

那么 t 值的含义实际上就是看看我这个估计值距离零假设的位置有几个标准误差的距离

[!note] 绝对值越大，认为系数越不可能为 0

p 值

假如某个系数真的按 $H_0$ 这样等于 0，那么出现这组数据的概率有多大？

p 很小：$H_0$ 不对
p 不小：不拒绝 $H_0$

F 统计量

$H_0$ 变成所有自变量都没用，用来一次性检验整体是否显著

[!note] p 值越小，证明参数越显著，系数越不可能为 0

t 分布

假如零假设真的成立，那么 t 统计量应当服从 t 分布我们可以用他计算 p 值，查临界值，做显著性检验，画置信区间

$R^2$ 统计量

公式： $$ R^2=\frac{TSS-RSS}{TSS}=1-\frac{RSS}{TSS} $$ 其中总平方和 TSS（Total Sum of Squares） : $$ TSS=\Sigma(y_i-\bar{y}) $$

TSS 表示的是原数据的变异性
RSS 表示的是回归后仍无法解释的变异性那么无法解释的变异性占比越小，证明回归的越好

[!note] $R^2$ 越接近 1，回归效果越好

调整 $R^2$

$R^2$ 的缺点就是，假如我们引入一个无关变量，就算这个变量对响应变量无关，但是由于自由度增加，相应的残差平方和 RSS 会降低，$R^2$ 会增大。

因此引入调整 $R^2$ $$ R_{adj}^2=1-(\frac{(1-R^2)\cdot(n-1)}{n-p-1}) $$

95%置信区间

公式： $$ 估计值±2\cdot SE(估计值) $$ 表示在这个区间内，有 95%的可能性包含真实值区间越窄，参数估得越准

预测区间

未来一个具体的 y（新样本）会落在哪里预测区间一定比置信区间宽，因为要考虑两个因素：

回归模型的准确性
未来 y 的变异性（存在 $\epsilon$ 的波动）

线性回归的假设

可加性：预测变量 $x_j$ 的变化对相应变量 $Y$ 产生的影响与其他预测变量的取值无关
线性：无论 $x_j$ 取什么值，$x_j$ 变化一个单位引起相应变量的变化是恒定的
误差项不相关

学生化残差

公式： $$ \frac{e_i}{RSE} $$

离群点

离群点是指对于给定的预测值 $x_i$ 来说，$y_i$ 远离模型预测点的点

离群点通常对最小二乘拟合几乎没有影响
会影响 RSE、置信区间、p 值、$R^2$ 判断离群点：
绘制学生化残差图，学生化残差大于 3 的观测点可能是离群点

[!note] x 正常，y 很怪

高杠杆点

通过计算杠杆统计量，来量化杠杆作用公式： $$ h_i=\frac{1}{n}+\frac{(x_i-\bar{x})^2}{\Sigma_{i'=1}^n(x_{i'}-\bar{x})^2} $$

$h_i$ 的取值在 1/n 到 1 之间，所有观测的平均杠杆值总是等于 $\frac{p+1}{n}$，假如平均值远大于这个值，怀疑这个点具有较高的杠杆作用

[!note] x 脱离大部队

误差项自相关

常出现在时序序列数据，也就是说昨天的误差会影响今天的误差，出现跟踪现象

共线性

预测变量之间高度相关解决方案：

从回归中剔除一个问题变量
把共线性的变量们组成一个单一的预测变量

K 最近邻法（KNN）

现在有一堆带标签的数据 ($x_i$，$y_i$)，现在要预测一个新样本 $x_{new}$ 的值 $y_{new}$，KNN 这么做：

在训练样本中，找出离 $x_{new}$ 最近的 K 个点
把它们的 y 值取出来，做平均或者加权平均，这个结果作为 $y_{new}$ 的值

如何选择 K？

小的 K 值提供了更灵活的拟合，导致低偏差和高方差
大的 K 值自由度更低，比较稳定，方差较小，但可能会隐藏 f（X）的部分结构导致偏差

[!warning] 存在维度灾难的问题，即在高维环境中找不到邻居所以我们优先选择线性回归，即使在低维问题，因为这虽然会损失精度，但是模型简单，p 值清晰，可解释性强

逻辑斯蒂回归

$$ p(X)=\frac{e^{\beta_0+\beta_1X}}{1+e^{\beta_0+\beta_1X}} $$ 其范围在 0~1 之间，将分类问题转换为了概率建模的回归问题我们采用最大似然方法估计系数，即求可以最大化某个式子的 $\beta$ 值

变换形式： $$ log{\frac{p(X)}{1-p(X)}}=\beta_0+\beta_1X $$ 转换为了分对数变换下关于 X 的一个线性模型

z 统计量

衡量某个观测值与总体均值之间的偏差 $$ z=\frac{X-\mu}{\sigma} $$

稍后再看

贝叶斯分类器

想看的电影们

Mon, 03 Nov 2025 22:28:13 GMT

芳华

星际穿越

盗梦空间

滑动窗口

Fri, 31 Oct 2025 14:34:01 GMT

什么是滑动窗口？

滑动窗口，致力于解决数组、字符串中的连续子串相关的问题，通过左右指针框住一个窗口，维护窗口中的相关数值，每个元素最多被访问两遍，因此时间复杂度能从 $O(n^2)$ 降低到 $O(n)$

使用情形

滑动窗口，常用来在 O(N) 时间复杂度上处理子串相关的问题，常见有一下三种情形：

1. 固定长度的窗口

首先框住第一个固定长度的窗口，再通过同时移动左右指针来移动窗口，每次移动会导致最左侧元素被删除、最右侧元素被加入，然后再根据变化维护窗口内的数值

以求固定长度区间最大值为例：

2 . 可变长度的窗口

与上一个不同的是，我们可以扩大窗口，那么我们就可以单独右移右指针，以扩大窗口，举个例子来看吧：

比方说我们想在一个字符串中，找到最大长度的一个子串，保证这个子串中的字符不重复，那么就要用到滑动窗口了：

例题

咱们以无重复字符的最长子串来举例子：

这道题实际上也就是上面所说的第二种情况，可以以 $O(s.size())$ 的时间复杂度来解决问题

class Solution {

public:

    int lengthOfLongestSubstring(string s) {

        int n=s.size(),ans=0;

        unordered_set<char> Set;

        int r=-1;

        for(int i=0;i<n;i++) {

            if(i!=0) {

                Set.erase(s[i-1]);

            }

            while(r<n-1&&!Set.count(s[r+1])) {

                Set.insert(s[r+1]);

                r++;

            }

            ans=max(ans,r-i+1);

        }

        return ans;

    }

};

每日一题：盛最多水的容器

Thu, 25 Sep 2025 11:09:46 GMT

题目描述

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。

找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。

返回容器可以储存的最大水量。

说明： 你不能倾斜容器。

示例 1：

输入：[1,8,6,2,5,4,8,3,7] 输出： 49 解释： 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。

示例 2：

输入： height = [1,1] 输出： 1

提示：

n == height.length
2 <= n <= 105
0 <= height[i] <= 10^4

解题思路

存水量取决于两根柱子中短的那一根，那么我们现在要做的就是来挑柱子

首先，我们当然希望 x 轴的距离越大越好，所以我们很自然地想到用双指针来解决

把两个指针分别放在最左端和最右端，我们一次挪动一步来找柱子，那么我们挪哪边的柱子呢？

假如我们移动其中较高的那根柱子：

距离缩短了
高度只低不高假如我们移动其中较矮的那根柱子：
距离缩短了
高度只高不低所以我们已经得到了策略：移动较矮的那根柱子每次移动较矮的那一根，找到容量最大的即可

完整代码

class Solution {

public:

    int maxArea(vector<int>& height) {

        int l = 0, r = height.size()-1;

        int max_volume=-1;

        while(l<r) {

            int h = min(height[l],height[r]);

            int vol = h*(r-l);

            max_volume = max(max_volume,vol);

            if(height[l]<height[r]) l++;

            else r--;

        }

        return max_volume;

    }

};

每日一题：分数转小数

Thu, 25 Sep 2025 10:53:39 GMT

题目描述

给定两个整数，分别表示分数的分子 numerator 和分母 denominator，以 字符串形式返回小数 。

如果小数部分为循环小数，则将循环的部分括在括号内。

如果存在多个答案，只需返回 任意一个 。

对于所有给定的输入，保证答案字符串的长度小于 $10^4$ 。

示例 1：

输入： numerator = 1, denominator = 2 输出： "0.5"

示例 2：

输入： numerator = 2, denominator = 1 输出： "2"

示例 3：

输入： numerator = 4, denominator = 333 输出： "0.(012)"

提示：

-2^31 <= numerator, denominator <= 2^31 - 1
denominator != 0

解题思路

这道题我们采用长除法的思路来做，这样我们不直接通过浮点数计算，而是一步步将小数部分转换到整数部分，依次得到小数的每一位。

例如： 计算 7 / 4 = 1.75

首先是整数部分：7 / 4 = 1 余 3
- 记录余数 3
第一位小数：3 * 10=30 , 30/4 = 7 余 2
- 记录余数 2
第二位小数：2 * 10=20 , 20/4 = 5 余 0 得到结果为 1.75

再例如： 计算 1 / 6 = 0.1666666...

首先是整数部分：1 / 6 = 0 余 1
- 记录余数 1
第一位小数： 1 * 10 = 10 , 10 / 6 = 1 余 4
- 记录余数 4
第二位小数： 4 * 10 = 40 , 40 / 6 = 6 余 4
- 余数 4 出现过，6 是循环节

[!note] 这种方法相当于每次将小数点往右移一位，以此来得到小数的下一位

因此我们可以总结出以下解题步骤：

1. 整数部分

这里会有两种情况，

除得尽：则答案就是结果的字符串形式
除不尽：需要继续处理小数部分

2. 小数部分

同样是两种情况，

通过长除法最终能结束：有限小数，直接把小数部分接上就行
通过长除法结束不了：无限循环小数，需要找循环节

3. 怎么找循环节

我们来看余数部分，假如说余数在某一次和这一次一样的，后面的结果也一定是一样的，也就是发生了循环。我们通过哈希表，映射一下余数和对应的位置，从而得到循环节。

4. 需要注意的点

需要先判断分子分母的正负，看看答案是否需要加负号
因为负数最小到 $-2^{31}$，取正会导致溢出，所以需要 long long

[!tip] 在判断结果的正负时，需要讨论分子分母的正负，这里我们可以直接使用异或来解决，异或，同 0 异 1，所以可以这样写：
if(x < 0 ^ y < 0) ans.push_back('-');

纠结部分

在判断循环节部分的代码，我之前是这样写的：

//小数部分
        unordered_map<ll,int> index;
        int cnt=0;
        string decimal;
        while(remainder!=0) {
            remainder *= 10;
            int cur = remainder/y;
            remainder %= y;
            if(index.count(remainder)) {//之前有过
                ans += decimal.substr(0,index[remainder]) + "(" + decimal.substr(index[remainder]) + ")";
                return ans;
            }
            index[remainder] = cnt++;
            decimal += (to_string(cur));
        }
        ans += decimal;

结果在解决 1/6 时发现了问题，因为余数依次为 1、4、4，结果在第二次发现 4 时就终止了，这时 ans 是 0.(1)

[!error]

首先是整数部分：1 / 6 = 0 余 1

记录余数 4

第一位小数： 1 * 10 = 10 , 10 / 6 = 1 余 4

余数 4 出现过，1 是循环节

[!why] 因为实际上第一个余数 1 对应的应该是第一位小数，但是这版代码误将下一次的余数和当前的小数点做了对应，自然就不对了

完整代码

#define ll long long

class Solution {

public:

    string fractionToDecimal(int numerator, int denominator) {

        ll x = numerator;

        ll y = denominator;

        if(x==0) return to_string(0);

        string ans;

        if(x < 0 ^ y < 0) ans.push_back('-');

        x = abs(x),y = abs(y);

        //整数部分

        ll remainder = x % y;

        if(remainder==0) {

            ans += to_string(x/y);

            return ans;

        }else {

            ans += to_string(x/y);

        }

        ans.push_back('.');

  

        //小数部分

        unordered_map<ll,int> index;

        int cnt=0;

        string decimal;

        while(remainder!=0) {

            if(index.count(remainder)) {//之前有过

                ans += decimal.substr(0,index[remainder]) + "(" + decimal.substr(index[remainder]) + ")";

                return ans;

            }

            index[remainder] = cnt++;

            remainder *= 10;

            int cur = remainder/y;

            remainder %= y;

            decimal += (to_string(cur));

        }

        ans += decimal;

        return ans;

    }

};

C++中常用的STL

Thu, 25 Sep 2025 10:35:27 GMT

string

字符串，有一些很好用的内置函数，下面介绍一些好用但之前不了解的：

一、构造函数

string s(num ,c)//生成num个c字符的字符串

例如：

string s(5,'3') => "33333"

二、比较函数

string 可以直接使用比较符进行大小比较，string 所谓的“大小”是这样来判断的：从左到右一位一位比较，按照字典序进行大小比较同时，string ("aaaa") < string ("aaaaa")

三、插入

pushback 在末尾插入一个字符

s.push_back('c');

insert 在位置 pos 前插入字符

s.insert(3,'+');

四、子串

//返回从第三位往后的子串
s.substr(3);
//返回2~5位的子串
s.substr(2,5);

五、`to_string` 和 `stoi`

to_string 可以将十进制类型 int、long、longlong、double 等转化为 string 类型

s = to_string(1234); => "1234"

stoi 可以将 string 类型转换为十进制

int x = stoi("1234",0,3); => 1234

vector

动态数组，然后有一个很好用的初始化：

vector<int> a(10,0);

意味着开一个长度至少为 10 的动态数组，每一项初始值为 0

专辑推荐

Tue, 23 Sep 2025 22:55:51 GMT

推荐一些好听的专辑

入门Node.js

Mon, 22 Sep 2025 17:49:51 GMT

Node. js 是什么

Node.js 是一个基于Chrome V8 JavaScript引擎的JavaScript运行时环境，让JavaScript可以在服务器端运行。

假如没有 Node. js，JavaScript 只能在浏览器上运行，而 Node. js 可以让 JavaScript 像 Python、Java 一样，能够直接在电脑上运行

如何使用 Node. js

npm 介绍

我们一般使用 npm（Node Package manager）进行 Node. js 的包管理，实现以下功能：

安装和管理 JS 包、模块
管理项目依赖
发布自己的包到 npm 仓库
运行脚本命令 npm 随 Node. js 一同安装

npm 常用命令

0. 检查版本

node --version
npm --version

1. 初始化项目

# 创建package.json文件
npm init
# 快速创建package.json文件
npm init -y

2. 安装包

# 安装到生产依赖
npm install <包名>
npm i <包名>  # 简写

# 安装到开发依赖
npm install <包名> --save-dev
npm i <包名> -D  # 简写

# 全局安装
npm install <包名> -g

# 安装指定版本
npm install <包名>@版本号

3. 卸载包

# 卸载本地包
npm uninstall <包名>

# 卸载全局包
npm uninstall <包名> -g

4. 查看包信息

# 查看已安装的包
npm list
npm ls

# 查看全局包
npm list -g

# 查看包信息
npm info <包名>

5. 更新包

# 更新所有包
npm update

# 更新指定包
npm update <包名>

package. json 结构

这是项目的配置文件, 结构如下:

{
  "name": "my-project",
  "version": "1.0.0",
  "description": "项目描述",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "test": "jest",
    "build": "webpack"
  },
  "dependencies": {
    "express": "^4.18.0"
  },
  "devDependencies": {
    "jest": "^28.0.0"
  }
}

依赖类型

dependencies: 生产环境需要的包
devDependencies: 开发环境需要的包（如测试工具、构建工具）
peerDependencies: 同伴依赖
optionalDependencies: 可选依赖

版本号规则

"^1.2.3"  # 兼容版本：>=1.2.3 <2.0.0
"~1.2.3"  # 近似版本：>=1.2.3 <1.3.0
"1.2.3"   # 精确版本
"*"       # 最新版本

常用 npm 脚本

在 package. json 中定义脚本:

{
"scripts": {
    "start": "node index.js",
    "test": "jest",
    "build": "webpack"
  }
}

运行脚本:

npm run start
npm run test
npm test # npm run test的缩写

使用 Node. js 创建项目的基本流程

1.创建项目目录

mkdir my-project
cd my-project

2.初始化项目

npm init -y

3. 安装一些包

npm install ...

4. 创建入口文件

echo "console.log('Hello npm!')" > index.js

每日一题：最长连续序列

Mon, 22 Sep 2025 09:24:59 GMT

题目描述

给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。

请你设计并实现时间复杂度为 O(n) 的算法解决此问题。

示例 1：

输入： nums = [100,4,200,1,3,2] 输出： 4 解释： 最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。

示例 2：

输入： nums = [0,3,7,2,5,8,4,6,0,1] 输出： 9

示例 3：

输入： nums = [1,0,1,2] 输出： 3

提示：

0 <= nums.length <= 105
-109 <= nums[i] <= 109

解题思路

朴素解->哈希表

首先来看最朴素的思想，当我们拿到一个数 x 时，以他作为连续序列的头元素，紧接着去寻找列表中有没有 x+1，直到找不到下一个 x+1，更新最长连续长度

这样的时间复杂度是 $O(n^2)$ 的，显然不符合题目要求，我们尝试减小时间复杂度。

我们知道，在哈希表中查询数据的时间复杂度是 $O(1)$ 的，因此，我们可以先将列表中的数据都存进哈希表中，这样找 x+1 的时间复杂度就从 $O(n)$ 变成了 $O(1)$，总时间复杂度降到了 $O(n)$

当我们拿到一个数 x 时，首先判断列表中有无 x-1，假如有，那么以 x 打头的列表必然不可能是最长序列，可以直接略过。假如没有，那么就依次寻找 x+1，更新序列长度。

至于 c++中如何使用哈希表，请见哈希值与哈希表

最后可以很顺利地写出代码：

class Solution {

public:

    int longestConsecutive(vector<int>& nums) {

        unordered_map<int,bool> HashTable;

        for(int i=0;i<nums.size();i++) {

            HashTable[nums[i]] = true;

        }

        int max_length=1;

        for(int i=0;i<nums.size();i++) {

            int length=1,num=nums[i];

            if(HashTable[num-1]) continue;

            while(HashTable[num+1]) {

                length++;

                num++;

            }

            max_length = max(max_length,length);

        }

        return max_length;

    }

};

结果发现通过不了，分析原因：

边界情况，当数组为空时应特判
考虑去重，当数据中存在很多重复数时，会极大增加时间复杂度

对于去重，我们采用 unordered_set，这样一举两得，在去重的同时能够以 $O(1)$ 的时间复杂度查询键值

具体用法请见哈希值与哈希表

改进后代码：

class Solution {

public:

    int longestConsecutive(vector<int>& nums) {

        if(nums.size()==0) return 0;

        unordered_set<int> num_set;

        for(const int& num : nums) {

            num_set.insert(num);

        }

        int max_length=1;

        for(const int& num : num_set) {

            int length=1,cur_num=num;

            if(num_set.count(cur_num-1)) continue;

            while(num_set.count(cur_num+1)) {

                length++;

                cur_num++;

            }

            max_length = max(max_length,length);

        }

        return max_length;

    }

};

并查集

Thu, 18 Sep 2025 18:11:51 GMT

一、并查集是什么

并查集用来“拉帮结派”，学术点来说，就是用来处理不相交集合的合并以及查找成员的集合归属的算法。主要有 union 和 find 两个操作，分别用来合并两个集合、查找成员集合归属。

二、什么思想

首先，怎么区分各个集合？找集合中某个人作为老大，他就是这个集合的代表，想知道某个人在哪个集合中，找他的老大就好了。至于怎么找，我们定义一个上级数组 parent[]，用来存储每个对象的上级，一级一级往上找就好。

`find` 操作

找成员 x 的老大，一级一级往上找，直到找到一个人，他的上级就是他自己。

int find(int x) {
	while(x != parent[x]) {
		x = parent[x];
	}
	return x;
}

`union` 操作

将集合 A 和集合 B 合并，那么只需要让 A 的老大变成 B，或者 B 的老大变成 A 即可。

void union(int x,int y) { //让x和y变成一伙的
	int rootX = find(x);
	int rootY = find(y);
	parent[rootX] = rootY;
}

我们可以发现，这其实就是棵树不过现在有了新问题：当树的高度过高，会导致 find 操作的时间成本很大，所以我们可以采用路径压缩的方法——当我们进行 find 操作时，会从下到上遍历每一个上级，那么我们可以边遍历，边让每个节点的上级直接变成老大，这样会使得树的高度直线下降。

int find(int x) {
	while(x != parent[x]) {
		x = find(parent[x]);
	}
	return x;
}

哈希值与哈希表

Wed, 17 Sep 2025 18:11:51 GMT

哈希值

将任何值通过哈希函数转换为哈希值 具有以下特点：

同一值转换的哈希值是固定的
不论输入值长度大小，哈希值的长度是固定的
无法通过哈希值反推原值

简单总结：哈希值就是数据的“指纹”或“身份证号”。它独一无二（理想情况下），能代表原始数据，但又隐藏了原始数据的具体内容。

哈希表

哈希表是一种数据结构，它利用哈希值的思想来实现极速的增、删、查、改。 分为以下步骤：

将输入值转换为哈希值
假如要对数据进行存储操作，查询哈希值是否发生冲突，若有，进行冲突处理
哈希值对容器大小取模得到容器中数据的索引，从而对数据进行增删改查

哈希冲突

在实际操作中，通过哈希函数转换，张三 和 李四 可能得到相同的哈希值，例如 47，这样会导致两个人共用同一个“47号柜子”。

对于这样的冲突，提供两种解决方法：

一. 链表法

通过哈希函数得到柜子号 47
这次我们给柜子挂上一条链表，链表上存储着所有哈希值等于柜子号的数据
这样一来，用户得到哈希值对应到柜号 47后，只需要顺着链表就能找到自己的数据

二. 开放空间法（线性搜索法）

通过哈希函数得到柜子号 47
李四发现张三已经占用了 47 柜子，则往后搜索，看看 48、49... 找到第一个空柜子存自己的数据

哈希函数的选择

我们的核心目标是：追求速度和均匀性、追求安全性 均匀分布是为了降低冲突概率

一、用于数据结构的增删改查

使用非加密哈希函数 特点：

速度快
散列均匀：能最大限度地避免冲突
对小输入友好：即使数据只有微小变化，仍然会导致哈希值变化很大 常见选择：
MurmurHash：性能极高，分布性非常好，是业界非常流行的非加密哈希算法。Redis, Hadoop 等很多知名项目都在使用它。
FNV (Fowler-Noll-Vo)：一个非常简单且快速的算法，在很多场景下表现良好，易于实现。
xxHash：以其惊人的速度而闻名，在许多基准测试中都是最快的哈希算法之一，同时保持了良好的分布性。
CityHash / FarmHash：由 Google 开发，专为 64 位架构优化，性能卓越。

[!note] 黄金法则： 黄金法则：不要自己造轮子！ 绝大多数情况下，你不需要自己去实现这些算法。直接使用你所用编程语言内置的哈希功能即可。

在 Java 中，每个对象都有 hashCode() 方法。HashMap 就依赖这个方法。

在 Python 中，有内置的 hash() 函数。dict 和 set 都依赖它。

在 C++ 中，标准库提供了 std::hash。

语言标准库的实现通常是经过深度优化的、可靠的非加密哈希函数，它们足以应对绝大多数哈希表的需求。只有在对性能有极致要求的特定场景下，才需要考虑引入 MurmurHash、xxHash 等第三方库。

二. 用于数据加密

此时, 速度不再是第一要义, 算法的安全性最重要所以我们使用加密哈稀函数 评估标准:

符合基础特点
原像抗性: 不可逆性
第二原像抗性: 抗篡改性

[!example]

举个例子, 网站在发给你一个文件的同时, 像你发送了一串 SHA-256 哈希值, 让你检验文件是否被篡改

一个黑客想攻击你, 制作了病毒文件, 并通过技术让他的文件哈希值也恰好等于原哈希值

这样一来, 你一比对并无偏差, 安安心心的下载了病毒文件, 招致了困惑

碰撞抗性: 几乎不可能找到任意两个不同的 A 和 B, 使得 H(A) 等于 H(B)

哈希函数在 c++中的实现

在 c++中，我们无需导入库，可直接使用 hash 类实现

hash<string> stringHasher;//创建哈希函数
string s = "abc";
cout<<stringHasher(s);

哈希表在 c++中的实现

在 c++中，哈希表通常采用 #include<unordered_map> 实现，unordered_map 用于存储键值对，正好符合哈希表的功能。以下是利用哈希表在列表中以 O(n) 实现数据查找

#include<unordered_map>

unordered_map<int,int> hashTable;
for(int i=1;i<=n;i++) {
	hashTable[a[i]] = i;
}
cin>>x;
auto it = hashTable.find(x);
if(it != hashTable.end()) {
	return it->second;
}
return NULL;

此外，还有 unordered_set 用来实现常数级的数据查找，它是一种使用哈希表实现的无序关联容器，其中键被哈希到哈希表的索引位置，因此插入操作总是随机的。无序集合上的所有操作在平均情况下都具有常数时间复杂度 O (1)，但在最坏情况下，时间复杂度可以达到线性时间 O (n)，这取决于内部使用的哈希函数，但实际上它们表现非常出色，通常提供常数时间的查找操作。具体用法：

unordered_set<type> name;

size() empty() 用于获取大小和是否为空 find() 用于查找键 insert() erase() 用于插入和删除元素 count() 用于查找某个键出现的次数

苏州行

Tue, 16 Sep 2025 22:08:24 GMT

出行

9.30 飞机

周水子-天津滨海 10:15-11:30

9.30 火车 (9.16 抢票下午 4:15)

天津西-苏州 20:40-07:23
苏州-昆山南 07:47-07:59
站内换乘 24 分钟(来得及)

10.3 高铁 (9:21抢票上午 8:30)

昆山南-上海 08:56-09:15
上海-昆山 22:09-22:30

10.5 火车（9.21 抢票上午 8:30）

苏州-天津 20:26-07:33

10.8 高铁（9.24抢票下午 4:15）

天津西-大连北 17:26-22:23

住宿

10.1-10.5 (共 4 晚) 下榻全季昆山开发区前进东路酒店 10.6-10.8 (共 2 晚) 下榻天津

安排

10.1

简单逛逛看看金鸡湖、东方之门

10.2

拙政园
苏州博物馆
狮子林
平江路

10.3

前往上海

武康大楼
HAUS NOWHERE
南京路
外滩

10.4

留园
虎丘山
山塘街

要带的东西

手机
身份证
充电器（手机、手表）、充电宝
剃须刀
小鲨鱼书包
精油
面膜
发箍
洗面奶
护肤品
拖鞋
pocket3
唇膏
药膏
水杯（大小都带）
卫生纸、湿纸巾
毛巾、浴巾
床上一次性用品
鼻炎药、过敏药、感冒药
夏衣 3 身，外套，防晒衣、鞋、睡衣
备点吃的
餐具
礼物

链表

Fri, 12 Sep 2025 18:11:51 GMT

一些思路：

快慢指针：fast 指针一次走两步，slow 指针一次走一步，那么当 fast 走完时，slow 指针会走到整条链表的一半位置
判断两链表交点：
- 设链表 A 相交前长度为 a
- 设链表 B 相交前长度为 b
- 相交长度为 c
- 因为有 a + c + b == b + c + a
- 所以让两个指针一起走，走到头就跳转到对方的头指针接着走
- 两个指针就会在交点处相遇

ListNode *fast = head,*slow =head;

while(fast != nullptr && fast->next != nullptr) {

	fast = fast->next->next;

	slow = slow->next;

}

粒子群算法

Sat, 06 Sep 2025 18:11:51 GMT

粒子群算法（PSO）

1.介绍

以一群蜜蜂寻找最甜的花为例
- 他们很盲目：不知哪里最甜
- 有记忆：知道自己到过最甜的位置
- 有沟通：知道群体最甜的位置于是，对于每只蜜蜂，它下次飞行会综合考虑以下三个方面：
按照惯性，沿着上一次的方向再飞一会儿
自己的最甜处，即个体最优解(pbest, Personal Best)
群体的最甜处，即全局最优解(gbest, Global Best) 然后在迭代后，所有蜜蜂都会找到最甜处

2.算法讲解

现在，我们把上面的故事翻译成算法的语言：

粒子 (Particle)：就是一只蜜蜂。在算法里，它代表一个潜在的解。
种群/粒子群 (Swarm)：就是整个蜂群。它是一组潜在的解。
位置 (Position, x)：就是蜜蜂所在的位置坐标。在算法里，它就是这个潜在解的具体数值。如果我们要优化函数 f(x, y)，那么一个粒子的位置就是 (x, y)。
速度 (Velocity, v)：就是蜜蜂飞行的方向和距离。它决定了粒子下一次移动的方向和步长。速度越大，粒子移动得越快、越远。
适应度 (Fitness)：就是蜜蜂闻到的花香浓度。在算法里，通常由一个目标函数（也叫适应度函数）来计算。我们的目标就是找到适应度最高（或最低）的位置。例如，寻找函数的最小值时，函数值就是适应度，越小越好。
个体最优解 (pbest, Personal Best)：就是某只蜜蜂自己历史上去过的最香的位置。每个粒子都有自己的 pbest。
全局最优解 (gbest, Global Best)：就是整个蜂群目前发现的最香的位置。所有粒子共享同一个 gbest。

3.算法流程

Step1：初始化

随机一群粒子
为每个粒子随机分配参数（对于蜜蜂，就是初始位置 x 和初始速度 v）
计算每个粒子的适应度 (适应度函数就是目标函数)
将当前适应度设置为每个个体的 pbest
从所有 pbest 中选出 gbest Step2：迭代
步骤与 Step1 相同，每次迭代会更新每个粒子的 x 和 v，从而得到更好的 pbest 和 gbest

4.PSO 的灵魂：迭代函数

速度更新公式： $$ v(t+1)=wv(t)+c_1rand_1*(pbest-x(t))+c_2rand_2(gbest-x(t)) $$ 其中，

$v(t+1)$：粒子下一刻速度
$w$：惯性权重
$c_1$：自我学习部分的学习因子
$rand_1$：0~1 的随机数
$c_2$：群体学习部分的学习因子
$rand_2$：0~1 的随机数
$c_1rand_1(pbest-x(t))$ 表示粒子向 pbest 飞行的趋势
$c_2rand_2(pbest-x(t))$ 表示粒子向 gbest 飞行的趋势

[!note] 值得注意的是在实际应用是，v, x 是多维的向量，每个维度就代表一个的参数

位置更新公式： $$ x(t+1)=x(t)+v(t+1) $$

5. 代码实战

理论说完了，我们来点实际的。用 Python 实现 PSO，求解函数 f(x, y) = x² + y² 在 [-10, 10] 区间内的最小值。我们都知道，最小值在 (0, 0)，值为 0。看看 PSO 能不能找到它。

import numpy as np

# --- 1. 定义目标函数 (适应度函数) ---
def objective_function(position):
    # position 是一个包含 x 和 y 的数组/列表，例如 [x, y]
    return position[0]**2 + position[1]**2

# --- 2. PSO 参数设置 ---
w = 0.5         # 惯性权重
c1 = 1.5        # 个体学习因子
c2 = 1.5        # 社会学习因子
n_particles = 50 # 粒子数量
n_dimensions = 2 # 问题维度 (x, y)
max_iter = 100   # 最大迭代次数
bounds = [(-10, 10), (-10, 10)] # 搜索范围

# --- 3. 初始化粒子群 ---
# 初始化粒子位置
particles_pos = np.random.uniform(bounds[0][0], bounds[0][1], (n_particles, n_dimensions))
# 初始化粒子速度
particles_vel = np.random.rand(n_particles, n_dimensions)

# 初始化个体最优解 (pbest) 和其适应度
pbest_pos = particles_pos.copy()
pbest_fitness = np.array([objective_function(p) for p in pbest_pos])

# 初始化全局最优解 (gbest) 和其适应度
gbest_idx = np.argmin(pbest_fitness)
gbest_pos = pbest_pos[gbest_idx].copy()
gbest_fitness = pbest_fitness[gbest_idx]

# --- 4. 迭代优化 ---
print(f"开始优化，共 {max_iter} 代...")

for i in range(max_iter):
    for j in range(n_particles):
        # --- 更新速度 ---
        r1 = np.random.rand(n_dimensions)
        r2 = np.random.rand(n_dimensions)
        
        cognitive_vel = c1 * r1 * (pbest_pos[j] - particles_pos[j])
        social_vel = c2 * r2 * (gbest_pos - particles_pos[j])
        particles_vel[j] = w * particles_vel[j] + cognitive_vel + social_vel

        # --- 更新位置 ---
        particles_pos[j] = particles_pos[j] + particles_vel[j]
        
        # --- 边界处理 ---
        for k in range(n_dimensions):
            if particles_pos[j, k] < bounds[k][0]:
                particles_pos[j, k] = bounds[k][0]
            elif particles_pos[j, k] > bounds[k][1]:
                particles_pos[j, k] = bounds[k][1]

        current_fitness = objective_function(particles_pos[j])
        
        # --- 更新 pbest 和 gbest ---
        # 更新个体最优
        if current_fitness < pbest_fitness[j]:
            pbest_fitness[j] = current_fitness
            pbest_pos[j] = particles_pos[j].copy()

        # 更新全局最优
        if current_fitness < gbest_fitness:
            gbest_fitness = current_fitness
            gbest_pos = particles_pos[j].copy()

    # 每一代打印一次最优结果
    if (i + 1) % 10 == 0:
        print(f"第 {i+1} 代: 最优位置 = {gbest_pos}, 最优值 = {gbest_fitness:.6f}")

# --- 5. 输出最终结果 ---
print("\n优化结束!")
print(f"找到的最优位置 (gbest): {gbest_pos}")
print(f"找到的最优值: {gbest_fitness}")

你可以运行这段代码，会看到 gbest 的值随着迭代次数的增加，越来越接近 (0, 0)，最优值也越来越接近 0。

网站汇总

Fri, 05 Sep 2025 18:11:51 GMT

知识类

简单说说：你的电脑是如何访问网页的

简单说说：IPV4已耗尽，为什么你仍然可以访问互联网?

捣鼓类

实现了一个便捷美观的聚合影视站，支持 vercel 和 docker 部署

资源站

gemini生图：Banana Nano

影视站

免费在线观看电影电视剧 - 高清流畅无广告

公益机场

仪表盘 | W

音乐 api

GD Studio's Online Music Platform API

AI-api

https://openrouter.ai/ （github 登录）

LaTeX的学习笔记

Wed, 03 Sep 2025 18:11:51 GMT

介绍

LaTex（读作 "Lay-tek"）是一个排版工具，相比 Word 中用鼠标调整格式，LaTeX 全部采用代码来描述文档的结构和内容，再将其编译为 pdf 文档。

数学公式的输入方式

使用 $..$ 来框住数学表达式

1. 行内公式

行内公式使用 $..$ 包裹，数学表达式嵌入在语句中，不会打断语句例如：当变量 $x$ 趋近于无穷时，表达式 $\dfrac{1}{x}$ 的极限为 0. 其源码为：

当变量 $x$ 趋近于无穷时，表达式 $\dfrac{1}{x}$ 的极限为 0.

2. 行间公式

行间公式使用 $$..$$ 包裹，数学表达式独占一行，并会居中显示，公式内部的元素也会完整展开显示。例如：计算下面这个极限： $$ \lim_{x\to\infty}\dfrac{1}{x}=0 $$ 其源码为：

计算下面这个极限：
$$
\lim_{x\to\infty}\dfrac{1}{x}=0
$$

3. 上下标

上标用 ^ 实现，比方 $e^x$，下标用 _ 实现，比方 $a_1$。假如上下标很长，要用 {} 框起来，比如 $e^{x+1}$

$x^{10}$ 要写作 $x^{10}$ 而不是 $x^10$ , $x^10$

4. 字符

希腊字母：

小写： \alpha，\beta, \gamma, \delta....
大写：\Alpha，\Beta, \Gamma, \Delta....（首字母大写即可）例如： $$ \alpha^2+\beta^2=\gamma $$ 其他字符：

| 功能 | 示例代码 | 显示效果 | 备注 | | :----------- | :-------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------ | :----------------- | | 积分、求和、极限 | \int_a^b f(x)dx \sum_{i=1}^n a_i \lim_{x \to \infty} f(x) | $\int_a^b f(x)dx$ $\sum_{i=1}^n a_i$ $\lim_{x \to \infty} f(x)$ | 在行内模式会压缩 | | 关系运算符 | \leq, \geq, \neq, \approx, \equiv | $\leq, \geq, \neq, \approx, \equiv$ | 小于等于、大于等于、不等、约等、恒等 | | 集合运算符 | \in, \notin, \subset, \cup, \cap | $\in, \notin, \subset, \cup, \cap$ | 属于、不属于、子集、并集、交集 | | 箭头 | \to, \rightarrow, \Rightarrow, \leftrightarrow | $\to, \rightarrow, \Rightarrow, \leftrightarrow$ | | | 其他常用符号 | \infty (无穷) \nabla (梯度) \partial (偏导) \forall (任意) \exists (存在) | $\infty$ $\nabla$ $\partial$ $\forall$ $\exists$ | | | 向量 | \vec{a} \overrightarrow{AB} | $\vec{a}$ $\overrightarrow{AB}$ | | | 上下括号 | \underbrace{a+b+\cdots+z}_{26} \overbrace{a+b+\cdots+z}^{26} | $\underbrace{a+b+\cdots+z}_{26}$ $\overbrace{a+b+\cdots+z}^{26}$ | | | | | | |

希腊字母对照表：

5. 分数

命令：\frac{分母}{分子} 例如： $$ \frac{x^2+x}{y+1} $$ 正如前文所提到的，只有在写为行间代码时，分式才能完整展开。

6. 函数

LaTeX 预设了基本函数，如 \sin, \cos, \tan, \log 等

[!note] 注意：重点：不要直接输入 sin(x)，而要使用 \sin(x)。前者会被渲染成 $sin(x)$ (变量 s, i, n 相乘)，而后者是正确的函数格式 $\sin(x)$ (字体为正体)。

7. 根号

平方根： \sqrt{表达式} 例如：$\sqrt{x}$
N 次平方根：\sqrt[N]{表达式} 例如：$\sqrt[3]{x}$

8. 省略号

\ldots：与基线对齐的省略号，如 $a_1,a_2,\ldots,a_n$
\cdots：居中的省略号，如 $a_1+a_2+\cdots+a_n$

9. 括号

使用 \left(...\right)，获得一个可以自动调整大小的括号，而不是单纯用 ()，区别：

直接使用 ()： $$ f(x) = (\frac{\sqrt{x^2+x}+1}{x+1})^2 $$
使用 \left(...\right)： $$ f(x) = \left(\frac{\sqrt{x^2+x}+1}{x+1}\right)^2 $$ 方括号 []、绝对值号 || 同理

10. 矩阵（matrix）

矩阵：
- pmatrix：圆括号矩阵
- bmatrix：方括号矩阵
- vmatrix：竖线行列式
- matrix：无括号
语法：& 用于分隔列，\\ 用于分隔行
示例： $$ A = \begin{pmatrix} a & b \ c & d \end{pmatrix} \quad I = \begin{bmatrix} 1 & 0 \ 0 & 1 \end{bmatrix} $$ 源代码：

$$
A = \begin{pmatrix}
a & b \\
c & d
\end{pmatrix}
\quad
I = \begin{bmatrix}
1 & 0 \\
0 & 1
\end{bmatrix}
$$

11. 分段函数 (cases)

$$ f(x) = \begin{cases} x^2, &\text{如果 } x \ge 0 \ -x , &\text{如果 } x < 0 \end{cases} $$ 源代码：

$$
f(x) = \begin{cases}
	x^2, &\text{如果 } x \ge 0 \\
	-x , &\text{如果 } x < 0
\end{cases}
$$

12. 多行公式对齐：align

align 环境（带编号）/ align* 环境（不带编号）
- 语法：
  - 在需要对齐的符号前用 & 标注
  - 使用 \\ 换行
示例： $$ \begin{align*} f(x) &= (x+y)(x-y) \ &= x^2-xy+yx-y^2 \ &= x^2-y^2 \end{align*} $$

$$
\begin{align*}
f(x) &= (x+y)(x-y) \\
	 &= x^2-xy+yx-y^2 \\
	 &= x^2-y^2
\end{align*}
$$

Callout怎么用

Wed, 03 Sep 2025 18:11:51 GMT

语法

> [!关键字]
> 语句

关键字：
- NOTE：注意
- INFO：信息
- TODO：代办
- TIP / HINT：提示/技巧
- SUCCESS / CHECK / DONE：成功 / 完成
- QUESTION / HELP / FAQ：问题
- WARNING / CAUTION: 警告 / 注意
- DANGER / ERROR: 危险 / 错误
- EXAMPLE : 示例
- QUOTE / CITE：引用

[!note] 注意事项注意啦！

[!info] 这是一条信息

[!warning] 警告！不要阅读这条消息

[!example]

print("Hello World!")

Mermaid图表

Tue, 02 Sep 2025 18:11:51 GMT

介绍：

Mermaid 是用于流程图绘制的 Markdown
示例：

flowchart TB
	A[开始] --> B{判断}
	B -.是.-> C[执行操作1]
	B -.否.-> D[执行操作2]
	C --> E[结束]
	D --> E

代码如下：

flowchart TB
	A[开始] --> B{判断}
	B -.是.-> C[执行操作1]
	B -.否.-> D[执行操作2]
	C --> E[结束]
	D --> E

代码块使用 ```mermaid``` 包裹 解释:

graph TD: 定义了一个图表，方向是从上到下 (Top-Down)。你也可以使用 LR (Left-Right) 从左到右。
A[开始]: 定义了一个节点 A，文本为“开始”，使用方括号 [] 表示矩形（默认）。
B{判断}: 定义了一个节点 B，文本为“判断”，使用花括号 {} 表示菱形。
C[执行操作1]: 定义了一个节点 C，文本为“执行操作 1”。
A --> B: 定义了一个从节点 A 到节点 B 的箭头。
B -->|是| C: 定义了一个从节点 B 到节点 C 的箭头，带有标签“是”。
常用节点形状:
- []: 矩形 (默认)
- (): 圆角矩形
- {}: 菱形
- (()): 圆形
- ([text]): 体育场形状
- >: 旗形
- {{text}}: 子例程形状

ArronHC的博客

muduo学习笔记

动起来！

1. 安装依赖

2. 下载并编译

3. 看一下效果

解剖

Eventloop

1. 阻塞与等待（The wait）

2. 处理网络事件（The Action）

3. 处理“任务队列”（The Pending Tasks）

Channel

TcpConnection

串起来看看！

第一幕：沉睡与唤醒 (Monitoring)

第二幕：分发与搬运 (Dispatch & Read)

第三幕：决策与执行 (Business Logic)

第四幕：发送与离场 (Send & Loop)

从零开始自己造

前置知识 ：

protected/private

static

const

explicit

类中的私有变量

using

继承

static_cast<类型>

Noncopyable 类

Noncopyable. h

InetAddress 类

InetAddress.h

InetAddress.cc

Timestamp 类

Timestamp.h

Timestamp.cc

🌟Socket 类

Socket. h

Socket.cc

Ip 地址

🌟Channel 类

Channel.h

Channel.cc

kReadEvent

update ()

🌟Poller 类、EpollPoller 类

用处：

Poller.h

Poller.cc

EpollPoller.h

EpollPoller.cc

🌟EventLoop 类

EventLoop.h

EventLoop.cc

整体流程图：

记录倒腾服务器的全过程

但是 ：

【转载】华为手机安装GMS最终教程

华为设备 microG 安装教程（鸿蒙 4.2 / EMUI 13.2+）

🔍 microG 是什么？

✅ 支持设备范围

🚨 声明与版权

📊 功能对比表（更新时间：2025-07-25）

ℹ️ 重要说明与补充

关于消息推送（非常重要）

📥 下载链接

✅ 安装教程总览

0. 安装前准备

1. 清除谷歌应用数据 / 卸载相关组件

2. 激活谷歌服务助手（仅手机操作，平板忽略）

2.1 下载并导入备份

2.2 修改系统日期到 2019 年

2.3 从内部存储恢复备份

2.4 激活谷歌服务助手

3. 安装下载好的软件（核心三件）

必装的 3 个 APK（缺一不可）

4. 授予 microG 权限

5. 检测 microG 是否支持

7. 登录谷歌账号

8. 使用 Play 商店或第三方商店

前置知识：

但是：

五、`to_string` 和 `stoi`