Quelqu'un peut-il expliquer la différence entre une fourchette et un fil?

Un fork vous donne un tout nouveau processus, qui est une copie du processus actuel, avec les mêmes segments de code. Au fur et à mesure que l'image mémoire change (en général, cela est dû à un comportement différent des deux processus), vous obtenez une séparation des images mémoire (copie à l'écriture), mais le code exécutable reste le même. Les tâches ne partagent pas la mémoire, sauf si elles utilisent une primitive IPC (Inter Process Communication) .

Un processus peut avoir plusieurs threads, chacun s'exécutant en parallèle dans le même contexte du processus. La mémoire et les autres ressources sont partagées entre les threads, par conséquent, les données partagées doivent être accessibles via certains objets primitifs et de synchronisation (comme les mutex , les variables de condition et les sémaphores ) qui vous permettent d'éviter la corruption des données.

Fourchette

Fork n'est rien d'autre qu'un nouveau processus qui ressemble exactement à l'ancien ou au processus parent, mais il s'agit toujours d'un processus différent avec un ID de processus différent et ayant sa propre mémoire. Le processus parent crée un espace d'adressage séparé pour l'enfant. Les processus parent et enfant possèdent le même segment de code, mais s'exécutent indépendamment l'un de l'autre.

L'exemple le plus simple de forking est lorsque vous exécutez une commande sur un shell sous Unix / Linux. Chaque fois qu'un utilisateur émet une commande, le shell active un processus enfant et la tâche est terminée.

Lorsqu'un appel système fork est émis, une copie de toutes les pages correspondant au processus parent est créée, chargée dans un emplacement mémoire séparé par le système d'exploitation pour le processus enfant, mais dans certains cas, cela n'est pas nécessaire. Comme dans les appels système 'exec', il n'est pas nécessaire de copier les pages du processus parent, car execv remplace l'espace d'adressage du processus parent lui-même.

Peu de choses à noter à propos de la fourche sont:

• Le processus enfant aura son propre ID de processus unique.
• Le processus fils doit avoir sa propre copie du descripteur de fichier parent.
• Les verrous de fichier définis par le processus parent ne doivent pas être hérités par le processus enfant.
• Tous les sémaphores ouverts dans le processus parent doivent également l'être dans le processus enfant.
• Le processus enfant doit avoir sa propre copie des descripteurs de file d'attente de messages du parent.
• L'enfant aura son propre espace d'adressage et sa propre mémoire.

Fils

Les threads sont des processus légers (LWP). Traditionnellement, un thread n'est qu'un état du processeur (et un autre état minimal) avec le processus contenant le reste (données, pile, E / S, signaux). Les threads nécessitent moins de temps système que «forking» ou engendrer un nouveau processus car le système n'initialise pas un nouvel espace de mémoire virtuelle système et un nouvel environnement pour le processus. Bien que plus efficace sur un système multiprocesseur où le flux de processus peut être programmé pour s'exécuter sur un autre processeur, gagnant ainsi en vitesse grâce au traitement parallèle ou distribué, des gains sont également trouvés sur les systèmes monoprocesseurs qui exploitent la latence des E / S et d'autres fonctions système qui peuvent interrompre le processus. exécution.

Les threads du même processus partagent:

• instructions de processus
• la plupart des données
• fichiers ouverts (descripteurs)
• signaux et gestionnaires de signaux
• répertoire de travail actuel
• identifiant d'utilisateur et de groupe

Plus de détails peuvent être trouvés ici .

La réponse de Dacav est excellente, je voulais juste ajouter que tous les modèles de threads ne vous offrent pas un véritable multi-traitement.

Par exemple, l'implémentation de threads par défaut de Ruby n'utilise pas de vrais threads OS / noyau. Au lieu de cela, il imite plusieurs threads en basculant entre les objets Thread au sein d'un seul thread / processus du noyau.

Ceci est important sur les systèmes multiprocesseurs / multicœurs, car ces types de threads légers ne peuvent s'exécuter que sur un seul cœur - vous n'obtenez pas beaucoup d'amélioration des performances en ayant plusieurs threads.

L'autre endroit où cela fait une différence est lorsqu'un thread bloque (en attente d'E / S ou en appelant l'IOCTL d'un pilote), tous les threads bloquent.

Ce n'est pas très courant de nos jours - la plupart des implémentations de threads utilisent des threads du noyau qui ne souffrent pas de ces problèmes - mais il vaut la peine de se concentrer pour être complet.

En revanche, fork vous donne un autre processus qui est exécutable simultanément sur un autre processeur physique pendant que le processus d'origine est en cours d'exécution. Certaines personnes trouvent IPC plus adapté à leur application, d'autres préfèrent le filetage.

Bonne chance et amusez-vous bien! Le multi-threading est à la fois stimulant et gratifiant.

Les threads sont des fonctions exécutées en parallèle, fork est un nouveau processus avec héritage des parents. Les threads sont bons pour exécuter une tâche en parallèle, tandis que les fourches sont des processus indépendants, qui s'exécutent également simultanément. Les threads ont des conditions de course et y contrôlent des sémaphores et des verrous ou des mutex, les tuyaux peuvent à la fois être utilisés dans fork et thread.