Apprentissage Java : Qu'est-ce qu'un fil de discussion ? L'explication la plus détaillée

Qu'est-ce qu'un thread : parfois appelé processus léger, il s'agit de la plus petite unité du flux d'exécution d'un programme.

Un thread standard est composé d'un ID de thread, d'un pointeur d'instruction actuel (PC), d'un ensemble de registres et d'une pile.

Un processus est composé d'un ou plusieurs threads. Chaque thread partage l'espace mémoire du programme (y compris les segments de code, les tas de segments de données, etc.) et certaines ressources au niveau du processus (telles que les fichiers ouverts et les signaux)

Plusieurs threads peuvent s'exécuter simultanément sans interférer les uns avec les autres, et partager des variables globales du processus et des données du tas

Autorisations d'accès des threads

Les threads ont des droits d'accès très libres et peuvent accéder à toutes les données de la mémoire du processus

Planification et priorité des threads

Un seul processeur correspond à plusieurs threads : le système d'exploitation laisse ces multiples threads s'exécuter à tour de rôle, à chaque fois ne s'exécutant que pendant une courte période de temps (généralement des dizaines de secondes), de sorte que chaque thread "ressemble" à Exécuté simultanément ; l'opération de commutation continue des threads sur un tel processeur devient une « planification des threads »

Il y a trois états dans la planification des threads :

(

1) : En cours d'exécution, le fil est en cours d'exécution en ce moment

(

2 ) : Prêt, à ce moment le thread peut s'exécuter immédiatement, mais CPU a été occupé

(

3) : En attente. À ce moment, le thread attend qu'un événement se produise et ne peut pas être exécuté

Chaque fois qu'un programme quitte l'état d'exécution, le système de planification. sélectionnera un thread prêt à exécuter ; Un thread en état d'attente entre dans l'état prêt après qu'un événement se produit.

Dans le cas de la planification des priorités, il existe généralement trois façons de modifier la priorité des threads :

Spécifiée par l'utilisateur Priorité ;

Augmenter ou diminuer la priorité en fonction de la fréquence d'entrée en état d'attente

La priorité sera augmentée si elle n'est pas exécutée pendant une longue période ; Multi-threading Linux

Sous Linux, vous pouvez utiliser les trois méthodes suivantes pour créer une nouvelle tâche :

(1) fork : copier le processus en cours

(2) exec: use new L'image exécutable écrase l'image exécutable actuelle

(3) clone : ​​Créez un processus enfant et démarrez l'exécution à partir de l'emplacement spécifié

fork :

pid_t pid;

if(pid==fork()){…}

Après l'appel fork, une nouvelle tâche est démarrée et renvoyée par la fonction fork avec cette tâche, mais la différence est que le fork de cette tâche renverra le pid de la nouvelle tâche, et le fork de la nouvelle tâche renverra 0 ;

fork génère de nouvelles tâches très rapidement, car fork ne copie pas l'espace mémoire ; de la tâche d'origine, mais partage un

avec la tâche d'origine Copiez l'espace mémoire de

lors de l'écriture de

dit ; copier en écrivant

 : signifie que deux tâches peuvent être effectuées en même temps. Lisez la mémoire librement, mais lorsqu'une tâche tente de modifier la mémoire, une copie de la mémoire sera fournie à la partie modificatrice pour utilisation séparée, afin de ne pas affecter l'utilisation d'autres tâches ;

fork ne peut générer que l'image de cette tâche, vous doit utiliser exec pour démarrer d'autres nouvelles tâches. exec peut remplacer l'image exécutable actuelle par une nouvelle image exécutable, donc après que fork ait généré une nouvelle tâche, la nouvelle tâche peut appeler exec pour exécuter le nouveau fichier exécutable

Les fichiers d'en-tête sont définis dans pthread.h

Créer un fil de discussion : #include

int pthread_create (pthread_t *thread,const pthread_attr_t* attr,void*(*start_routine)( void*),void*arg)

Le paramètre de thread est l'identifiant du nouveau thread, les fonctions pthread_* suivantes font référence au nouveau thread à travers celui-ci

Le paramètre attr est utilisé pour définir les attributs du nouveau thread. Lui transmettre NULL signifie utiliser les attributs de thread par défaut.

Les paramètres Start_routine et arg spécifient respectivement les fonctions et les paramètres que le nouveau thread exécutera ; ;

pthread_create renvoie 0 en cas de succès et un code d'erreur en cas d'échec

Fin d'un fil : void pthread_exit(void *retval)

La fonction transmet ses informations de sortie au recycleur du thread via le paramètre retval ;

Sécurité des threads :

Les programmes multithreads sont dans un environnement changeant, et les variables globales et les données de tas accessibles peuvent être modifiées par d'autres threads à tout moment ;

Moyens : Synchronisation et verrouillage

Atomique : Une opération d'instruction unique est appelée atomique Dans tous les cas, l'exécution d'une seule instruction. ne sera pas interrompu ;

Afin d'éviter des conséquences imprévisibles causées par plusieurs threads lisant et écrivant les mêmes données en même temps, nous devons synchroniser l'accès de chaque thread aux mêmes données (le soi-disant moyen de synchronisation que lorsqu'un thread accède aux données avant qu'elles ne soient terminées, les autres threads ne doivent pas accéder aux mêmes données), par conséquent, l'accès aux données est atomique

Méthodes courantes de synchronisation : (sémaphore, mutex, section critique, verrou en lecture-écriture, variable de condition)

Verrouillage : chaque thread tente d'abord d'acquérir un verrou lors de l'accès aux données ou aux ressources, et libère le verrou une fois l'accès terminé. ;

Sémaphore : Lorsqu'un thread accède à une ressource, il acquiert d'abord un sémaphore ;

fonctionne comme suit :

(1) Diminuer la valeur du sémaphore de 1 ;

(2) Si la valeur du sémaphore est inférieure à 0, entrez dans l'état d'attente ; sinon continuez l'exécution

Après avoir accédé à la ressource, le thread libère le sémaphore ; 🎜> (3) Augmentez la valeur du sémaphore de 1 ;

(4) Si la valeur du sémaphore est inférieure à 1, réveillez un thread en attente

mutex

&&sémaphore identique à : ressource uniquement Autoriser un thread à accéder en même temps

Exception : le sémaphore peut être acquis ; et libéré par n'importe quel thread de l'ensemble du système. C'est-à-dire que le même sémaphore peut être acquis par un autre thread du système

Le mutex nécessite quel thread acquiert le mutex, dont le thread est responsable. libérer le verrou. Il n'est pas valide pour d'autres threads de libérer le mutex en leur nom

Section critique :

est une méthode de synchronisation plus stricte qu'un mutex L'acquisition. du verrou dans la section critique est appelé entrée dans la section critique

et le déverrouillage est appelé sortie de section critique ;

Différence (avec sémaphore et mutex)

Le mutex et le sémaphore sont visibles dans n'importe quel processus du système

C'est-à-dire qu'un processus après un mutex ou un sémaphore est ; créé, il est légal qu'un autre processus tente d'acquérir le verrou

La portée de la section critique est limitée à ce processus, et les autres processus ne peuvent pas acquérir le verrou

Lire -verrouillage en écriture :

Deux méthodes : exclusive partagée

Lorsque le verrou est à l'état libre, essayez n'importe quelle méthode d'acquisition du verrou peut réussir et mettre la serrure dans l'état correspondant ; (comme indiqué ci-dessus)

Variable de condition :

Comme moyen de synchronisation, il agit comme une clôture ; Pour les variables de condition, les threads ont deux opérations :

(1) Premièrement, les threads peuvent attendre les variables de condition, et une variable de condition peut être attendue par plusieurs threads

( 2) Le thread ; peut réveiller la variable de condition. À ce moment, un ou tous les threads en attente de cette variable de condition seront réveillés et continueront à prendre en charge l'occurrence d'un événement, lorsque l'événement se produit, tous les threads peuvent reprendre l'exécution ensemble).

Articles associés :

Qu'est-ce qu'un processus ? Qu'est-ce qu'un fil de discussion ?

Méthode d'implémentation du multi-threading basée sur l'apprentissage java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!