Creation des Threads pthread_create & pthread_join sur UBUNTU Lunix et le langage C

Creation des Threads pthread_create & pthread_join sur UBUNTU Lunix et le langage C.
Les threads sont une abstraction de programmation moderne populaire. Ils fournissent plusieurs threads d'exécution au sein du même programme dans un espace d'adressage de mémoire partagé. Ils peuvent également partager des fichiers ouverts et d'autres ressources. Les threads permettent la programmation simultanée et, sur les systèmes à plusieurs processeurs, un véritable parallélisme.
Linux a une implémentation unique des threads. Pour le noyau Linux, il n'y a pas de concept de thread. Linux implémente tous les threads en tant que processus standard. Le noyau Linux ne fournit aucune sémantique de planification ou structure de données spéciale pour représenter les threads. Au lieu de cela, un thread est simplement un processus qui partage certaines ressources avec d'autres processus. Chaque thread a une task_struct unique et apparaît au noyau comme un processus normal (qui partage des ressources, comme un espace d'adressage, avec d'autres processus).
Cette approche des threads contraste fortement avec les systèmes d'exploitation tels que Microsoft Windows ou Sun Solaris, qui ont une prise en charge explicite du noyau pour les threads (et appellent parfois les threads processus légers). Le nom "processus léger" résume la différence de philosophie entre Linux et les autres systèmes. Pour ces autres systèmes d'exploitation, les threads sont une abstraction pour fournir une unité d'exécution plus légère et plus rapide que le processus lourd. Pour Linux, les threads sont simplement une manière de partager des ressources entre processus (qui sont déjà assez légers)11. Par exemple, supposons que vous ayez un processus composé de quatre threads. Sur les systèmes prenant en charge les threads explicites, il peut exister un descripteur de processus qui, à son tour, pointe vers les quatre threads différents. Le descripteur de processus décrit les ressources partagées, telles qu'un espace d'adressage ou des fichiers ouverts. Les fils décrivent alors les ressources qu'ils possèdent seuls. Inversement, sous Linux, il y a simplement quatre processus et donc quatre structures task_struct normales. Les quatre processus sont mis en place pour partager certaines ressources.
Threads are a popular modern programming abstraction. They provide multiple threads of execution within the same program in a shared memory address space. They can also share open files and other resources. Threads allow for concurrent programming and, on multiple processor systems, true parallelism.
Linux has a unique implementation of threads. To the Linux kernel, there is no concept of a thread. Linux implements all threads as standard processes. The Linux kernel does not provide any special scheduling semantics or data structures to represent threads. Instead, a thread is merely a process that shares certain resources with other processes. Each thread has a unique task_struct and appears to the kernel as a normal process (which just happens to share resources, such as an address space, with other processes).
This approach to threads contrasts greatly with operating systems such as Microsoft Windows or Sun Solaris, which have explicit kernel support for threads (and sometimes call threads lightweight processes). The name "lightweight process" sums up the difference in philosophies between Linux and other systems. To these other operating systems, threads are an abstraction to provide a lighter, quicker execution unit than the heavy process. To Linux, threads are simply a manner of sharing resources between processes (which are already quite lightweight)11. For example, assume you have a process that consists of four threads. On systems with explicit thread support, there might exist one process descriptor that in turn points to the four different threads. The process descriptor describes the shared resources, such as an address space or open files. The threads then describe the resources they alone possess. Conversely, in Linux, there are simply four processes and thus four normal task_struct structures. The four processes are set up to share certain resources.

[@molkadhrief6717]

merci mr tres bonne explication

[@zoquevil4792]

Bonjour, J'ai eu le meme resultat dans l'example2 en creant une seule boucle : int main(void)
{
pthread_t thread[4];
// pthread_t thread2;
int i;
printf("bonjour je suis le pere
");
i = 0;
while (i < 4)
{
pthread_create((&thread[i]), NULL, f1, (void*)i);
pthread_join(thread[i], NULL);
i++;
}
// pthread_create((&thread1), NULL, f1, NULL);
// pthread_create((&thread2), NULL, f2, NULL);
// pthread_join() permet d'attendre l'execution de la fonction pthread_create() avant de terminer le programme
// pthread_join(thread1, NULL);
// pthread_join(thread2, NULL);
return EXIT_SUCCESS;
}
Merci pour l'explication, c'est un sujet tout nouveau pour moi ....tres bonne video!