IPC: Memoria compartida

Muestra cómo compartir datos de imagen entre diferentes procesos utilizando el mecanismo de IPC de memoria compartida.

El ejemplo «Memoria compartida» muestra cómo utilizar la clase ` QSharedMemory ` para implementar la comunicación entre procesos mediante memoria compartida. Para compilar el ejemplo, ejecuta `make`. Para ejecutar el ejemplo, inicia dos instancias del ejecutable. La función `main()` crea un objeto ` application ` y una instancia de la clase `Dialog` de nuestro ejemplo. Se muestra el cuadro de diálogo y, a continuación, el control pasa a la aplicación de la forma habitual.

int main(int argc, char *argv[])
{
    QApplication application(argc, argv);
    Dialog dialog;
    dialog.show();
    return application.exec();
}

Aparecen dos instancias de la clase `Dialog`.

Captura de pantalla del ejemplo de «Memoria compartida»

La clase `Dialog` hereda de ` QDialog`. Encapsula la interfaz de usuario y una instancia de ` QSharedMemory`. También tiene dos ranuras públicas, `loadFromFile()` y `loadFromMemory()`, que se corresponden con los dos botones del cuadro de diálogo.

class Dialog : public QDialog
{
    Q_OBJECT

public:
    Dialog(QWidget *parent = nullptr);

public slots:
    void loadFromFile();
    void loadFromMemory();

private:
    void detach();

private:
    Ui::Dialog ui;
    QSharedMemory sharedMemory;
};

El constructor crea los widgets de la interfaz de usuario y conecta la señal clicked() de cada botón a la función de ranura correspondiente.

Dialog::Dialog(QWidget *parent)
    : QDialog(parent), sharedMemory(QNativeIpcKey(u"QSharedMemoryExample"_s))
{
    ui.setupUi(this);
    connect(ui.loadFromFileButton, &QPushButton::clicked,
            this, &Dialog::loadFromFile);
    connect(ui.loadFromSharedMemoryButton, &QPushButton::clicked,
            this, &Dialog::loadFromMemory);
    setWindowTitle(tr("SharedMemory Example"));
}

Ten en cuenta que se pasa «QSharedMemoryExample» al constructor de ` QSharedMemory() ` para que se utilice como clave. El sistema lo utilizará como identificador del segmento de memoria compartida subyacente.

Haz clic en el botón « Load Image From File... » de uno de los cuadros de diálogo. Se invoca la función de conexión loadFromFile(). En primer lugar, comprueba si ya hay un segmento de memoria compartida asociado al proceso. Si es así, dicho segmento se desvincula del proceso, lo que nos garantiza que el ejemplo se inicia correctamente.

void Dialog::loadFromFile()
{
    if (sharedMemory.isAttached())
        detach();

    ui.label->setText(tr("Select an image file"));
    QString fileName = QFileDialog::getOpenFileName(0, QString(), QString(),
                                        tr("Images (*.png *.xpm *.jpg)"));
    QImage image;
    if (!image.load(fileName)) {
        ui.label->setText(tr("Selected file is not an image, please select another."));
        return;
    }
    ui.label->setPixmap(QPixmap::fromImage(image));

A continuación, se solicita al usuario que seleccione un archivo de imagen mediante ` QFileDialog::getOpenFileName()`. El archivo seleccionado se carga en un ` QImage`. El uso de ` QImage ` nos permite asegurarnos de que el archivo seleccionado es una imagen válida, y también nos permite mostrar inmediatamente la imagen en el cuadro de diálogo mediante `setPixmap()`.

A continuación, la imagen se transmite a un ` QBuffer ` mediante un ` QDataStream`. Esto nos proporciona el tamaño, que luego utilizamos para llamar a ` create()` en nuestro segmento de memoria compartida. Al crear un segmento de memoria compartida, este se asigna automáticamente al proceso mediante ` attaches `. El uso de ` QBuffer ` en este punto nos permite obtener un puntero a los datos de la imagen, que luego utilizamos para realizar un `memcopy()` desde el ` QBuffer ` al segmento de memoria compartida.

    // load into shared memory
    QBuffer buffer;
    buffer.open(QBuffer::ReadWrite);
    QDataStream out(&buffer);
    out << image;
    int size = buffer.size();

    if (!sharedMemory.create(size)) {
        if (sharedMemory.error() == QSharedMemory::AlreadyExists) {
            sharedMemory.attach();
        } else {
            ui.label->setText(tr("Unable to create or attach to shared memory segment: %1")
                                .arg(sharedMemory.errorString()));
            return;
        }
    }
    sharedMemory.lock();
    char *to = (char*)sharedMemory.data();
    const char *from = buffer.data().data();
    memcpy(to, from, qMin(sharedMemory.size(), size));
    sharedMemory.unlock();
}

Ten en cuenta que lock() el segmento de memoria compartida antes de copiar en él, y que unlock() de nuevo inmediatamente después de la copia. Esto garantiza que tengamos acceso exclusivo al segmento de memoria compartida para realizar nuestro memcopy(). Si algún otro proceso tiene bloqueado el segmento, nuestro proceso se bloqueará hasta que el bloqueo quede disponible.

Obsérvese también que la función no utiliza ` detach()` para liberar el segmento de memoria compartida tras la llamada a `memcopy()` y `unlock()`. Recordemos que, cuando el último proceso se desvincula de un segmento de memoria compartida, el sistema operativo libera dicho segmento. Dado que este proceso es el único conectado al segmento de memoria compartida en este momento, si loadFromFile() se desconectara del segmento de memoria compartida, el segmento se destruiría antes de que pudiéramos pasar al siguiente paso.

Cuando la función devuelva el resultado, si el archivo seleccionado era qt.png, el primer cuadro de diálogo tendrá este aspecto.

Captura de pantalla del ejemplo de «Memoria compartida»

En el segundo cuadro de diálogo, haz clic en el botón « Display Image From Shared Memory ». Se invoca la ranura `loadFromMemory()`. En primer lugar, ` attaches ` el proceso al mismo segmento de memoria compartida creado por el primer proceso. A continuación, ` locks ` el segmento para obtener acceso exclusivo y vincula un ` QBuffer ` a los datos de la imagen en el segmento de memoria compartida. Después, transfiere los datos a un ` QImage ` y ` unlocks ` el segmento.

void Dialog::loadFromMemory()
{
    if (!sharedMemory.attach()) {
        ui.label->setText(tr("Unable to attach to shared memory segment.\n" \
                             "Load an image first."));
        return;
    }

    QBuffer buffer;
    QDataStream in(&buffer);
    QImage image;

    sharedMemory.lock();
    buffer.setData((char*)sharedMemory.constData(), sharedMemory.size());
    buffer.open(QBuffer::ReadOnly);
    in >> image;
    sharedMemory.unlock();

    sharedMemory.detach();
    ui.label->setPixmap(QPixmap::fromImage(image));
}

En este caso, la función ejecuta ` detach()` desde el segmento, ya que, en la práctica, hemos terminado de utilizarlo. Por último, se muestra el QImage. En este momento, ambos cuadros de diálogo deberían mostrar la misma imagen. Al cerrar el primer cuadro de diálogo, el destructor de Dialog llama al destructor de QSharedMemory, que se desvincula del segmento de memoria compartida. Dado que este es el último proceso en desvincularse del segmento, el sistema operativo liberará ahora la memoria compartida.

Proyecto de ejemplo en code.qt.io

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.