Concurrence en Java

Lorsque nous développons des logiciels, il est souvent utile que son exécution se fasse avec plusieurs fils d’instructions en parallèles. Par exemple, un serveur web doit pouvoir servir plusieurs utilisateurs en même temps plutôt que l’un à la suite de l’autre. En utilisant le parallélisme, ce modèle de programmation amène aussi quelques maux de têtes en ce qui a trait aux variables partagées puisqu’elles ne doivent pas être lues en même temps d’être modifiées.

Cet article porte sur comment créer des fils d’exécutions et comment utiliser des variables partagées avec Java.

Créer de la concurrence

Le choix le plus simple est de créer un Thread manuellement. Si par-contre, vous avez plusieurs tâches à exécuter et vous ne désirez pas créer un Thread par tâche (par exemple si vous en avez 2000, cela rendrait votre application totalement morte), vous pouvez utiliser un Executor qui se charge de créer un bassin de Threads et de partager l’exécution des tâches parmi ces fils.

Que ce soit en utilisant un Thread ou un Executor, vos tâches doivent implémenter l’interface Runnable. Si vous créez une classe de ce type, vous pouvez surveiller l’exécution de votre classe en vérifiant si le Thread associé est terminé. Le seul problème est que si votre classe est donnée à un Executor, il n’est plus possible de vérifier l’état de la progression aisément. C’est pourquoi, vous pouvez utiliser l’interface FutureTask à la place. Dépendant de ce que vous désirez faire, vous pouvez vérifier si le travail est terminé ou encore bloquer votre fil courant tant que la tâche n’est pas terminée.

Partager des variables en restreignant l’accès

Pour éviter plusieurs fils d’écrire/lire en même temps une même variable, il est possible d’utiliser plusieurs mécanismes de verrouillage. Le plus connu est le mot clé Synchronize qui peut être utilisé sur une méthode d’une classe ou sur un objet. En l’utilisant sur plusieurs méthodes, une seule de ces méthodes peut être exécutée à la fois. Ceci est donc bon lorsque toutes les propriétés d’une classe sont dépendantes entre-elles, sinon le verrouillage nuira aux performances. Pour bloquer des propriétés/objets selon quelle fonction accède à quelle objet, il faut utiliser le mot clé sur l’objet utilisé.

Si vous désirez limiter le nombre de fils qui peuvent accéder à une ressource quelconque à tout moment, vous pouvez utiliser un Semaphore. Cet objet est initialisé avec un nombre maximum de jetons à partager et tous les fils tentent de prendre un jeton et doivent peut-être attendre que l’un d’eux devienne disponible.

Partager des variables atomiques

Si vous n’avez de besoin que d’une simple variable (comme un nombre entier) auquel vous effectuez un incrément ou tout autre opération légère, il vous faut quand même barrer cet objet durant sa mise à jour puisque l’objet pourrait devenir invalide pendant qu’un autre fil veuille le lire. Verrouiller un objet prend du temps et c’est pourquoi vous pouvez vous en tirer grâce aux objets atomiques. Chaque opération effectuée dessus ceux-ci se fait assurément par un seul fil et elle sera obligatoirement complétée avant qu’un autre fil lui touche. Vous avez donc des AtomicInteger, AtomicBoolean, AtomicLong, …

Partager des listes

Les collections d’objets sont souvent une nécessité dans toutes les applications. Par contre, ces entités sont très capricieuses lorsqu’il s’agit d’ajouter ou d’enlever des objets qu’elles contiennent. Par exemple, si vous avez un itérateur et que vous effacez un item sans le faire par l’itérateur, ce dernier lancera une exception quand vous désirerez obtenir l’objet suivant.

Si vous faites plus souvent des lectures que des écritures sur vos listes, les performances seront gravement détériorées en utilisant des verrous. Vous pouvez utiliser des ConcurrentHashMap ou des ConcurrentLinkedQueue qui permettent de modifier leur contenu sans briser les itérateurs.

4 réflexions au sujet de « Concurrence en Java »

  1. est ce que peuvent m’aide pour faire cette programme en java j’arrive pas a faire et ce que ils y a quelqu’un est peux m’aide il faudra créer un jeu interactif basé sur le jeu Le jeu consiste à trouver comment aller d’un mot à un autre en changeant
    qu’une lettre à chaque étape. la recherche de la solution est effectuée par
    plusieurs joueurs en même temps (deux au minimum). Les mots de départ et d’arrivé se trouvent dans le dictionnaire et doivent être générés de manière aléatoire pour les joueurs. Le joueur qui trouve la solution le plus rapidement gagne la partie. notation la recherche se fais dans un dictionnaire format texte

  2. La première question à te poser, c’est : « Peu importe le langage de programmation, sais-tu quelle logique/algorithme tu veux utiliser pour définir si une réponse est bonne ou non? »
    Si la réponse est non, alors ce n’est pas un problème avec Java que tu as, mais avec ta conception de ton jeu. C’est donc la première étape à franchir.

  3. on fait j’ai trouve l’algorithme pour recherche dans le dictionnaire il reste juste comment creé un deux joueurs qui cherche au meme temps le mot de depart et le mot d’arrive qui la donne ateatoire
    merci
    contacter moi sur mon msn mriad18@hotmail.com

Les commentaires sont fermés.