TP3

1. ExecutorService et Runnable

On souhaite vérifier l'existance de sites Web en parallèle.
La liste est la suivante:

String[] hostList = { "http://crunchify.com", "http://yahoo.com",
"http://www.ebay.com", "http://google.com",
"http://www.example.co", "https://paypal.com",
"http://bing.com/", "http://techcrunch.com/",
"http://mashable.com/", "http://thenextweb.com/",
"http://wordpress.com/", "http://wordpress.org/",
"http://example.com/", "http://sjsu.edu/",
"http://ebay.co.uk/", "http://google.co.uk/",
"http://www.wikipedia.org/",
"http://en.wikipedia.org/wiki/Main_Page"

Le principe à employer est la création d'un pool de threads qui vont chacun vérifier l'existance d'une ressource.

A

Implémentons la classe WebVerif implements Runnable. Ce Runnable correspond à une tache à exécuter (vérifier le status d'un site).
Cette tache doit retourner le status d'un site qui est donné à travers son constructeur.

Pour effectuer cette vérification, utilisez la Classe URL qui possède une méthode openConnection retournant une instance d' HttpURLConnection .
Sur cette instance faites un connect(); et un getResponseCode(); pour connaître le code de retour.
Si vous etes derrière un proxy, ajoutez les lignes:
System.setProperty("http.proxyHost","IP"); (IP=193.49.118.36 en 2019)
System.setProperty("http.proxyPort", "8080");
B

Y-a t-il des données partagées ? Lesquelles ?
Soit nbthreads le nb de threads du Pool. A combien fixez vous nbthreads et pourquoi ?

C

Créez la classe GetStatus qui a comme attribut la liste ci-dessus et un ExecutorService executor = Executors.newFixedThreadPool(nbthreads);
On doit faire passer à ce pool toutes les taches permettant de vérifier le status des sites de la liste. On doit également attendre la fin du pool.

Ici, les taches exprimées via des instances de Runnable ne peuvent retourner de résultat à l'appelant. Il est possible de le faire via des Callable (comme ci-dessous)

2. ExecutorService, Callable et FutureTask

Nous souhaitons simuler le comportement de singes ramassant des bananes, qu'ils plaçent dans un casier.

Les singes seront représentés par des Threads, les casiers de bananes par une collection que j'appelerai Casiers.

Utilisons la classe ExecutorService avec des FutureTask. Les FutureTasks retourneront en plus le nb de bananes collectées dans les casiiers.
Vous trouverez un exemple ici.

Nous souhaitons implémenter la classe Singe.

Plusieurs solutions sont possibles. Prenons cette solution: chaque singe i tire un entier aléatoire qui représente le nb de bananes collectées. Ce nombre est stocké dans la collection Casiers à la position i.

Comment allez vous implémenter la collection Casiers ?

L'entier aléatoire précédent est de quel type : Integer ou AtomicInteger ?

Comme dit précedemment, le nombre de bananes à retourner est aléatoire (Vous pouvez utiliser classe Random et méthode nextInt(). ex:random.nextInt(10)).

Implémentez la classe Singe.

Créez la Classe Ramasseur. Elle doit créer 10 singes et attendre la fin de leurs exécutions pour additionner toutes les bananes. Elle possède au moins les attributs suivants:

private Integer numberOfBananasCollected;
private static ExecutorService executorService = Executors.newFixedThreadPool(10);

Quelle est la solution que vous avez retenue pour effectuer la tache "addition de bananes"?

Le rédacteur de ce TP va supposer que vous avez suivi le cours et l'avez ouvert. De ce fait, la collection Casiers a été implantée pour garantir l'exclusion mutuelle :-).

Supposons maintenant que nous utilisions ArrayList.

Quels sont les changements à apporter ? Soyez précis.

D
On veut maintenant que les singes injectent dans la collection non pas un nombre, mais une collection de Bananes (On a donc une classe Banane).
Quelle collection prendre ? Doit-elle être ThreadSafe ?
Modifiez le code.