c++ threads - parallel processing

Ich Frage mich, wie führen zwei Prozesse in einer dual-core-Prozessor in c++.

Ich weiß, threads (oder multi-threading) ist nicht ein built-in feature von c++.

Es ist threading-Unterstützung in Qt, aber ich Verstand nichts von der Referenz. 🙁

So, weiß jemand eine einfache Möglichkeit für einen Anfänger, es zu tun. Cross-platform Unterstützung (wie Qt) wäre sehr hilfreich da ich mich auf Linux.

InformationsquelleAutor Kid Green | 2011-04-19

  1. 5

    Versuchen die Multithreading in C++0x, Teil 1: Starten von Threads als 101. Wenn Sie der compiler nicht haben C++0x unterstützen, dann bleiben Sie mit Boost.Thread

    InformationsquelleAutor dubnde

  2. 3

    Werfen Sie einen Blick auf Boost.Thread. Dies ist cross-Plattform und eine sehr gute Bibliothek zu verwenden, die in Ihrem C++ - Anwendungen.

    Was speziell möchtest du wissen?

    InformationsquelleAutor murrekatt

  3. 2

    Den POSIX-Threads (pthreads) - Bibliothek ist wahrscheinlich Ihre beste Wette, wenn Sie brauchen nur einen einfachen threading-Bibliothek, hat es Implementierungen sowohl auf Windows und Linux.

    Eine Anleitung findet man z.B. hier. Eine Win32-Umsetzung von pthreads heruntergeladen werden kann hier.

    Edit: Wollte nicht sehen, Sie waren auf Linux. In diesem Fall bin ich mir nicht 100% sicher, aber ich denke, die Bibliotheken sind wahrscheinlich schon gebündelt mit Ihrem GCC-installation.

    InformationsquelleAutor Rune Aamodt

  4. 2

    Ich würde empfehlen, mit der Boost-Bibliotheken Boost.Thread statt. Diese wrap-Plattform Besonderheiten von Win32-und Posix, und geben Ihnen ein festes set von threading und Synchronisation von Objekten. Es ist auch in sehr schweren Gebrauch, so finden Sie Hilfe zu allen Fragen, die Sie stoßen auf SO und auf anderen Seiten ist einfach.

    +1: das ist enthalten in C++0x, so sollte es auch zukunftssicher sein.

    InformationsquelleAutor holtavolt

  5. 1

    Können Sie die Suche nach einem kostenlosen PDF-Buch "C++-GUI-Programming-with-Qt-4-1st-ed.zip" und Lesen Sie Kapitel 18 über Multi-threading in Qt.

    Concurrent programming unterstützte Funktionen von Qt beinhaltet (nicht beschränkt auf) die folgenden:

    • Mutex
    • Read Write Lock
    • Semaphore
    • Warten-Bedingung
    • Thread-Specific Storage

    Allerdings bewusst sein, die folgenden trade-offs mit Qt:

    • Leistungseinbußen vs native threading-Bibliotheken. POSIX-Threads (pthreads) wurde native Linux ab kernel 2.4 und auch kein Ersatz für < Prozess.h > in W32API in allen Situationen.
    • Inter-thread-Kommunikation in Qt implementiert ist, mit SIGNAL-und SLOT-Konstrukte. Diese sind NICHT Teil der Sprache C++ und umgesetzt werden, wie Makros, die benötigt proprietäre code-Generatoren zur Verfügung gestellt von Qt werden vollständig zusammengestellt.

    Wenn Sie Leben können mit den oben genannten Einschränkungen, Folgen Sie einfach diese Rezepte für die Verwendung von QThread:

    1. #include < QtCore >
    2. Leiten Sie Ihre eigene Klasse von QThread. Sie müssen implementieren eine public function run (), die void zurückgibt enthalten Anweisungen ausgeführt werden.
    3. Instantiierung der eigenen Klasse und Aufruf der start () - zum Auftakt eines neuen Threads.

    Sameple Code:

    #include <QtCore>

class MyThread : public QThread {
public:
    void run() {
        //do something
    }
};

int main(int argc, char** argv) {
    MyThread t1, t2;
    t1.start(); //default implementation from QThread::start() is fine
    t2.start(); //another thread
    t1.wait();  //wait for thread to finish
    t2.wait();
    return 0;
}

    InformationsquelleAutor user715213

  6. 1

    Als ein wichtiger Hinweis in c++14, die Verwendung von gleichzeitige threading verfügbar ist:

    #include<thread>

class Example
{
  auto DoStuff() -> std::string
  { 
    return "Doing Stuff";
  }

  auto DoStuff2() -> std::string
  {
    return "Doing Stuff 2";
  }
};

int main() 
{
  Example EO;
  std::string(Example::*func_pointer)();
  func_pointer = &Example::DoStuff;
  std::future<string> thread_one = std::async(std::launch::async, func_pointer, &EO); //Launching upon declaring

  std::string(Example::*func_pointer_2)();
  func_pointer_2 = &Example::DoStuff2;
  std::future<string> thread_two = std::async(std::launch::deferred, func_pointer_2, &EO);
  thread_two.get(); //Launching upon calling
}

    Beide std::async (std::launch::async, std::launch::deferred) und std::thread sind voll kompatibel mit Qt, und in einigen Fällen kann es besser sein, bei der Arbeit in den verschiedenen OS-Umgebungen.

    Für parallel Verarbeitung, siehe diese.

    InformationsquelleAutor Babra Cunningham

Schreibe einen Kommentar