Qu'est-ce que la concurrence en Java ?

Concurrence et parallélisme

Concurrence : fait référence à un certain laps de temps, Plusieurs tâches sont exécutées en alternance. Lorsque plusieurs threads fonctionnent, le temps d'exécution du processeur est divisé en plusieurs périodes, puis les périodes sont allouées à chaque thread pour l'exécution. Pendant que le code d'un thread est en cours d'exécution, les autres threads sont suspendus.

Parallèle : fait référence à la capacité de gérer plusieurs tâches en même temps. Lorsque plusieurs threads fonctionnent, la capacité du processeur à gérer les requêtes de ces threads en même temps.

Ainsi, dans un environnement concurrent, la fermeture du programme est interrompue et les caractéristiques suivantes apparaissent :

1 Il existe une relation de restriction mutuelle entre les programmes concurrents. Les contraintes directes se reflètent dans un programme nécessitant les résultats de calcul d'un autre programme ; les contraintes indirectes se reflètent dans plusieurs programmes en compétition pour des ressources partagées, telles que des processeurs, des tampons, etc.

2. Le processus d'exécution des programmes concurrents est intermittent. Le programme doit mémoriser les instructions sur site et les points d'exécution.

3. Lorsque le nombre de concurrence est défini de manière appropriée et que le processeur dispose d'une puissance de traitement suffisante, la concurrence améliorera l'efficacité de l'exécution du programme.

Dans un environnement concurrent, lorsqu'un objet est accessible par plusieurs threads, l'objet peut être modifié par n'importe quel thread accédé, ce qui entraîne une incohérence des données. Par conséquent, le concept de sécurité des threads est proposé.

Introduction aux concepts de base des threads

Threads et processus

Processus : Chaque processus a un code et un espace de données indépendants (contexte de processus), la commutation entre les processus entraînera une surcharge importante et un processus contient 1 à n threads. (Le processus est la plus petite unité d’allocation de ressources). En termes simples, les processus sont des programmes isolés les uns des autres et exécutés de manière indépendante dans une certaine mesure.

Threads : les threads du même type partagent du code et de l'espace de données. Chaque thread dispose d'une pile d'exécution et d'un compteur de programme (PC) indépendants, et la surcharge de changement de thread est faible. (Le thread est la plus petite unité de planification du processeur)

Les threads sont divisés en cinq étapes comme les processus : création, préparation, exécution, blocage et terminaison.

1. Création : Un nouvel objet thread est créé, mais la méthode start() n'a pas encore été appelée. Par exemple, Thread thread = new Thread();

2. Prêt : une fois l'objet thread créé, d'autres threads (tels que le thread principal) appellent la méthode start() de l'objet. Le thread dans cet état se trouve dans le pool de threads exécutables, en attente d'être sélectionné par la planification des threads pour obtenir le droit d'utiliser le processeur.

3. Exécuter : le thread en cours d'exécution (exécutable) obtient la tranche de temps du processeur (timeslice) et exécute le code du programme.

4. Bloqué (Bloqué) : Le thread est bloqué. La différence entre "l'état bloqué" et "l'état en attente" est la suivante : "l'état bloqué" attend d'acquérir un verrou exclusif. événement. Se produit lorsqu'un thread abandonne le verrou ; et que "l'état d'attente" attend pendant un certain temps, ou qu'une action de réveil se produit. Le thread entrera dans cet état pendant que le programme attend d'entrer dans la zone synchronisée (synchronisée).

(1). En attente de blocage : le thread en cours d'exécution exécute la méthode o.wait() et la JVM placera le thread dans la file d'attente.

(2). Blocage synchrone : lorsqu'un thread en cours d'exécution acquiert le verrou de synchronisation d'un objet, si le verrou de synchronisation est occupé par un autre thread, la JVM placera le thread dans le pool de verrouillage) au milieu.

(3). Autre blocage : lorsque le thread en cours d'exécution exécute la méthode Thread.sleep(long ms) ou t.join(), ou émet une requête d'E/S, la JVM définit le thread sur est en état de blocage. Lorsque l'état sleep() expire, join() attend que le thread se termine ou expire, ou que le traitement des E/S est terminé, le thread revient à l'état exécutable.

5. En attente : le thread entrant dans cet état doit attendre que d'autres threads effectuent certaines actions spécifiques (notification ou interruption).

6. Blocage : lorsqu'un thread tente d'acquérir un verrou d'objet interne (verrou de bibliothèque non-java.util.concurrent) et que le verrou est détenu par d'autres threads, le thread entre dans l'état de blocage.

7. En attente : lorsqu'un thread attend qu'un autre thread informe le planificateur d'une condition, le thread entre dans l'état d'attente. Par exemple, appelez : Object.wait(), Thread.join() et attendez le verrouillage ou la condition.

8. Timeout en attente (TIMED_WAITING) : Cet état est différent de WAITING, il peut revenir tout seul après le temps spécifié.

9. TERMINATED : indique que le thread a terminé son exécution.

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!