EISTI-ING1-GI
/
Java-2017-2018


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137
							<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang="">
<head>
  <meta charset="utf-8" />
  <meta name="generator" content="pandoc" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" />
  <title>Thread</title>
  <style type="text/css">
      code{white-space: pre-wrap;}
      span.smallcaps{font-variant: small-caps;}
      span.underline{text-decoration: underline;}
      div.column{display: inline-block; vertical-align: top; width: 50%;}
  </style>
  <link rel="stylesheet" href="pandoc.css">
  <!--[if lt IE 9]>
    <script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
  <![endif]-->
</head>
<body>
<div class="doctitle">Thread</div>
<nav id="TOC">
<ul>
<li><a href="#thread-et-exécutions-concurrentes">Thread et exécutions concurrentes</a><ul>
<li><a href="#introduction">Introduction</a></li>
<li><a href="#observations">Observations</a><ul>
<li><a href="#parallélisme">Parallélisme</a></li>
<li><a href="#mise-en-pause-dun-thread">Mise en pause d’un Thread</a></li>
<li><a href="#attente-de-fin-dexécution-dun-thread">Attente de fin d’exécution d’un Thread</a></li>
<li><a href="#modification-conflictuelle-dune-même-ressource">Modification conflictuelle d’une même ressource</a></li>
<li><a href="#exclusion-mutuelle-avec-synchronized">Exclusion mutuelle avec synchronized</a></li>
<li><a href="#compte-en-banque-non-sécurisé">Compte en banque non sécurisé</a></li>
<li><a href="#manipulation-de-comptes-mutuellement-exclusives">Manipulation de comptes mutuellement exclusives</a></li>
<li><a href="#manipulation-de-comptes-mutuellement-exclusives-version-sans-boucle">Manipulation de comptes mutuellement exclusives version sans boucle</a></li>
</ul></li>
<li><a href="#exercices">Exercices</a><ul>
<li><a href="#semaphore-et-lock">Semaphore et Lock</a></li>
<li><a href="#le-problème-du-producteurconsommateur-verrou">Le problème du producteur/consommateur (verrou)</a></li>
<li><a href="#le-problème-du-producteurconsommateur-moniteurs">Le problème du producteur/consommateur (moniteurs)</a></li>
<li><a href="#application-des-countdownlatch-et-cyclicbarrier">Application des CountDownLatch et CyclicBarrier</a></li>
</ul></li>
<li><a href="#ressources">Ressources</a></li>
</ul></li>
</ul>
</nav>
<h1 id="thread-et-exécutions-concurrentes">Thread et exécutions concurrentes</h1>
<h2 id="introduction">Introduction</h2>
<p>De nos jours, les ordinateurs sont multi-tâches et sont capables d’exécuter plusieurs opérations simultanément (mise à jour en tâche de fond, contrôle de la bonne exécution d’une opération par une application tierce, etc).</p>
<p>Il est fréquent que plusieurs acteurs accèdent de manière concurrente à une même ressource. Cela peut engendrer différents problèmes.</p>
<h2 id="observations">Observations</h2>
<h3 id="parallélisme">Parallélisme</h3>
<p>Compiler et exécuter la classe <code>Thread1Parallelisme</code>.</p>
<p>Le programme crée trois <em>threads</em> qui affichent 100 fois respectivement <code>Hello</code>, <code>World</code> et <code>and Everybody</code>.</p>
<p>Que pouvez vous dire à propos de l’ordre d’affichage ? Expliquer.</p>
<p><strong>Remarque</strong></p>
<p>Ce programme hérite de <code>Thread</code> et réimplémente la méthode <code>run()</code> pour obtenir des flots d’exécutions parallèles.</p>
<h3 id="mise-en-pause-dun-thread">Mise en pause d’un Thread</h3>
<p>Compiler et exécuter plusieurs fois la classe <code>Thread2Sleep</code>.</p>
<p>Voyez vous tous les affichages ?</p>
<p>Essayez d’augmenter les valeurs d’attente (le troisième argument passé lors de la création des threads). Par quelle méthode de l’API Java est utilisé cette valeur ?</p>
<p>Si vous mettez de trop grandes valeurs, vous devriez parfois ne plus voir aucun affichage.</p>
<p><strong>Pourquoi ?</strong></p>
<h3 id="attente-de-fin-dexécution-dun-thread">Attente de fin d’exécution d’un Thread</h3>
<p>Dans la classe <code>Thread3Join</code>, nous faisons appel à la fonction join qui force le programme principal à attendre la terminaison des threads.</p>
<p>Compiler le programme, Modifiez les valeurs d’attente (paramètre <code>delai</code>) et s’assurer que tous les affichages sont présents.</p>
<h3 id="modification-conflictuelle-dune-même-ressource">Modification conflictuelle d’une même ressource</h3>
<p>Dans la classe <code>Thread4ModificationConflictuelle</code>, nous manipulons une variable partagée d etype <code>Tableau</code>.</p>
<p>Les Thread sont instanciés en leur donnant en paramètre un objet de type <code>Runnable</code> : la méthode <code>Runnable.run()</code> est exécutée par le Thread.</p>
<p>Ces objets sont fabriqués par la classe <code>TacheTableau</code>. Deux types de tâches sont effectuées:</p>
<ul>
<li>les tâches <em>Déposer</em> incrémentent les valeurs dans le tableau</li>
<li>les tâches <em>Retirer</em> décrémentent les valeurs dans le tableau</li>
</ul>
<p>Logiquement, à la fin les valeurs doivent être égales à 0 puisque les tâches incrémentant et décrementant s’annulent.</p>
<p>Exécuter plusieurs fois le programme. Y a-t-il des cas où le résultat est différent ?</p>
<h3 id="exclusion-mutuelle-avec-synchronized">Exclusion mutuelle avec synchronized</h3>
<p>Pour corriger le problème dans l’exemple précédent, on ajoute le mot clé <code>synchronized</code> aux deux méthodes <code>incrementerValeurs</code> et <code>decrementerValeurs</code>.</p>
<p>Exécuter le programme. S’assurer que le comportement est correct. Que remarquez vous au niveau du temps d’exécution ? Expliquer.</p>
<h3 id="compte-en-banque-non-sécurisé">Compte en banque non sécurisé</h3>
<p>Dans <code>Thread6CompteEnBanqueSansVerrou</code> la ressource partagée est un compte et non un tableau. Les opérations sont débiter, créditer et consulter.</p>
<p>Est-ce que le solde est toujours égal à 0 à la fin ?</p>
<h3 id="manipulation-de-comptes-mutuellement-exclusives">Manipulation de comptes mutuellement exclusives</h3>
<p>Dans la classe <code>Thread7CompteSynchronized</code>, nous reprenons l’exemple de manipulation de comptes.</p>
<p>Le programme est modifié pour interdire le retrait s’il n’y a pas assez d’argent.</p>
<p>Quand le solde est insuffisant, les threads de retrait attendent (<code>wait()</code> dans la méthode <code>debiter</code>), ils sont réveillés par les threads de dépôt qui appellent la méthode <code>crediter</code> contenant un appel à <code>notify()</code>.</p>
<p>Compiler et observer l’exécution de Thread7CompteSynchronized.</p>
<p>Essayer de trouver un cas où un appel à retirer est fait avec un solde <code>0</code>. Que se passe-t-il ?</p>
<h3 id="manipulation-de-comptes-mutuellement-exclusives-version-sans-boucle">Manipulation de comptes mutuellement exclusives version sans boucle</h3>
<p>La classe <code>Thread8MutexSansBoucle</code> utilise <code>CompteMutexIf</code> est quasi identique à la classe <code>CompteMutex</code>.</p>
<p>La différence tient dans le fait que pour la vérification de la condition avant <code>wait</code>, nous avons remplace le <code>while</code> par un <code>if</code>.</p>
<p>Y a-t-il des cas où le solde devient négatif ? Expliquer.</p>
<h2 id="exercices">Exercices</h2>
<h3 id="semaphore-et-lock">Semaphore et Lock</h3>
<p>Cet exercice est à faire initialement sur feuille papier, avant d’être programmé.</p>
<p>Faites une recherche sur le concept de sémaphore dans le domaine du parallélisme.</p>
<p>Etudiez la classe <code>DemoSemaphore</code>. Modifez les valeurs suivantes dans le <code>main</code>:</p>
<ul>
<li>paramètre <code>token</code> sur le constructeur</li>
<li><code>numberOfLoops</code></li>
</ul>
<p>Observez ce qui se passe et concluez.</p>
<p>Faites de même avec la classe <code>DemoLock</code>.</p>
<p>Etudiez la documentation sur la classe <code>Semaphore</code>.</p>
<p>Etudiez cette classe et l’interface <code>Lock</code> (et les classes qui l’implémentent).</p>
<h3 id="le-problème-du-producteurconsommateur-verrou">Le problème du producteur/consommateur (verrou)</h3>
<p>Programmer le problème du producteur/consommateur en utilisant les <code>Lock</code>. Pour cela, écrire une classe Stockage contenant un tableau d’Object ainsi que les méthodes <code>Object consomme()</code> et <code>void produit(Object)</code>.</p>
<p>Écrire un programme principal qui instancie un objet Stockage puis qui crée de nombreux threads dont certains vont produire et d’autres consommer des objets.</p>
<p>Faites en sorte que l’on puisse observer le déroulement des synchronisations (par exemple avec des <code>System.out.println()</code> judicieusement placés). Pour cela, vous aurez probablement à ralentir vos threads (en insérant des appels à <code>sleep(int)</code> à l’intérieur des sections critiques ou entre les productions/consommations d’objets).</p>
<p>Note : vous pouvez utiliser la classe <code>Random</code> (voir la Javadoc) pour générer des temps d’attente aléatoires, ainsi que la classe <code>TimeUnit</code>.</p>
<p>Gardez des traces montrant que certains threads sont effectivement endormis (et réveillés plus tard) lorsqu’ils essayent de consommer alors que le stockage est vide ou bien au contraire lorsqu’ils essayent de produire alors que le stockage est plein.</p>
<h3 id="le-problème-du-producteurconsommateur-moniteurs">Le problème du producteur/consommateur (moniteurs)</h3>
<p>Réécrivez le problème du producteur/consommateur en utilisant directement les moniteurs Java (i.e. sans utiliser la classe Semaphore ou Lock mais uniquement <code>synchronized</code>, <code>wait</code> et <code>notify</code>).</p>
<h3 id="application-des-countdownlatch-et-cyclicbarrier">Application des CountDownLatch et CyclicBarrier</h3>
<p>Ecrivez un programme simulant un repas fait par quatre convives (par l’affichage de messages).</p>
<p>Les quatres convives doivent attendre d’être attablés avant de commencer le repas.</p>
<p>Une fois le repas commencé, il se déroule comme suit:</p>
<ul>
<li>L’entrée est amenée. Les quatre convives mangent à des vitesses différentes (le premier met 2 minutes, le second 5 minutes, le troisième 3 minutes et le quatrième met 7 minutes).</li>
<li>Une fois que tous les convives ont terminé leur entrée, le serveur enlève les assiettes vides.</li>
<li>Le plat est alors amené et les quatre convives mangent également à des vitesses différentes (respectivement 4, 9, 6 et 5 minutes).</li>
<li>Une fois le plat terminé par tous les convives il est desservi.</li>
<li>Le café est alors servi et les convives mettent respectivement 2, 3, 1 et 4 minutes pour le boire.</li>
<li>Le temps entre le moment où les convives ont terminé un met et le met suivant est servi est aléatoire (entre 1 et 15 minutes).</li>
</ul>
<p>Un serveur (géré par un Thread) enlève puis ramène les assiettes 2 par 2. Il met 1 minute pour effectuer un aller-retour en cuisine.</p>
<p>Simulez ce repas (en remplaçant les minutes par des secondes pour plus de rapidité).</p>
<p>Le programme doit inscrire dans un fichier les temps totaux d’exécution pour chaque repas (donc chaque lancement du programme).</p>
<h2 id="ressources">Ressources</h2>
<p>Un exemple d’utilisation de CyclicBarrier:</p>
<p><a href="http://java67.blogspot.fr/2015/06/how-to-use-cyclicbarrier-in-java.html" class="uri">http://java67.blogspot.fr/2015/06/how-to-use-cyclicbarrier-in-java.html</a></p>
<p>Une ressource pour les deux:</p>
<p><a href="http://oppansource.com/cyclicbarrier-and-countdownlatch-in-java/" class="uri">http://oppansource.com/cyclicbarrier-and-countdownlatch-in-java/</a></p>
<p>Un algorithme de tri parallèle:</p>
<p><a href="http://www.javamex.com/tutorials/threads/CyclicBarrier_parallel_sort.shtml" class="uri">http://www.javamex.com/tutorials/threads/CyclicBarrier_parallel_sort.shtml</a></p>
<p>Quelques explications sur l’usage de CountDownLatch:</p>
<p><a href="http://howtodoinjava.com/2013/07/18/when-to-use-countdownlatch-java-concurrency-example-tutorial/" class="uri">http://howtodoinjava.com/2013/07/18/when-to-use-countdownlatch-java-concurrency-example-tutorial/</a></p>
</body>
</html>