Wenn ich zwei Instanzen von Glib :: IOChannel haben, blockieren sie, bis beide geschrieben. Was ist der richtige Weg, dies zu tun?

Question

Ich habe das Beispiel gefunden modifiziert hier zwei io Kanäle zu verwenden. Keiner der Rückrufe scheint genannt zu werden, bevor ich auf beiden Kanäle geschrieben habe. Danach werden sie einzeln aufgerufen, wenn der fifos zu schreiben. Bin ich etwas vergessen?

• Starten Sie das Testprogramm in einem Shell-Fenster.
• schreibt echo "abc"> testfifo1 in der zweiten Shell-Fenster. -> nichts passiert
.
• schreiben echo "def"> testfifo2 in einem dritten Shell-Fenster. -> jetzt ich "abc" und "def"
• Schreibe eine der fifos. Dies wird sofort serviert.

Edit: Die Lösung, wie Gormley unten angedeutet, war der Mangel an nonblock.

read_fd1 = open("testfifo1", O_RDONLY | O_NONBLOCK);
...
read_fd2 = open("testfifo2", O_RDONLY | O_NONBLOCK);

Diese Änderung des Code unten machte es sofort reagieren.

Der Code:

#include <gtkmm/main.h>
#include <fcntl.h>
#include <iostream>

int read_fd1, read_fd2;
Glib::RefPtr<Glib::IOChannel> iochannel1, iochannel2;

// Usage: "echo "Hello" > testfifo<1|2>", quit with "Q"

bool MyCallback1(Glib::IOCondition io_condition)
{
    Glib::ustring buf;
    iochannel1->read_line(buf);
    std::cout << "io 1: " << buf;

    if (buf == "Q\n")
        Gtk::Main::quit();

    return true;
}

bool MyCallback2(Glib::IOCondition io_condition)
{
    Glib::ustring buf;
    iochannel2->read_line(buf);
    std::cout << "io 2: " << buf;

    if (buf == "Q\n")
        Gtk::Main::quit();

    return true;
}

int main(int argc, char *argv[])
{
    // the usual Gtk::Main object
    Gtk::Main app(argc, argv);

    if (access("testfifo1", F_OK) == -1)
    {
        if (mkfifo("testfifo1", 0666) != 0)
            return -1;
    }

    if (access("testfifo2", F_OK) == -1)
    {
        if (mkfifo("testfifo2", 0666) != 0)
            return -1;
    }

    read_fd1 = open("testfifo1", O_RDONLY);

    if (read_fd1 == -1)
        return -1;

    read_fd2 = open("testfifo2", O_RDONLY);

    if (read_fd2 == -1)
        return -1;

    Glib::signal_io().connect(sigc::ptr_fun(MyCallback1), read_fd1, Glib::IO_IN);
    Glib::signal_io().connect(sigc::ptr_fun(MyCallback2), read_fd2, Glib::IO_IN);

    iochannel1 = Glib::IOChannel::create_from_fd(read_fd1);
    iochannel2 = Glib::IOChannel::create_from_fd(read_fd2);

    app.run();

    if (unlink("testfifo1"))
        std::cerr << "error removing fifo 1" << std::endl;

    if (unlink("testfifo2"))
        std::cerr << "error removing fifo 2" << std::endl;

    return 0;
}

Answer 1

Diese beiden Aussagen blockieren das Programm aus, bis beide fifos in die Hauptschleife bekommen sind für Schreib offen. FIFOs blockieren, bis beide Seiten verbunden sind

iochannel1 = Glib :: IOChannel :: create_from_fd (read_fd1); iochannel2 = Glib :: IOChannel :: create_from_fd (read_fd2);