qt写程序用Concurrent机制定时使用多线程向12个服务端发送udp的心跳包，异步检测服务端是否能通讯

好的，针对您的问题，我可以提供一个简单的示例代码，以供参考：

#include <QtCore>
#include <QtNetwork>

class HeartbeatSender : public QObject
{
    Q_OBJECT

public:
    explicit HeartbeatSender(const QHostAddress &address, quint16 port, QObject *parent = nullptr)
        : QObject(parent), m_address(address), m_port(port)
    {
    }

    void start()
    {
        QTimer *timer = new QTimer(this);
        connect(timer, &QTimer::timeout, this, &HeartbeatSender::sendHeartbeat);
        timer->start(5000); // 定时器间隔为5秒
    }

signals:
    void serverAlive(const QHostAddress &address, quint16 port);
    void serverDead(const QHostAddress &address, quint16 port);

private:
    void sendHeartbeat()
    {
        QUdpSocket *socket = new QUdpSocket(this);
        connect(socket, &QUdpSocket::readyRead, this, &HeartbeatSender::readDatagram);

        QByteArray datagram = "Heartbeat";
        socket->writeDatagram(datagram.data(), datagram.size(), m_address, m_port);
    }

    void readDatagram()
    {
        QUdpSocket *socket = qobject_cast<QUdpSocket *>(sender());
        if (socket) {
            while (socket->hasPendingDatagrams()) {
                QByteArray datagram;
                datagram.resize(socket->pendingDatagramSize());
                QHostAddress sender;
                quint16 senderPort;
                socket->readDatagram(datagram.data(), datagram.size(), &sender, &senderPort);
                if (sender == m_address && senderPort == m_port) {
                    emit serverAlive(sender, senderPort);
                }
            }
        }
    }

private:
    QHostAddress m_address;
    quint16 m_port;
};

class HeartbeatManager : public QObject
{
    Q_OBJECT

public:
    explicit HeartbeatManager(QObject *parent = nullptr)
        : QObject(parent)
    {
    }

    void addServer(const QHostAddress &address, quint16 port)
    {
        HeartbeatSender *sender = new HeartbeatSender(address, port, this);
        connect(sender, &HeartbeatSender::serverAlive, this, &HeartbeatManager::handleServerAlive);
        connect(sender, &HeartbeatSender::serverDead, this, &HeartbeatManager::handleServerDead);
        m_senders.append(sender);
        sender->start();
    }

signals:
    void serverAlive(const QHostAddress &address, quint16 port);
    void serverDead(const QHostAddress &address, quint16 port);

private slots:
    void handleServerAlive(const QHostAddress &address, quint16 port)
    {
        emit serverAlive(address, port);
    }

    void handleServerDead(const QHostAddress &address, quint16 port)
    {
        emit serverDead(address, port);
    }

private:
    QList<HeartbeatSender *> m_senders;
};

int main(int argc, char *argv[])
{
    QCoreApplication app(argc, argv);

    HeartbeatManager manager;
    manager.addServer(QHostAddress("192.168.1.1"), 1234);
    manager.addServer(QHostAddress("192.168.1.2"), 1234);
    manager.addServer(QHostAddress("192.168.1.3"), 1234);
    // 添加更多服务端

    QObject::connect(&manager, &HeartbeatManager::serverAlive, [](const QHostAddress &address, quint16 port) {
        qDebug() << "Server" << address.toString() << ":" << port << "is alive";
    });

    QObject::connect(&manager, &HeartbeatManager::serverDead, [](const QHostAddress &address, quint16 port) {
        qDebug() << "Server" << address.toString() << ":" << port << "is dead";
    });

    return app.exec();
}

#include "main.moc"

上面的示例代码中，我们定义了一个 `HeartbeatSender` 类来负责向单个服务端发送UDP心跳包，并且在接收到服务端的响应后发出信号来通知 `HeartbeatManager` 类。

`HeartbeatManager` 类则负责管理多个 `HeartbeatSender` 实例，并且在接收到 `HeartbeatSender` 发出的信号后，发出自己的信号来通知上层代码。

在 `main` 函数中，我们创建了一个 `HeartbeatManager` 实例，并添加了三个服务端的地址和端口号。然后，我们通过连接 `HeartbeatManager` 的信号来处理服务端的状态变化。

希望这个示例代码可以对您有所帮助。如果您还有任何问题，请随时追问。