c++, des filets de traitement parallèle

Je me demandais comment exécuter deux processus dans un processeur dual-core en c++.

Je sais threads (ou multi-threading) n'est pas une fonctionnalité intégrée de c++.

Il est en charge des threads dans Qt, mais je n'ai pas de comprendre quoi que ce soit à partir de leur référence. 🙁

Donc, est-ce quelqu'un connaît un moyen simple pour un débutant de le faire. Support multi-plateforme (comme Qt) serait très utile depuis que je suis sur Linux.

OriginalL'auteur Kid Green | 2011-04-19

  1. 5

    Essayer le Le Multithreading dans C++0x partie 1: a Partir des Threads comme un 101. Si vous le compilateur n'a pas C++0x de soutien, alors rester avec Coup de pouce.Fil

    OriginalL'auteur dubnde

  2. 3

    Prendre un coup d'oeil à Coup de pouce.Fil. C'est multi-plateforme et une très bonne bibliothèque à utiliser dans vos applications C++.

    Spécifiquement, que voudriez-vous savoir?

    OriginalL'auteur murrekatt

  3. 2

    Les threads POSIX (pthreads) bibliothèque est probablement votre meilleur pari si vous avez juste besoin d'un simple enfilage de la bibliothèque, il a implémentations à la fois sur Windows et Linux.

    Un guide peut être trouvé par exemple ici. Un Win32 mise en œuvre de pthreads peut être téléchargé ici.

    Edit: N'ai pas vu que vous étiez sur Linux. Dans ce cas, je ne suis pas sûr à 100% mais je pense que les bibliothèques sont probablement déjà fournie avec votre installation de GCC.

    OriginalL'auteur Rune Aamodt

  4. 2

    Je vous recommande d'utiliser les bibliothèques Boost Coup de pouce.Fil à la place. Cela permettra d'envelopper les spécificités de la plate-forme de Win32 et Posix, et de vous donner un solide ensemble de filetage et d'objets de synchronisation. Il est aussi très lourd d'utilisation, afin de trouver de l'aide sur les problèmes que vous rencontrez sur soi et les autres sites, c'est facile.

    +1: c'est inclus dans C++0x, il devrait également être à l'avenir.

    OriginalL'auteur holtavolt

  5. 1

    Vous pouvez rechercher un PDF gratuit livre "C++-GUI-Programming-with-Qt-4-1st-ed.zip" et de lire le Chapitre 18 sur du Multi-threading dans Qt.

    La programmation simultanée fonctionnalités prises en charge par Qt inclut (entre autres, les suivantes:

    • Mutex
    • En Lecture Et En Écriture Verrouillage
    • Sémaphore
    • Condition D'Attente
    • Fil De Stockage Spécifique

    Cependant, être au courant de la suite de compromis avec Qt:

    • Pénalités vs natif de bibliothèques. POSIX thread (pthreads) a été natifs Linux depuis le noyau 2.4 et ne peut pas remplacer < processus.h > dans W32API dans toutes les situations.
    • Communication Inter-thread dans Qt est mis en œuvre avec de SIGNAUX et de slots constructions. Ils ne font PAS partie du langage C++ et sont mis en œuvre que pour les macros, qui exige de propriétaires de générateurs de code fourni par Qt pour être entièrement compilé.

    Si vous pouvez vivre avec les limitations ci-dessus, il suffit de suivre ces recettes pour l'utilisation de QThread:

    1. #include < QtCore >
    2. Dériver votre propre classe QThread. Vous devez mettre en place une fonction publique run() qui retourne void contenir des instructions à exécuter.
    3. Instancier votre propre classe et d'appeler la méthode start() pour lancer un nouveau thread.

    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;
}

    OriginalL'auteur user715213

  6. 1

    Comme une remarque importante en c++14, l'utilisation de simultanées filetage est disponible:

    #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
}

    Les deux std::async (std::launch::async, std::launch::deferred) et std::thread sont entièrement compatibles avec Qt, et dans certains cas peut-être mieux en mesure de travailler dans différents environnements d'OS.

    Pour parallèle traitement, voir cette.

    OriginalL'auteur Babra Cunningham