Avantages du multithreading Java

La raison pour laquelle le multithreading est toujours utilisé malgré les défis est que le multithreading présente encore plusieurs avantages, certains de ces avantages sont :

• Meilleure utilisation des ressources

• Programmation simple dans certains scénarios

• Programme de réponse plus rapide

Meilleure utilisation des ressources

Imaginez une application lisant et traitant des fichiers du système de fichiers local. Disons que la lecture d'un fichier à partir du disque prend 5 secondes, son traitement prend 2 secondes, l'exécution des deux fichiers prendra : Lors de la lecture d'un fichier à partir du disque, la majeure partie du temps CPU est passée à attendre que le fichier soit lu. À ce moment-là, le processeur est plutôt inactif. Cela peut faire d'autres choses. En modifiant l'ordre de cette opération, le processeur peut être mieux utilisé. Regardez cette séquence :

  5 seconds reading file A
  2 seconds processing file A
  5 seconds reading file B
  2 seconds processing file B
-----------------------
 14 seconds total

Le processeur attend que le premier fichier soit lu. Ensuite, il commence à lire le deuxième fichier. Pendant la lecture du deuxième fichier, cette CPU exécute le premier fichier. N'oubliez pas que ce processeur est inactif la plupart du temps en attendant que les fichiers soient lus à partir du disque.

  5 seconds reading file A
  5 seconds reading file B + 2 seconds processing file A
  2 seconds processing file B
-----------------------
 12 seconds total

Normalement, le processeur peut faire d'autres choses en attendant les E/S. Il ne doit pas nécessairement s'agir d'E/S disque. Il peut également s'agir d'E/S réseau ou d'une entrée d'un utilisateur. Les E/S réseau et disque sont beaucoup plus lentes que les E/S CPU et mémoire.

Programmation plus simple

Si vous écrivez manuellement la séquence ci-dessus de lecture et de traitement de fichiers dans une application monothread, vous devrez suivre l’état de chaque fichier lu et traité. Au lieu de cela, vous pouvez démarrer deux threads, chacun lisant et traitant simplement un fichier distinct. Chacun de ces threads sera bloqué en attendant que le disque lise le fichier. En attendant, d'autres threads peuvent utiliser le processeur pour traiter des parties du fichier qu'ils ont déjà lu. Le résultat est que le disque restera constamment occupé à lire divers fichiers en mémoire. Le résultat est une meilleure utilisation du disque et du processeur. Il sera également plus simple à programmer, puisqu'un thread ne suit qu'un seul fichier. Programmes de réponse plus rapides

Un autre objectif commun est de convertir une application monothread en une application multithread. Imaginez une application serveur qui écoute sur certains ports les requêtes entrantes. Lorsqu'une demande est reçue, il traite la demande puis revient à l'écoute. Ce cycle du serveur se résume comme suit :

Si cette requête prend beaucoup de temps à traiter, aucun nouveau client n'envoie de requête au serveur pendant ce temps. Seul le serveur peut écouter les demandes entrantes.

 while(server is active){
    listen for request
    process request
  }

Une conception alternative consiste pour le thread d'écoute à transmettre une requête à un thread de travail et à revenir immédiatement à l'écoute. Ce thread de travail exécutera la requête et enverra une réponse au client. La conception est décrite comme suit

De cette façon, le thread du serveur reviendra rapidement à dispositif d'écoute. Ainsi, davantage de clients peuvent envoyer des requêtes au serveur. Le serveur est devenu plus réactif.

while(server is active){
    listen for request
    hand request to worker thread
  }

Il en va de même pour les applications de bureau. Si vous cliquez sur un bouton pour démarrer une tâche de longue durée et que le thread qui exécute la tâche est le thread qui met à jour les fenêtres, les boutons, etc., lorsque la tâche est exécutée, l'application ne répond plus. Au lieu de cela, cette tâche peut être convertie en thread de travail. Pendant que le thread de travail est occupé à traiter des tâches, le thread de fenêtre est libre de répondre aux autres demandes des utilisateurs. Lorsque le thread de travail se termine, il signale le thread de fenêtre. Le thread de fenêtre peut ensuite mettre à jour la fenêtre de l'application en fonction des résultats de cette tâche. Les programmes conçus à l'aide de threads de travail donneront aux utilisateurs des réponses plus rapides.

Ce qui précède est le contenu des avantages du multi-threading Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !