Qt 网络绘图多线程并发库编程实战：构建高性能远程绘图服务器

客户端 → 发送绘图命令（JSON） → 服务器接收 → 放入请求队列 → 线程池并发处理 → 绘图操作（主线程） → 广播结果给所有客户端

{
  "type": "circle",
  "params": {
    "x": 100, "y": 150,
    "radius": 30,
    "color": "#FF0000"
  }
}

#ifndef SERVER_H
#define SERVER_H

#include <QTcpServer>
#include <QTcpSocket>
#include <QGraphicsScene>
#include <QImage>
#include <QThreadPool>
#include <QQueue>
#include <QMutex>
#include <QFuture>

class Server : public QTcpServer
{
    Q_OBJECT
public:
    explicit Server(QObject *parent = nullptr);
    void startServer(quint16 port);

protected:
    void incomingConnection(qintptr socketDescriptor) override;

private slots:
    void onReadyRead();
    void onClientDisconnected();
    void processDrawCommand(const QByteArray &data, QTcpSocket *client);
    void performDraw(const QJsonObject &cmd);

private:
    QGraphicsScene *scene;
    QImage sharedImage; // 共享画布，用于广播
    QMutex imageMutex;
    QSet<QTcpSocket*> clients;
    QThreadPool pool;

    void broadcastImage();
};

#endif // SERVER_H

#include "Server.h"
#include <QJsonDocument>
#include <QJsonObject>
#include <QPainter>
#include <QGraphicsRectItem>
#include <QGraphicsEllipseItem>
#include <QGraphicsLineItem>
#include <QtConcurrent/QtConcurrent>

Server::Server(QObject *parent) : QTcpServer(parent)
{
    scene = new QGraphicsScene(this);
    sharedImage = QImage(800, 600, QImage::Format_ARGB32);
    sharedImage.fill(Qt::white);
    pool.setMaxThreadCount(4);
}

void Server::startServer(quint16 port)
{
    if (!listen(QHostAddress::Any, port)) {
        qDebug() << "Failed to bind port";
        return;
    }
    qDebug() << "Server started on port" << port;
}

void Server::incomingConnection(qintptr socketDescriptor)
{
    QTcpSocket *socket = new QTcpSocket(this);
    socket->setSocketDescriptor(socketDescriptor);
    connect(socket, &QTcpSocket::readyRead, this, &Server::onReadyRead);
    connect(socket, &QTcpSocket::disconnected, this, &Server::onClientDisconnected);
    clients.insert(socket);
    qDebug() << "New client connected";
}

void Server::onReadyRead()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
    if (!socket) return;
    QByteArray data = socket->readAll();
    // 假设每条消息以换行符结尾（简单分包）
    QList<QByteArray> lines = data.split('\n');
    for (const QByteArray &line : lines) {
        if (line.trimmed().isEmpty()) continue;
        // 将处理任务提交到线程池，避免阻塞主线程网络事件
        QtConcurrent::run(&pool, [this, line, socket]() {
            processDrawCommand(line, socket);
        });
    }
}

void Server::processDrawCommand(const QByteArray &data, QTcpSocket *client)
{
    QJsonParseError err;
    QJsonDocument doc = QJsonDocument::fromJson(data, &err);
    if (err.error != QJsonParseError::NoError) {
        qDebug() << "Invalid JSON" << data;
        return;
    }
    // 解析命令，这里可以做一些耗时预处理（如数据校验、坐标变换）
    // 然后通过信号/槽或直接调用主线程绘图
    QMetaObject::invokeMethod(this, "performDraw", Qt::QueuedConnection,
                              Q_ARG(QJsonObject, doc.object()));
}

void Server::performDraw(const QJsonObject &cmd)
{
    // 此函数在主线程执行，保证绘图安全
    QPainter painter(&sharedImage);
    QString type = cmd["type"].toString();
    QJsonObject params = cmd["params"].toObject();

    painter.setRenderHint(QPainter::Antialiasing);

    if (type == "circle") {
        int x = params["x"].toInt();
        int y = params["y"].toInt();
        int r = params["radius"].toInt();
        QColor color = QColor(params["color"].toString());
        painter.setPen(color);
        painter.drawEllipse(QPoint(x, y), r, r);
    } else if (type == "rectangle") {
        int x = params["x"].toInt();
        int y = params["y"].toInt();
        int w = params["width"].toInt();
        int h = params["height"].toInt();
        QColor color = QColor(params["color"].toString());
        painter.setPen(color);
        painter.drawRect(x, y, w, h);
    } else if (type == "line") {
        int x1 = params["x1"].toInt();
        int y1 = params["y1"].toInt();
        int x2 = params["x2"].toInt();
        int y2 = params["y2"].toInt();
        QColor color = QColor(params["color"].toString());
        painter.setPen(color);
        painter.drawLine(x1, y1, x2, y2);
    } else if (type == "clear") {
        sharedImage.fill(Qt::white);
    }

    painter.end();

    // 广播更新后的图像给所有客户端（可优化为增量发送）
    broadcastImage();
}

void Server::broadcastImage()
{
    // 将 QImage 转为 PNG 数据并广播
    QByteArray imgData;
    QBuffer buffer(&imgData);
    buffer.open(QIODevice::WriteOnly);
    sharedImage.save(&buffer, "PNG");
    buffer.close();

    // 简单添加长度头，实际可压缩
    QByteArray packet;
    packet.append(QString::number(imgData.size()).toUtf8()).append('\n');
    packet.append(imgData);
    for (QTcpSocket *socket : clients) {
        if (socket->state() == QAbstractSocket::ConnectedState) {
            socket->write(packet);
        }
    }
}

void Server::onClientDisconnected()
{
    QTcpSocket *socket = qobject_cast<QTcpSocket*>(sender());
    if (socket) {
        clients.remove(socket);
        socket->deleteLater();
    }
}

#include <QApplication>
#include "Server.h"
#include <QGraphicsView>

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

    Server server;
    server.startServer(8888);

    // 显示服务器端画布（可选）
    QGraphicsView view(server.scene);
    view.show();

    return app.exec();
}

import socket
import json
import time

def send_command(cmd):
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    sock.connect(('localhost', 8888))
    data = json.dumps(cmd) + '\n'
    sock.sendall(data.encode())
    # 接收图像广播（简化，不处理）
    sock.close()

if __name__ == '__main__':
    # 画一个红色圆
    cmd = {
        "type": "circle",
        "params": {"x": 200, "y": 200, "radius": 50, "color": "#FF0000"}
    }
    send_command(cmd)
    time.sleep(0.5)
    # 画一个蓝色矩形
    cmd = {
        "type": "rectangle",
        "params": {"x": 100, "y": 100, "width": 80, "height": 60, "color": "#0000FF"}
    }
    send_command(cmd)