1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

DNS 解析请求
    │
    ├── NormalResolver（默认）
    │     → 投递到 ConcurrentTaskQueue（阻塞线程池）
    │     → getaddrinfo() 在工作线程里阻塞
    │     → 完成后回调（在工作线程里直接调用）
    │
    └── AresResolver（c-ares 可用时）
          → 在 EventLoop 线程里全程非阻塞
          → c-ares 管理 DNS socket，注册到 epoll
          → EventLoop 处理 DNS socket 的读写事件
          → 完成后在 EventLoop 线程里调用回调

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class Resolver {
  public:
    using Callback = std::function<void(const trantor::InetAddress&)>;
    using ResolverResultsCallback =
        std::function<void(const std::vector<trantor::InetAddress>&)>;

    // 工厂函数：根据编译配置选择实现
    static std::shared_ptr<Resolver> newResolver(
        EventLoop *loop = nullptr,
        size_t timeout = 60);   // timeout：DNS 缓存有效期（秒）

    // 解析单个地址
    virtual void resolve(const std::string& hostname,
                         const Callback& callback) = 0;

    // 解析所有地址（A/AAAA 记录，可能有多个 IP）
    virtual void resolve(const std::string& hostname,
                         const ResolverResultsCallback& callback) = 0;

    static bool isCAresUsed();   // 当前是否在用 c-ares
};

1
2
3
4

编译时是否有 c-ares？
    │
    ├── 有 c-ares → newResolver() 返回 AresResolver
    └── 没有 c-ares → newResolver() 返回 NormalResolver（NormalResolver.cc 里实现）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

void NormalResolver::resolve(const std::string &hostname,
                             const Callback &callback)
{
    // ① 先查全局缓存（加锁）
    {
        std::lock_guard<std::mutex> guard(globalMutex());
        auto iter = globalCache().find(hostname);
        if (iter != globalCache().end()) {
            auto &cachedAddr = iter->second;
            // 缓存未过期？
            if (timeout_ == 0 ||
                cachedAddr.second.after(timeout_) > Date::date()) {
                callback(cachedAddr.first);   // ← 直接从缓存返回
                return;
            }
        }
    }

    // ② 缓存未命中：投递到线程池
    concurrentTaskQueue().runTaskInQueue(
        [thisPtr = shared_from_this(), callback, hostname]() {
            // ③ 在工作线程里再查一次缓存（防止并发重复查询）
            {
                std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
                // ... 同①的缓存检查 ...
                if (hit) { callback(cachedAddr.first); return; }
            }

            // ④ 调用阻塞的系统 DNS 解析
            struct addrinfo hints, *res = nullptr;
            memset(&hints, 0, sizeof(hints));
            hints.ai_family = PF_UNSPEC;      // 支持 IPv4 和 IPv6
            hints.ai_socktype = SOCK_STREAM;
            hints.ai_flags = AI_PASSIVE;
            auto error = getaddrinfo(hostname.data(), nullptr, &hints, &res);

            if (error != 0 || res == nullptr) {
                callback(InetAddress{});      // 解析失败：返回空地址
                return;
            }

            // ⑤ 提取第一个地址（IPv4 优先）
            InetAddress inet;
            if (res->ai_family == AF_INET) {
                inet = InetAddress(*reinterpret_cast<sockaddr_in*>(res->ai_addr));
            } else if (res->ai_family == AF_INET6) {
                inet = InetAddress(*reinterpret_cast<sockaddr_in6*>(res->ai_addr));
            }
            freeaddrinfo(res);

            // ⑥ 直接调用回调（在工作线程里！）
            callback(inet);

            // ⑦ 更新全局缓存
            {
                std::lock_guard<std::mutex> guard(thisPtr->globalMutex());
                auto &addrItem = thisPtr->globalCache()[hostname];
                addrItem.first = inet;
                addrItem.second = Date::date();   // 记录缓存时间
            }
        });
}

1
2
3
4
5
6
7
8
9

调用 resolve()
    │
    ├─ 加锁检查缓存（快速路径）
    │   命中 → 直接返回
    │   未命中 → 投递到线程池
    │
    └─ 线程池里再次检查缓存（防止并发重复查询）
         命中 → 直接返回（多个相同 hostname 的查询，第一个完成后，后续命中缓存）
         未命中 → getaddrinfo（真正的网络查询）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 所有 NormalResolver 实例共享同一个缓存和线程池
static std::unordered_map<std::string, std::pair<InetAddress, Date>>&
globalCache() {
    static std::unordered_map<std::string, std::pair<InetAddress, Date>> dnsCache_;
    return dnsCache_;
}

static std::mutex& globalMutex() {
    static std::mutex mutex_;
    return mutex_;
}

static ConcurrentTaskQueue& concurrentTaskQueue() {
    static ConcurrentTaskQueue queue(
        std::thread::hardware_concurrency() < 8
            ? 8                               // 最少 8 个线程
            : std::thread::hardware_concurrency(),  // 或 CPU 核心数
        "Dns Queue");
    return queue;
}

1
2

// 工作线程里：
callback(inet);  // ← 直接调用，此时在 ConcurrentTaskQueue 的某个线程

1
2
3
4
5
6
7
8

// 正确用法：
resolver->resolve("game.server.com", [loop, conn](const InetAddress& addr) {
    loop->runInLoop([conn, addr]() {
        // 现在在 EventLoop 线程，可以安全操作 conn
        auto client = TcpClient(loop, addr, "client");
        client.connect();
    });
});

1
2
3
4
5
6
7
8

class AresResolver {
  private:
    trantor::EventLoop *loop_;   // c-ares 运行在这个 EventLoop 上
    ares_channel ctx_;           // c-ares 内部 channel（管理 DNS 请求状态）
    bool timerActive_{false};    // c-ares 超时定时器是否在运行
    ChannelList channels_;       // c-ares 创建的 DNS socket → trantor::Channel 映射
    // map<int sockfd, unique_ptr<Channel>>
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

AresResolver::resolve(hostname, cb)
    │
    ├─ 查缓存（命中直接 cb）
    │
    └─ 未命中 → resolveInLoop(hostname, cb)
         │
         ▼
    ares_getaddrinfo(ctx_, hostname, ...)
    ← c-ares 内部发起 DNS 查询（创建 UDP/TCP socket）
         │
    ares_sock_createcallback_()  ← c-ares 通知"新 socket 创建了"
    onSockCreate(sockfd, type)
         │
         ▼
    channels_[sockfd] = make_unique<Channel>(loop_, sockfd)
    channel->setReadCallback([this, sockfd]() { onRead(sockfd); })
    channel->enableReading()    ← 注册到 EventLoop 的 epoll
         │
    [DNS 服务器响应，sockfd 可读]
         │
         ▼
    epoll_wait() 返回 sockfd 可读
    Channel::handleEvent() → onRead(sockfd)
         │
         ▼
    ares_process_fd(ctx_, sockfd, ARES_SOCKET_BAD)  ← 让 c-ares 处理读事件
         │
    [c-ares 解析 DNS 响应]
         │
         ▼
    ares_hostcallback_(data, status, timeouts, result)
    onQueryResult(status, result, hostname, callback)
         │
         ▼
    更新缓存 → callback(解析结果)   ← 在 EventLoop 线程里回调！

1
2
3
4
5

static EventLoop* getLoop() {
    static EventLoopThread loopThread;
    loopThread.run();
    return loopThread.getLoop();
}

1
2
3
4

void AresResolver::onTimer() {
    ares_process_fd(ctx_, ARES_SOCKET_BAD, ARES_SOCKET_BAD);
    // 如果 c-ares 还有活跃查询，继续调度下一次 timer
}

1
2
3
4

// 时间判断：缓存时间 + 超时时长 > 当前时间 → 缓存有效
cachedAddr.second.after(timeout_) > trantor::Date::date()
// 等价于：(缓存时间 + timeout_秒) > 现在
// 即：距缓存时间已过 < timeout_ 秒 → 有效

1
2
3
4
5
6
7

游戏服务器是否需要频繁 DNS 解析？
    │
    ├─ 否（服务器间连接用 IP，只在启动时解析一次）
    │   → NormalResolver 足够，不必依赖 c-ares
    │
    └─ 是（动态服务发现、跨数据中心路由）
        → 安装 c-ares，使用 AresResolver，彻底不阻塞 EventLoop

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// 游戏服启动时解析逻辑服地址（一次性）
auto resolver = Resolver::newResolver();
resolver->resolve("logic.internal.game.com",
    [&loop](const InetAddress &addr) {
        if (!addr.isUnspecified()) {
            // 注意：NormalResolver 的回调在工作线程！
            loop.runInLoop([addr, &loop]() {
                auto client = std::make_shared<TcpClient>(
                    &loop, addr, "LogicSrv");
                client->connect();
            });
        } else {
            LOG_ERROR << "DNS 解析失败：logic.internal.game.com";
        }
    });

1
2
3
4
5
6
7
8
9

// 内部服务：IP 基本不变，缓存 1 小时（3600秒）
auto resolver = Resolver::newResolver(nullptr, 3600);

// 外部服务：可能有 CDN 动态调度，缓存 60 秒
auto resolver = Resolver::newResolver(nullptr, 60);

// 调试/测试：不缓存
auto resolver = Resolver::newResolver(nullptr, 0);   // timeout=0 → 永不过期
// ⚠️ 注意：timeout=0 在代码里是"永不过期"而不是"不缓存"！

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 解析所有 A 记录（用于负载均衡）
resolver->resolve("api.game.com",
    [](const std::vector<InetAddress> &addrs) {
        LOG_INFO << "解析到 " << addrs.size() << " 个地址";
        for (auto &addr : addrs) {
            LOG_INFO << "  " << addr.toIpPort();
        }
        // 随机选一个，或轮询
        auto &selected = addrs[rand() % addrs.size()];
        // ... 连接 ...
    });

1
2
3
4
5

// 用户代码——不区分两种 Resolver 的回调线程
resolver->resolve("game.server.com", [conn](const InetAddress &addr) {
    // 直接操作 TcpConnection
    conn->send("Resolved: " + addr.toIpPort());   // 危险！
});

1
2
3
4
5

resolver->resolve("game.server.com", [loop, conn](const InetAddress &addr) {
    loop->runInLoop([conn, addr]() {
        conn->send("Resolved: " + addr.toIpPort());  // 安全
    });
});

1
2
3
4
5
6
7
8

static ConcurrentTaskQueue& concurrentTaskQueue() {
    static ConcurrentTaskQueue queue(
        std::thread::hardware_concurrency() < 8
            ? 8
            : std::thread::hardware_concurrency(),
        "Dns Queue");
    return queue;
}

1
2
3

第 1 次查询 api.game.com → [IP-A, IP-B, IP-C]
第 2 次查询 api.game.com → [IP-B, IP-C, IP-A]
第 3 次查询 api.game.com → [IP-C, IP-A, IP-B]

1
2
3
4
5

static EventLoop* getLoop() {
    static EventLoopThread loopThread;   // 静态局部变量
    loopThread.run();
    return loopThread.getLoop();
}

1
2
3
4

static ConcurrentTaskQueue& concurrentTaskQueue() {
    static ConcurrentTaskQueue queue(8, "Dns Queue");
    return queue;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// 全局对象
class GameService {
    std::shared_ptr<Resolver> resolver_;
    TcpClient client_;
public:
    ~GameService() {
        // main() 结束后的静态析构阶段
        resolver_->resolve("shutdown.notify.com", [](const InetAddress &addr) {
            // 发送关服通知
        });
        // 此时 DNS 的全局 EventLoopThread/ConcurrentTaskQueue 可能已经被析构了！
    }
};
static GameService service;  // 全局静态对象