[包頭（固定N字節）][包體（變長）]

// TcpClientThread.h
class TcpClientThread : public QThread {
    Q_OBJECT
public:
    explicit TcpClientThread(qintptr socketDescriptor, QObject *parent = nullptr)
        : QThread(parent), m_socketDescriptor(socketDescriptor) {}

protected:
    void run() override {
        // 在子線程中創建QTcpSocket
        QTcpSocket socket;
        if (!socket.setSocketDescriptor(m_socketDescriptor)) {
            emit error(socket.error());
            return;
        }

        // 處理粘包/拆包的緩衝區
        QByteArray recvBuffer;

        // 等待數據到達
        while (socket.waitForReadyRead(-1)) {
            recvBuffer += socket.readAll();
            // 解析緩衝區中的完整數據包
            parsePackets(recvBuffer);
        }
    }

private:
    void parsePackets(QByteArray &buffer) {
        // 定長包頭（4字節）解析邏輯
        while (buffer.size() >= 4) {
            uint32_t bodyLen = *reinterpret_cast<uint32_t*>(buffer.data());
            // 注意：網絡字節序與主機字節序轉換（Qt提供qToBigEndian/qFromBigEndian）
            bodyLen = qFromBigEndian(bodyLen);

            if (buffer.size() < 4 + bodyLen) {
                break; // 包體不完整，等待後續數據
            }

            // 提取完整包體
            QByteArray body = buffer.mid(4, bodyLen);
            // 處理業務邏輯
            processBody(body);
            // 移除已處理數據
            buffer = buffer.mid(4 + bodyLen);
        }
    }

    void processBody(const QByteArray &body) {
        // 實際業務處理（如解析JSON、執行命令）
        qDebug() << "Received data:" << body;
    }

    qintptr m_socketDescriptor;
};

// TcpServer.h
class TcpServer : public QTcpServer {
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = nullptr) : QTcpServer(parent) {}

protected:
    void incomingConnection(qintptr socketDescriptor) override {
        // 為每個新連接創建線程
        TcpClientThread *thread = new TcpClientThread(socketDescriptor);
        connect(thread, &TcpClientThread::finished, thread, &TcpClientThread::deleteLater);
        thread->start();
    }
};

// 錯誤示例：手動鎖管理可能導致死鎖
QMutex mutex;
QList<qintptr> clientList;

void addClient(qintptr socketDesc) {
    mutex.lock();
    clientList.append(socketDesc);
    // 若此處拋出異常，unlock()將不會執行，導致死鎖
    mutex.unlock();
}

// TcpClientTask.h
#include <QRunnable>
#include <QTcpSocket>
#include <QMutex>
#include <QByteArray>
#include <QLoggingCategory>

// 日誌分類，方便調試
Q_DECLARE_LOGGING_CATEGORY(logTcpTask)

class TcpClientTask : public QRunnable {
public:
    explicit TcpClientTask(qintptr socketDescriptor, QObject *parent = nullptr);
    ~TcpClientTask() override;

    void run() override; // 任務執行入口

private:
    // 粘包/拆包解析
    void parsePackets(QByteArray &buffer);
    // 業務處理
    void processBusiness(const QByteArray &data);
    // 發送響應
    void sendResponse(const QByteArray &response);

private:
    qintptr m_socketDescriptor; //  socket描述符
    QTcpSocket *m_socket;       // TCP socket
    QByteArray m_recvBuffer;    // 接收緩衝區（用於粘包處理）
    bool m_isRunning;           // 任務運行狀態
};

// TcpClientTask.cpp
Q_LOGGING_CATEGORY(logTcpTask, "tcp.task")

TcpClientTask::TcpClientTask(qintptr socketDescriptor, QObject *parent)
    : QRunnable(), m_socketDescriptor(socketDescriptor), m_socket(nullptr), m_isRunning(true) {
    setAutoDelete(true); // 任務完成後自動銷燬
}

TcpClientTask::~TcpClientTask() {
    if (m_socket) {
        m_socket->close();
        delete m_socket;
    }
    qCDebug(logTcpTask) << "Task destroyed, socketDescriptor:" << m_socketDescriptor;
}

void TcpClientTask::run() {
    m_socket = new QTcpSocket();
    if (!m_socket->setSocketDescriptor(m_socketDescriptor)) {
        qCWarning(logTcpTask) << "Set socket descriptor failed:" << m_socket->errorString();
        return;
    }

    qCDebug(logTcpTask) << "New client connected, socketDescriptor:" << m_socketDescriptor
                        << "Thread ID:" << QThread::currentThreadId();

    // 循環讀取數據
    while (m_isRunning && m_socket->state() == QTcpSocket::ConnectedState) {
        // 等待數據到達（超時100ms，避免永久阻塞）
        if (m_socket->waitForReadyRead(100)) {
            m_recvBuffer += m_socket->readAll();
            parsePackets(m_recvBuffer); // 解析緩衝區
        } else {
            // 處理錯誤（如連接斷開）
            if (m_socket->error() != QTcpSocket::TimeoutError) {
                qCWarning(logTcpTask) << "Socket error:" << m_socket->errorString();
                m_isRunning = false;
            }
        }
    }

    qCDebug(logTcpTask) << "Client disconnected, socketDescriptor:" << m_socketDescriptor;
}

void TcpClientTask::parsePackets(QByteArray &buffer) {
    // 定長包頭（4字節，存儲包體長度，網絡字節序）
    while (buffer.size() >= 4) {
        // 解析包頭（注意字節序轉換）
        uint32_t bodyLen = *reinterpret_cast<const uint32_t*>(buffer.constData());
        bodyLen = qFromBigEndian(bodyLen); // 網絡字節序轉主機字節序

        // 檢查包體是否完整
        if (buffer.size() < 4 + bodyLen) {
            break; // 包體不完整，等待後續數據
        }

        // 提取包體
        QByteArray body = buffer.mid(4, bodyLen);
        // 移除已處理的包頭+包體
        buffer = buffer.mid(4 + bodyLen);

        // 處理業務邏輯
        processBusiness(body);
    }
}

void TcpClientTask::processBusiness(const QByteArray &data) {
    qCDebug(logTcpTask) << "Processing data:" << data << "Length:" << data.size();

    // 示例：簡單回顯業務（實際場景可替換為JSON解析、數據庫操作等）
    QByteArray response = "Server received: " + data;
    sendResponse(response);
}

void TcpClientTask::sendResponse(const QByteArray &response) {
    if (m_socket->state() != QTcpSocket::ConnectedState) {
        return;
    }

    // 構建響應包（包頭+包體）
    uint32_t bodyLen = qToBigEndian(static_cast<uint32_t>(response.size())); // 主機字節序轉網絡字節序
    QByteArray packet;
    packet.append(reinterpret_cast<const char*>(&bodyLen), 4); // 包頭
    packet.append(response); // 包體

    // 發送數據
    m_socket->write(packet);
    m_socket->flush();
}

// TcpServer.h
#include <QTcpServer>
#include <QThreadPool>
#include "TcpClientTask.h"

class TcpServer : public QTcpServer {
    Q_OBJECT
public:
    explicit TcpServer(QObject *parent = nullptr) : QTcpServer(parent) {
        // 配置線程池（根據CPU核心數調整）
        QThreadPool::globalInstance()->setMaxThreadCount(QThread::idealThreadCount() * 2);
        qCDebug(logTcpTask) << "ThreadPool max threads:" << QThreadPool::globalInstance()->maxThreadCount();
    }

protected:
    void incomingConnection(qintptr socketDescriptor) override {
        // 創建任務並提交到線程池
        TcpClientTask *task = new TcpClientTask(socketDescriptor);
        QThreadPool::globalInstance()->start(task);
    }
};

// main.cpp
#include <QCoreApplication>
#include "TcpServer.h"

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

    TcpServer server;
    if (!server.listen(QHostAddress::Any, 8888)) {
        qCritical() << "Server listen failed:" << server.errorString();
        return -1;
    }

    qInfo() << "Server started on port 8888";
    return a.exec();
}

// 共享資源管理類
class ClientManager {
public:
    static ClientManager &instance() {
        static ClientManager inst;
        return inst;
    }

    // 增加在線客户端
    void addClient(qintptr socketDesc) {
        QMutexLocker locker(&m_mutex); // 自動加鎖
        m_onlineClients.insert(socketDesc);
        // 離開作用域時，locker析構，自動解鎖
    }

    // 移除在線客户端
    void removeClient(qintptr socketDesc) {
        QMutexLocker locker(&m_mutex); // 自動加鎖
        m_onlineClients.remove(socketDesc);
    }

    // 獲取在線客户端數量
    int onlineCount() {
        QMutexLocker locker(&m_mutex); // 自動加鎖
        return m_onlineClients.size();
    }

private:
    ClientManager() = default;
    QMutex m_mutex; // 保護共享資源的互斥鎖
    QSet<qintptr> m_onlineClients; // 在線客户端集合
};

// TcpClientTask.cpp 中補充
void TcpClientTask::run() {
    m_socket = new QTcpSocket();
    if (!m_socket->setSocketDescriptor(m_socketDescriptor)) {
        // ... 錯誤處理
        return;
    }

    // 客户端上線，添加到管理器
    ClientManager::instance().addClient(m_socketDescriptor);
    qCDebug(logTcpTask) << "Online clients:" << ClientManager::instance().onlineCount();

    // ... 數據處理循環 ...

    // 客户端下線，從管理器移除
    ClientManager::instance().removeClient(m_socketDescriptor);
    qCDebug(logTcpTask) << "Online clients:" << ClientManager::instance().onlineCount();
}

void doSomething() {
    QMutexLocker locker(&m_mutex);
    // 處理需要加鎖的邏輯
    
    locker.unlock(); // 臨時解鎖
    // 執行不需要鎖的耗時操作（如IO）
    
    locker.relock(); // 重新加鎖
    // 繼續處理需要加鎖的邏輯
}

QMutexLocker locker1(&m_mutex);
// ... 
QMutexLocker locker2(std::move(locker1)); // 鎖所有權轉移給locker2
// 此時locker1不再持有鎖，解鎖由locker2負責

// 錯誤示例：兩個線程獲取鎖的順序相反
// 線程1
QMutexLocker locker1(&mutexA);
QMutexLocker locker2(&mutexB); // 可能死鎖

// 線程2
QMutexLocker locker1(&mutexB);
QMutexLocker locker2(&mutexA); // 可能死鎖

// 正確示例：按鎖地址排序獲取
QMutex *m1 = &mutexA;
QMutex *m2 = &mutexB;
if (m1 > m2) std::swap(m1, m2); // 確保先獲取地址小的鎖

QMutexLocker locker1(m1);
QMutexLocker locker2(m2);

int cpuCount = QThread::idealThreadCount();
QThreadPool::globalInstance()->setMaxThreadCount(cpuCount * 3); // IO密集型場景

// 優化前：mid()會複製數據
QByteArray body = buffer.mid(4, bodyLen);
buffer = buffer.mid(4 + bodyLen);

// 優化後：使用指針和偏移量，避免複製
const char *bodyData = buffer.constData() + 4;
processBusiness(QByteArray::fromRawData(bodyData, bodyLen)); // 不復制數據
buffer.remove(0, 4 + bodyLen); // 高效移除頭部數據

// 在TcpClientTask::run()中使用信號槽
void TcpClientTask::run() {
    m_socket = new QTcpSocket();
    // ... 綁定socketDescriptor ...

    // 將socket移動到當前線程（任務執行的線程）
    m_socket->moveToThread(QThread::currentThread());

    // 連接信號槽
    connect(m_socket, &QTcpSocket::readyRead, this, &TcpClientTask::onReadyRead, Qt::DirectConnection);
    connect(m_socket, &QTcpSocket::disconnected, this, &TcpClientTask::onDisconnected, Qt::DirectConnection);

    // 啓動事件循環（QRunnable本身無事件循環，需手動創建）
    QEventLoop loop;
    connect(this, &TcpClientTask::finished, &loop, &QEventLoop::quit);
    loop.exec();
}

void TcpClientTask::onReadyRead() {
    m_recvBuffer += m_socket->readAll();
    parsePackets(m_recvBuffer);
}

void TcpClientTask::onDisconnected() {
    m_isRunning = false;
    emit finished(); // 退出事件循環
}

// TcpServer中限制最大連接數
void TcpServer::incomingConnection(qintptr socketDescriptor) {
    if (ClientManager::instance().onlineCount() >= 10000) { // 最大連接數限制
        QTcpSocket socket;
        socket.setSocketDescriptor(socketDescriptor);
        socket.write("Server is busy");
        socket.disconnectFromHost();
        return;
    }
    // 正常創建任務
    TcpClientTask *task = new TcpClientTask(socketDescriptor);
    QThreadPool::globalInstance()->start(task);
}