1ère partie (thread en java) indépendant d’Android ...deptinfo.unice.fr/~renevier/POO/cours/03 - thread et UI et java et... · Philippe Renevier Gonin - L3 Informatique parcours

1ère partie (thread en java) indépendant d’Android. Certains exemples en java « classique »

Ressource (textes) :

http://docs.oracle.com/javase/tutorial/essential/concurrency/

http://developer.android.com/guide/components/processes-and-threads.html

http://docs.oracle.com/javase/tutorial/essential/concurrency/


Philippe Renevier Gonin - L3 Informatique parcours Miage - POO s6 - Thread & Android 02 / 53

Lancement d’une application ou d’un programme : un thread « graphique » qui gère les événements et le rafraichissement.

Et pour le reste ? (connexion http, traitement long, etc.)

Objectif : ne pas « geler » l’interface…

des Threads ? Thread en Java AsyncTask Handler


• Multitâche : exécution en parallèle de différentes partie d’un programme

• Processus : contexte d’exécution (espace mémoire, etc.)

– Contient au moins un thread

• Thread : contexte d’exécution dans un processus

– Partage de ressources

– « moins lourd » qu’un processus



• Répartition des tâches sur plusieurs processeurs

– Programmation parallèle…

• Simplification de code (par isolation)

• Interface graphique réactive (ne pas bloquer le “main” thread)



• Difficulté à écrire

– Ordre et temps d’exécution non connu à l’avance

– Accès concurrents

– Interdépendance

• Difficulté à débugger (pas abordé ici)

– Tests unitaires séparés (mock object)

– Tests d’intégration



Mise en évidence des problèmes



• API de haut-niveau (pas d’appel système direct)

• Deux objets pour l’exécution

– L’objet qui contrôle

– L’objet qui exécute (code du thread)



• Interface Runnablepublic void run( ) ; // code à exécuter

• Class Thread

– Classe qui implements Runnable (méthode run vide)

– Association avec le code à exécuter

• Par héritage et surcharge de la méthode run Constructeur

• Par construction avec un « Runnable » en paramètre

– Nom (au constructeur, {set|get}Name ) : pour débug ou communication par message



• Méthode start( )– « déroule » le code de la méthode « run » associée– Exécution en parallèle– Ce n’est pas limité à une classe : on peut tout utiliser, sous réserve d’erreur accès

concurrent

• Appel à run( ) directement : l’exécution serait alors séquentielle (non parallèle) dans le même « thread »

• Le thread est terminé lorsque la méthode « run » l’est – Boucle pour faire durer– Relance impossible (même en rappelant la méthode start)

• java.lang.IllegalThreadStateException si le thread n’est pas fini• Pas d’erreur, mais il ne se passe rien si c’est fini…• Il faut refaire un objet / thread…



basé sur un transparent de Richard Grindes Threads ? Thread en Java AsyncTask Handler

Nouveau Thread

New Thread( )



Eligible pour

exécution

Nouveau Thread

New Thread( )

start( )



Eligible pour

exécution

En cours d’exécution

Nouveau Thread

New Thread( )

start( )

Le système « passe »à ce thread



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin




Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué


• void start()• static void sleep(long) throws InterruptedException• void join() throws InterruptedException• static void yield()

• boolean isAlive( )

• void interrupt()– Interrompre un processus (InterruptedException)

• static boolean interrupted()– Le processus courant est-il interrompu ?

• static Thread currentThread()– Placée dans une méthode de n’importe quelle classe, elle retourne l’objet Thread qui contrôle le thread qui exécute cette

méthode au moment où currentThread est appelé• Gestion des priorités d’exécution

– int getPriority()– void setPriority(int)



• Exemple cas d’école :– Augmenter un compte (compteur)

– 3 sources d’augmentation différentes

• Comme en système, il faut attendre la fin des processus – On ne sait pas dans quel ordre…

– Attente « manuelle » « active »• sleep (de thread ou de TimeUnit)

– pour ne pas sur-occuper le(s) processeur(s)

– Le thread garde la main

– Attente la fin d’un thread : méthode join( )



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué

sleep / fin du délai

join / fin du thread rejoint



• Interruption par le « scheduler » – Le thread peut se faire interrompre pour qu’un autre soit exécuter– Sauvegarde / restauration de l’état… mais entre temps les « valeurs ont

changées »– => cas de mémoire inconsistante– => résultat « aléatoire »

• Besoin de synchronisation– Déclarer une variable volatile

• Toute modification sur une variable sera répercutée dans les autres threads (notion de "happens-before")

– Utilisation du mot clef synchronized



• Objectif : faire en sorte qu’un seul thread exécute une partie du code– « Atomicité » du code : pas d’entrelacement d’exécution

– (inter)blocage possible !! (deadlock)• Un thread n’est pas bloqué par lui-même

– Ralentissement du code : attendre son tour

• Synchroniser juste ce qui est nécessaire

• Synchronisation– Méthode

– Bloc { } (statement)



• Pas besoin de préciser sur quoi porte la synchronisation

• Tant qu’un thread est dans une méthode synchronisée, les autres threads sont bloqués sur les méthodes synchronisées de cet objet– À la fin de la méthode (« libération »), les autres threads sont prévenus

(des changements) (notion de "happens-before")

• Pas de règle sur l’héritage / surcharge

• Synchroniser une méthode statique => blocage de tout appel statique (sans lien avec les appels aux méthodes d’instance)



• Il faut préciser l’objet de la synchronisationpublic void addName(String name) {

synchronized(this)

{

lastName = name;

nameCount++;

}

nameList.add(name);

}

Objet de la synchronisation



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué





Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué



synchronized / son tour venu



• Méthode wait (sur un objet)– objet.wait( );– Appel dans une section synchronisée– Possibilité d’attendre que quelque chose réveille le thread

• Le thread ne fait plus rien en attendant• Et il passe aussitôt la main

• Réveil par la méthode notify– objet.notify( );– Appel dans une section synchronisée– Ne débloque qu’un thread, on ne sait pas lequel

• Réveil par notifyAll( );

• Possibilité d’utiliser un délai max du wait( délai) – Dans ce cas, le thread doit gérer lui-même le fait de connaître la cause de son déblocage (notify ou temps

écoulé)



// attendre tant qu’une condition // boucle pour ne pas rater un changement par un 3ième threadwhile (!condition) {

objet.wait();}

/* … */

// pour ne pas perdre deux notify consécutifs de 2 autres threadswhile (nbNotify < 2) {

wait();

}



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué






Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué




wait / notify



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué




wait / notify

Le système « passe »à un autre thread

ou

Méthode static yield( )

Pour passer la main



• Si on stoppe un thread il arrête de s’exécuter

• Il ne peut reprendre son exécution ; si on veut pouvoir suspendre et reprendre l’exécution du thread, voir suspend et resume

• stop() est deprecated car le thread stoppé peut laisser des objets dans un état inconsistant car il relâche leur moniteur quand il arrête son exécution

• On peut simuler stop en utilisant une variable

basé sur un transparent de Richard Grin



/* canceled est une variable volatile et/ou modifiée dans des méthodes synchronisées

*/

public void run( ) {// codewhile( ! canceled) {

// code}

// code de fin du thread}



• En cas de wait , sleep, etc.

• interrupt()

– met l’état du thread à « interrupted »

– Nous considérerons que c’est revenir à « en cours d’exécution », à ceci près qu’il faut gérer l’interruption…



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué




wait / notify


ou


Pour passer la main



Eligible pour

exécution


Mort

Nouveau Thread

New Thread( )

start( )

Fin


Bloqué


ou


Pour passer la main




wait / notify

? / interruption

suspend/ resume



• priorité

• Happens-before

• Groupe de thread

• Collection & thread

• Fork / join

• etc.



• Un sémaphore gère des ressources limitées• Blocage de haut niveau

– Création de bloc(s) « atomique(s) » « exclusif(s) »

• Avec des opérations (lock / unlock) atomiques– Lock pour bloquer la ressource– Unlock pour débloquer la ressource

• java.util.concurrent.locks.*;– Interface Lock : lock( ) et unlock( )– ReentrantLock– ReentrantReadWriteLock



• Problème : lecture et écriture d’une liste simultané

– ConcurrentModificationException

– Peut arriver tout « seul » (parcours d’une collection et modification simultanée)

• Solution :

– Synchronisation

– Et/ou travail sur une copie puis recopie « totale »



Certaines actions prennent du temps, elles figeraient l’application (UI).

Certaines actions sont interdites (car longues ou bloquantes) dans l’application

AsyncTask

Handler & HandlerThread, CoutDownTimer

java.util.concurrent.ScheduledThreadPoolExecutor (plutôt que java.util.Timer)

Un peu d’anglais ☺



• Utilisation de « worker » (AsyncTask)

• Exemple : adresse vers coordonnées (nominatim) puis image (openstreetmap)

• V1 : l’intention, qui ne fonctionne pas

• V2 : une AsyncTask pour l’adresse

• V3 : évolution pour charger aussi l’image



• Classes fourni dans java.net

URL siteUrl = new URL(url);

URLConnection conn = siteUrl.openConnection();

// on peut vouloir suivre les redirections…

// HttpURLConnection.setFollowRedirects(true);

// ensuite on a l’InputStream… conn.getInputStream()

// à encapsuler selon ce qu’on reçoit

// par exemple du JSON / text / etc.

BufferedReader in = new BufferedReader(new InputStreamReader( conn.getInputStream(), "UTF-8"));

// lecture tant qu’il y a à lire

while ((line = in.readLine()) != null) { file += line; }

// à la fin, file (une String) contient le fichier distant

in.close();

• Alternative : package d’apache intégré dans android

– http://developer.android.com/reference/org/apache/http/package-summary.html

– package org.apache.http


http://developer.android.com/reference/org/apache/http/package-summary.html


<manifest xmlns:android="http://schemas.android.com/apk/res/android"package="adresseverscoordonnees.three"android:versionCode="1"android:versionName="1.0" >

<uses-sdkandroid:minSdkVersion="8"android:targetSdkVersion="25" />

<uses-permission android:name="android.permission.INTERNET" />

<application …



• Il faut le « parser »– http://developer.android.com/reference/org/json/package-summary.html

// on reçoit un json qui contient un tableau d’objetJSONArray fileJson= new JSONArray(file);

// si le tableau n’est pas videif ((fileJson != null) && (fileJson.length() > 0)) {

// on prend le premier élément, qui est supposé être un objetJSONObject adresseRetournee = (JSONObject) fileJson.get(0);result = new Object[2];// on retrouve la propriété « lat » de cette objetresult[0] = (String) adresseRetournee.get("lat") ;// etc.

}


http://developer.android.com/reference/org/json/package-summary.html


• Impossible à savoir…

• Risque de figer l’interface graphique (et l’application)…

• … mais de toutes façons, depuis 3.x, il est interdit de faire certaines choses dans le thread graphique…

• Donc, il faut faire autrement– Il faut un thread,

– qui puisse faire des choses dans le graphique, plus facilement que la méthode runOnUiThread(Runnable) de la classe Activity

– bref un « Worker »



• http://developer.android.com/reference/android/os/AsyncTask.html

• AsyncTask enables proper and easy use of the UI thread. This class allows to perform background operations and publish results on the UI thread without having to manipulate threads and/or handlers.

• AsyncTask is designed to be a helper class around Thread and Handler and does not constitute a generic threading framework. AsyncTasks should ideally be used for short operations (a few seconds at the most.)

• If you need to keep threads running for long periods of time, it is highly recommended you use the various APIs provided by the java.util.concurrent pacakge


http://developer.android.com/reference/android/os/AsyncTask.html

http://developer.android.com/reference/java/lang/Thread.html

http://developer.android.com/reference/android/os/Handler.html


• An asynchronous task is defined by a computation that runs on a background thread and whose result is published on the UI thread.

• An asynchronous task is defined by 3 generic types, called Params, Progress and Result, and 4 steps



public class Tache extends AsyncTask<String, String, Object[]> {

// [...] // attributs de la classe

public Tache(TextView lat, TextView lon, ImageView img) {

// constructeur pour obtenir des élémentts

// par exemple graphique, pour mise à jour...

}

@Override

protected Object[] doInBackground(String... params) { // lancer par execute()

// tester les paramètres

if ((params == null)|| (params.length != 2)) return null;

Object [] result = null;

String url = params[0];

// [...] // utilise publishProgress(“<string>");

return result;

}

@Override

protected void onProgressUpdate(String... result){

// [...] // pour montrer la progression // appelé par publishProgress

}

@Override

protected void onPostExecute(Object [] res){

// traitement des résultats... // [...] // appelé à la fin de doInBackground

}

}



• Création (new)• Appel à execute()

1. onPreExecute(), invoked on the UI thread before the task is executed. Setup / Graphical initialization (progress bar)

2. doInBackground(Params...), invoked on the background thread immediately after onPreExecute()This step is used to perform background computation that can take a long time. The result of the computation must be returned by this step and will be passed back to the last step.

3. onProgressUpdate(Progress...), invoked on the UI thread after a call to publishProgress(Progress...) from doInBackground. The timing of the execution is undefined. For user feedback.

4. onPostExecute(Result), invoked on the UI thread after the background computation finishes. The result of the background computation is passed to this step as a parameter.


http://developer.android.com/reference/android/os/AsyncTask.htmlonPreExecute()


http://developer.android.com/reference/android/os/AsyncTask.htmldoInBackground(Params...)


http://developer.android.com/reference/android/os/AsyncTask.htmlonProgressUpdate(Progress...)

http://developer.android.com/reference/android/os/AsyncTask.htmlpublishProgress(Progress...)


http://developer.android.com/reference/android/os/AsyncTask.htmlonPostExecute(Result)


• Cancel : cancel(boolean). – isCancelled() return true. – onCancelled(Object) instead of onPostExecute– checking isCancelled() periodically in doInBackground(Object[])

• The AsyncTask class must be loaded on the UI thread. • The task instance must be created on the UI thread.• execute(Params...) must be invoked on the UI thread.• Do not call onPreExecute, onPostExecute,

doInBackground, onProgressUpdate manually.• The task can be executed only once


http://developer.android.com/reference/android/os/AsyncTask.htmlcancel(boolean)

http://developer.android.com/reference/android/os/AsyncTask.htmlisCancelled()

http://developer.android.com/reference/android/os/AsyncTask.htmlonCancelled(Result)


http://developer.android.com/reference/android/os/AsyncTask.htmlisCancelled()


http://developer.android.com/reference/android/os/AsyncTask.htmlexecute(Params...)




http://developer.android.com/reference/android/os/AsyncTask.htmlonProgressUpdate(Progress...)


• Starting with HONEYCOMB, tasks are executed on a single thread to avoid common application errors caused by parallel execution.

• If you truly want parallel execution, you can invoke executeOnExecutor(java.util.concurrent.Executor,

Object[]) withTHREAD_POOL_EXECUTOR.


http://developer.android.com/reference/android/os/Build.VERSION_CODES.html#HONEYCOMB

http://developer.android.com/reference/android/os/AsyncTask.htmlexecuteOnExecutor(java.util.concurrent.Executor, Params...)

http://developer.android.com/reference/android/os/AsyncTask.html#THREAD_POOL_EXECUTOR


• Similaire à java

– http://developer.android.com/guide/components/processes-and-threads.html

– Pensez à onResume / onPause et onRestart / onStop, etc.

• Ou lié à des services

– http://developer.android.com/guide/components/services.html



http://developer.android.com/guide/components/services.html


• Tache a besoin

– D’éléments graphiques pour les mettre à jour

– D’une url, d’un message par défaut

• Tache retourne

– Des coordonnées (latitude, longitude)

– Une image (enfin, si c’est ok)

• Publication de l’avancement : du texte



• On recherche un json

– C.f; exemple ci-dessus

• On recherche une image

– Création d’une Bitmap à partir d’un InputStream

• Pour les résultats

– Appels à des setters

– Mise à jour avec invalidate( )

– Masquer / montrer l’image



Attend

Exécute

Looper

Permet de poster ou d’envoyer des messages

(file d’attente)

Handler

Le Main Thread est un Looper

C’est le Looper par défaut

Looper.getMainLooper()

Messages d’autres threadsMessages

d’autres threadsMessages d’autres threads



• Handler handler = new Handler()– En paramètre, un Looper est possible, c.f. HandlerThread– Par défaut Looper = Main Thread

• Utilisable « de partout »– Exécution sur le Looper Thread – Par défaut sur le Main Thread

• handler.post(Runnable)– postAtFrontOfQueue– postDelayed avec un second paramètre un délai (long, en ms)– postAtTime avec un second paramètre un temps (long, en ms)

• Date, System.uptimeMillis()+ …

• handler.removeCallbacks(r)– Garder une référence vers le Runnable r– Si pas encore exécuté, pas lancé ; sinon, c’est trop tard



• Plutôt que poster des Runnable, envoyer des messages– Tâches connues à l’avance– Economie en mémoire (moins d’objet)

• Message– http://developer.android.com/reference/android/os/Message.html

– Des champs publics (facile d’accès)– Avec un « id » : message.what– Avec des données

• get/setData => un Bundle• ou int .arg1 / .arg2 et Object obj

• Création par fabrique– Message.obtain– avec différents paramètres : handler (pour le champ replyTo), what, arg1, arg2, obj– Ex: Message.obtain(handler, 42, "réponse à la grande question sur la vie, l'univers et le reste");


http://developer.android.com/reference/android/os/Message.html

http://developer.android.com/reference/android/os/Bundle.html


• Pour envoyer sendMessage

– sendMessage

– sendMessageAtFrontOfQueue

– sendMessageDelayed avec un second paramètre un délai (long, en ms)

– sendMessageAtTime avec un second paramètre un temps (long, en ms)

• Variante avec sendEmptyMesssage(int what)

• Pour annuler (si pas encore traité) : removeMessage(int what)

– Car message recyclé dans la fabrique



• Délégation à un Handler.Callback– handleMessage(Message msg)– En paramètre du constructeur du Handler (seul ou après le looper)

• Surcharge de la méthode handleMessage(Message msg)– Appelé par défaut par le Looper– Appel par défaut (si pas surchargée) le Handler.Callback– Déclaration en classe à part entière (ou en classe static) pour éviter un

nettoyage mémoire intempestif

• Possible de combiner les deux – dans la méthode surchargée handleMessage, appel à super.

handleMessage


http://developer.android.com/reference/android/os/Handler.Callback.htmlhandleMessage(android.os.Message)

http://developer.android.com/reference/android/os/Message.html


• Méthode post de View

– view.post(new Runnable() { /* … */ } );

• Méthode runOnUiThread de Activity



• HandlerThread fournit un Looper (caché)// création du HandlerThread, avec un priorité basse pour ne

// pas surcharger le système

HandlerThread encapsuleLooper =

new HandlerThread("un nom", Process.THREAD_PRIORITY_BACKGROUND);

encapsuleLooper.start(); // obligatoire !

// création du handler

Handler handler = new Handler( encapsuleLooper.getLooper() );

// les posts et messages seront traité sur encapsuleLooper



• Classe Abstraite à compléter– onTick– onFinish

• Constructeur CountDownTimer(long millisInFuture, long countDownInterval) – millisInFuture : délai en ms pour la fin– countDownInterval : délai en ms pour évolution intermédiaire

• Utilise un handler– Sur le thread « principal »– Utilise sendMessageDelayed– Appel selon le temps restant

• onTick (long millisUntilFinished) s’il reste du temps• onFinish() à la fin (dépassement possible)

– Accès à tout ce qui est graphique



• java.util.Timer et import java.util.TimerTask• Un Timer permet de planifier des tâches

– Comme un Handler • Il y a un thread (Looper) commun à tous les Timer

– Méthode(s) schedule ou scheduleAtFixedRate– Méthode cancel / purge

• Un TimerTask est un objet avec une méthode run– à étendre (classe anonyme ou pas)

• https://docs.oracle.com/javase/8/docs/api/java/util/Timer.htmlhttps://docs.oracle.com/javase/8/docs/api/java/util/TimerTask.html


https://docs.oracle.com/javase/8/docs/api/java/util/TimerTask.html


• 100% java : java.util.concurrent– http://developer.android.com/reference/java/util/concurrent/ScheduledT

hreadPoolExecutor.html

• Quand il y a plusieurs actions à « programmer »– À préférer à Timer (de java.util.Timer)– http://developer.android.com/reference/java/util/Timer.html

• Gère un « pool » de thread où exécuter les tâches (Callable<V> ou Runnable )– Méthodes schedule pour programmer à un temps donner

• Tâches exécutées le plus tôt possible une fois leur « heure » arrivée

– Méthodes submit pour le faire exécuter dès que possible


http://developer.android.com/reference/java/util/concurrent/ScheduledThreadPoolExecutor.html

http://developer.android.com/reference/java/util/Timer.html

Documents

1ère partie (thread en java) indépendant d’Android ...deptinfo.unice.fr/~renevier/POO/cours/03 - thread et UI et java et... · Philippe Renevier Gonin - L3 Informatique parcours