Comment utiliser fork () dans unix? Pourquoi pas quelque chose de la fourche de forme(pointerToFunctionToRun)?

Histoire mise à part, il existe certaines différences fondamentales entre les processus et les fils en ce qui concerne la propriété des ressources et le temps de vie.

lorsque vous bifurquez, le nouveau processus occupe un espace mémoire complètement séparé. C'est une distinction très importante de la création d'un nouveau thread. Dans les applications multi-threadées, vous devez considérer comment vous accédez et manipulez les ressources partagées. Les traitements qui ont été bifurqués doivent explicitement partager les ressources en utilisant les moyens d'inter-processus tels que la mémoire partagée, les pipes, les appels de procédure à distance, les sémaphores, etc.

une autre différence est que les enfants de fork()'ed peuvent survivre à leur parent, où comme tous les fils meurent lorsque le processus se termine.

dans une architecture client-serveur où une disponibilité très, très longue est attendue, l'utilisation de fork() plutôt que de créer des threads pourrait être une stratégie valide pour combattre les fuites de mémoire. Plutôt que de se préoccuper de nettoyer les fuites de mémoire dans votre threads, vous venez de bifurquer un nouveau processus enfant pour traiter chaque demande de client, puis tuer l'enfant lorsque c'est fait. La seule source de fuites de mémoire serait alors le processus parent qui distribue des événements.

une analogie: vous pouvez penser aux fils de fraie comme l'ouverture des onglets à l'intérieur d'une fenêtre de navigateur simple, tandis que bifurcation est comme l'ouverture de fenêtres de navigateur séparées.

il serait plus valide de demander pourquoi CreateNewThread ne renvoie pas simplement un ID de thread comme fork() le fait... après tout, fork() a créé un précédent. Votre opinion est colorée par le fait que vous avez vu l'un avant l'autre. Prenez un peu de recul et considérez que fork() fait double emploi avec le processus et continue l'exécution... quel meilleur endroit qu'à la prochaine instruction? Pourquoi compliquer les choses en ajoutant une fonction appel dans le marché (et puis un ce qui ne prend nul*)?

votre commentaire à Mike dit "Je ne peux pas comprendre dans quels contextes vous voulez l'utiliser.". Fondamentalement, vous l'utilisez quand vous voulez:

• exécuter un autre processus en utilisant la famille de fonctions exec
• faire un certain traitement parallèle indépendamment (en termes d'utilisation de la mémoire, la manipulation du signal, les ressources, la sécurité)
  • par exemple, chaque processus peut avoir des limites intrusives du nombre de descripteurs de fichiers qu'il peut gérer, ou sur un système 32 bits - la quantité de mémoire: un deuxième processus peut partager le travail tout en obtenant ses propres ressources

BTW / utiliser UNIX/Linux ne signifie pas que vous devez abandonner les threads pour les processus de fork()ing... vous pouvez utiliser pthread_create () et releated functions si vous êtes plus à l'aise avec le paradigme du threading.

laisser la différence entre un processus de fraie et un fil mis de côté pour une seconde: fondamentalement, fork() est une primitive plus fondamentale. Tandis que SpawnNewThread doit faire un travail de fond pour obtenir le compteur de programme au bon endroit, fork ne fait pas un tel travail, il copie juste (ou copie virtuellement) votre mémoire de programme et continue le compteur.

Fork est avec nous depuis très, très, très longtemps. Fork a été pensé avant que l'idée de "démarrer un fil tournant une fonction particulière" était une lueur dans l'oeil de n'importe qui.

les gens n'utilisent pas fork parce que c'est "mieux", nous l'utilisons parce que c'est la seule et unique fonction de création de processus en mode utilisateur non privilégié qui fonctionne à travers toutes les variations de Linux. Si vous voulez créer un processus , vous devez appeler fork . Et, pour certaines fins, un processus est ce que vous avez besoin, pas d'un fil.

vous pourriez envisager de faire des recherches sur les premiers documents sur le sujet.

Il est intéressant de noter que les traitement n'est pas exactement la même que de multiples threading . Le nouveau processus créé par fork partage très peu de contexte avec l'ancien, ce qui est très différent du cas des threads.

donc, regardons l'unixy thread système: pthread_create a la sémantique similaire à CreateNewThread .

ou, pour faire demi - tour, regardons le windows (ou java ou un autre système qui fait sa vie avec des threads) façon de générer un processus identique à celui que vous exécutez actuellement (ce qui est ce que fork fait sur unix)...on pourrait, sauf qu'il n'y en a pas: ça ne fait pas partie du modèle all-threads-all-the-time. (Ce qui n'est pas une mauvaise chose, mais c'est différent).

Vous fork chaque fois que vous voulez plus qu'une chose en même temps. Ça s'appelle le multitâche, et c'est vraiment utile.

Voici par exemple un programme telnetish comme:

#!/usr/bin/perl
use strict;
use IO::Socket;
my ($host, $port, $kidpid, $handle, $line);

unless (@ARGV == 2) { die "usage: "151900920" host port" }
($host, $port) = @ARGV;

# create a tcp connection to the specified host and port
$handle = IO::Socket::INET->new(Proto     => "tcp",
                                PeerAddr  => $host,
                                PeerPort  => $port)
       or die "can't connect to port $port on $host: $!";

$handle->autoflush(1);              # so output gets there right away
print STDERR "[Connected to $host:$port]\n";

# split the program into two processes, identical twins
die "can't fork: $!" unless defined($kidpid = fork());

if ($kidpid) {                      
    # parent copies the socket to standard output
    while (defined ($line = <$handle>)) {
        print STDOUT $line;
    }
    kill("TERM" => $kidpid);        # send SIGTERM to child
}
else {                              
    # child copies standard input to the socket
    while (defined ($line = <STDIN>)) {
        print $handle $line;
    }
}
exit;

tu vois comme c'est facile?

Fork () est de cloner un serveur pour chaque nouveau client qui se connecte()s (parce que le nouveau processus hérite de tous les descripteurs de fichiers dans quelque état qu'ils existent). Mais je l'ai également utilisé pour lancer un nouveau service (local running) à la demande d'un client. Ce schéma est le mieux fait avec deux appels à fork() - l'un reste dans la session parent jusqu'à ce que le serveur soit opérationnel et capable de se connecter, l'autre (je le bifurque de l'enfant) devient le serveur et quitte le la session du parent de sorte qu'il ne peut plus être atteint par (disons) SIGQUIT.