programme par défaut est que les applications d'un processus, un processus qui peut contenir plusieurs threads.
Multithreading - Présentation
Définition: plusieurs threads simultanément, à savoir plusieurs tâches simultanément.
Remarque:
- En fait, l'ordinateur à un moment donné ne peut effectuer une tâche;
- Multithreading est seulement une illusion: juste parce que les ressources de planification rapide JVM de continuer à prendre des virages en rotation l'exécution du fil, il semble que seulement effectuer des tâches multiples en même temps.
A, Android fil de classe et d'action
1.1 Par application
- Le fil conducteur:
Définitions: système Android va démarrer un thread principal automatiquement lors du démarrage du programme
Effet: le traitement des quatre composants interagissent avec l'utilisateur (par exemple, l' interface utilisateur, l' interaction de l' interface liée)
Remarque: Parce que l'interface utilisateur et l' interaction se produisent à tout moment, de sorte que le principal fil doit en tout temps maintenir une vitesse de réponse élevée, de sorte que le thread principal ne permet pas le fonctionnement de temps, il y aurait ANR
- fil de l'enfant:
Définition: Une unité d'exécution de base et unité minimale du processeur de flux d'exécution du programme.
Action: opérations de processus consommateurs de temps, comme les demandes de réseau, des calculs complexes, afin de réduire le temps et la mémoire programme, lorsqu'il est exécuté en même temps payé pour améliorer les performances des systèmes d'exploitation concurrents.
Sous-état du fil comme indiqué:
-------------------------------------------------- -------- discussion ----------------------------------------- --------------------
2.2 Selon la forme:
一, Discussion
1. Description: Le fil de base, vous pouvez faire quelques opérations simples, souvent avec l'utilisation Handler.
2, Enfilez fonctions principales :
RUN () : exécution d'exécution de code-thread
start (): démarrer le fil
sommeil (): sommeil du fil, dans l'état bloqué, le mode de sommeil ne libère pas le verrouillage
yield (): fil CPU de rachat, mais ne bloque pas mais est remis à l'état prêt, ne sera pas libérer le verrou
interruption (): fil d' interruption, interrompu seulement attention à l'état bloqué de fil
setDaemon (): définir et récupérer la garde si fil
3, Enfilez plusieurs Etat
Nouvel Etat (nouveau nouveau) : Cet état est entré après l'instanciation;
Prêt (Runnable) : Après l'état thread appelle start () d'exécution prêt à cpu d'attente, attention à ce point ne signifie pas seulement que vous pouvez exécuter est déjà en cours;
état de fonctionnement ( en cours) : fil de cpu est exécuté, et commencer méthode run d'exécution ();
Bloqué (bloqué) : fil dans l'état bloqué en raison de diverses raisons: join (), sleep () , attente (), en attente d'une condition de déclenchement, en attente occupée par un autre verrou de fil;
état de mort (Dead) : le fil a terminé la course ou de sortie anormale, l' utilisation isAlive () Obtient l'état.
4, utiliser Android dans cette discussion
1.1, l' héritage de cette discussion, rewrite run()méthode.
1.2, pour atteindre Runnable, rewrite run()méthode pour effectuer la tâche
1.3, démarrer le fil par Handler
5, comment mettre fin au fil
1.1, en utilisant comme marqueur variable booléenne
1.2, en utilisantinterrupt()
Enfilez le fonctionnement normal: Interrompre threads au lieu de l'extrémité du fil.
Thread bloqué: lancer une exception, cette exception à l'utilisation de hors de la boucle.
1,3, en utilisant la stop()méthode de terminaison de fil
Cela équivaut à l'arrêt forcé en cas de perte de données plus de mal que de bien.
6, fil de sécurité et la synchronisation des threads
1.1 Qu'est - ce qu'un fil de sécurité?
En termes simples, fil de sécurité fait référence à plusieurs threads accèdent au même code ou des données, ce qui entraîne des résultats de la confusion et des données.
1.2, la méthode de solution:
(. 1) la synchronisation mot - clé, en même temps de veiller à ce que l' accès seul bloc ou de fil à la méthode.
(2) volatile domaine variable spéciale variables modifiées: la variable pour indiquer à la machine virtuelle peut être mis à jour à tout moment, sont recalculés chaque emploi du temps, au lieu d'utiliser la valeur du registre.
(3) ReentrantLock: utiliser des verrous réentrants pour la synchronisation du fil.
(4) ThreadLocal variables de gestion: Cette variable est utilisée pour chaque thread recevra une copie de la variable, indépendamment les uns des autres exemplaires.
-------------------------------------------------- - AsyncTask ------------------------------------------------ --------------
二, AsyncTask
1, description: opération asynchrone classe légère, facile à mettre à jour l'interface utilisateur.
2, le principe: encapsule Handler et deux pool de threads.
(1) Piscine fil THREAD_POOL_EXECUTOR: être vrai fil de mission
(2) pool de threads SERIAL_EXECUTOR: planificateur de tâches (permet à plusieurs threads de tâches , dans l'ordre)
(3) instancie un objet WorkerRunnable AsyncTask créer mWorker et objets FutureTask mFuture. cheveux FutureTask et est un acte de classe comme le rôle de Runnable. Suivant utilisera la ligne série et threads de travail pour gérer la tâche.
(4) Lorsque vous créez un objet passé en paramètre à WorkerRunnable objet FutureTask, FutureTask une mission run()lorsque les appels WorkerRunnable la call()méthode, call()la méthode est réalisée dans le pool de threads.
(5) le fil conducteur Handler:
- Après avoir appelé la méthode call (), appelez doInBackground et renvoie le résultat.
- Ce processus va attraper la tâche a été annulée à la fin de la AsyncTask set.
call()La dernière méthodepostResult(result)。- Obtenez le thread principal gestionnaire, thread de travail de communication et le fil conducteur
3, les paramètres et les fonctions de base
AsyncTask prévoit également quatre méthodes principales:
protected void onPreExecute(): Avant le thread principal pour effectuer des tâches asynchrones appelant les travaux préparatoires;protected abstract Result doInBackground(Params... var1): Fils d'exécution dans le pool, utilisé pour effectuer des tâches asynchrones. Params représente les paramètres asynchrones d'entrée de tâche, dans cette méthode par publishProgress à la méthode tâche de mise à jour de progrès, publishProgress appelle à son tour la onProgressUpdate façon d'atteindre les principales mises à jour de progression de fil. Cette méthode renvoie Résultat à onPostExecute méthode.protected void onProgressUpdate(Progress... values): Dans le thread principal d'exécution, une tâche d'arrière-plan des changements d'horaire d'exécution fera appel à cette méthode.protected void onPostExecute(Result result): Après la principale exécution du thread, les tâches asynchrones d' appel, le résultat paramètre est doInBackground retourné.
4, Attention AsyncTask
- AsyncTask classe d'objet doit être créé dans la principale charge de fil.
- exécuter méthode doit être appelée sur le thread d'interface utilisateur.
- Un objet AsyncTask ne peut être effectuée une fois , qui ne peut être appelée une fois que la méthode d' exécution, sinon l'exception d'exécution du rapport.
5, les avantages
- Simple et rapide et facile à utiliser.
- met à jour l'interface utilisateur en temps opportun, le contrôle du processus.
6, les insuffisances
1, de multiples besoins de fonctionnement asynchrone pour être mis à jour l'interface utilisateur, il devient gênant.
-------------------------------------------------- - HandlerThread ------------------------------------------------ -----
三, HandlerThread
1. Description: un Looper utilisé, fil conducteur.
2, le principe
(1) hérité de cette discussion, est en fait un Looper, les fils de gestionnaire.
(2) a hérité de cette discussion, dans le run()processus de Looper.prepare()création d' une file d'attente de message, Looper.loop()pour traiter la boucle de messages.
(3) ouvrir lors de l' utilisation HandlerThread, créer Handler et HandlerThread liaison de Looper, notification de gestionnaire de messages HandlerThread façon d'effectuer une tâche spécifique.
(4) HandlerThread interne maintient une file d' attente de messages, pour éviter de créer de manière répétée et détruire thread enfant à utiliser.
3, par exemple:
//创建HandlerThread实例，参数字符串定义新线程的名称。
HandlerThread mHandlerThread = new HandlerThread("check-message-coming");
//启动HandlerThread线程。
mHandlerThread.start();
//Handler与HandlerThread绑定
Handler mCheckMsgHandler = new Handler(mHandlerThread.getLooper()){
@Override
public void handleMessage(Message msg){
// 进行耗时操作
}
};Remarque : Pour ne pas oublier onPause()et onDestroy()pause et mise à jour d'arrêt mHandlerThread pour libérer de la mémoire.
-------------------------------------------------- --- IntentService ---------------------------------------------- -------
Quatre, IntentService
1, Description: IntentService encapsule HandlerThread et un gestionnaire, IntentService encapsule HandlerThread et un gestionnaire.
2, le principe:
- Lorsque vous créez un début HandlerThread IntentService, tout en se liant gestionnaire HandlerThread. Par conséquent, les messages envoyés par le gestionnaire sont effectuées dans HandlerThread.
- Ensuite IntentService dans le cycle de vie de
onStartCommandrappelonStartsera envoyée en utilisant l'objet Intent passé sous la forme de messages Handler. - Gestionnaire sera appelé après avoir reçu le message d'
onHandleIntentune telle méthode abstraite que nous avons besoin pour réaliser leur propre logique de traitement. Enfin traitéestopSelf(msg.arg1);attente pour toutes les tâches à la fin complète IntentService;
-------------------------------------------------- ----- piscine de fil ------------------------------------------- ------------------
Cinquièmement, la piscine de fil
1, Principe:
Android dans le concept de pool de threads en Java est Exécuteur, Executor est une interface pour vrai fil est ThreadPoolExecutor. (ThreadPoolExecutor hérité AbstractExecutorService, AbstractExecutorService est ExecutorService classe de mise en oeuvre, ExecutorService a hérité de l'interface Executor).
2, les avantages:
- La réutilisation des fils dans la piscine, éviter de fréquentes création de fil et la destruction provoquée par la surcharge de la mémoire.
- Le contrôle effectif du nombre maximum de threads simultanés pour éviter phénomène de blocage en raison de saisir les ressources entre les threads causés.
- Il peut être une simple gestion des threads, l'exécution et fournir cycle de synchronisation d'intervalle de temps d'exécution des fonctions spécifiées.
3, la classification de la piscine de fil
, (1). FixedThreadPool (Correction: fixe et immuable)
En Huissiers de newFixedThreadPoolcréation, par la création de paramètres peuvent être vus et les caractéristiques suivantes:
- Un nombre fixe de fils et les fils sont le noyau : nombre de fils de noyau et le nombre maximal de fils sont nThreads;
- Ils sont le fil d'âme et ne seront pas récupérés rapidement correspondant demande externe;
- Aucun mécanisme time-out, la file d'attente des tâches est sans limite de taille;
- La nouvelle tâche à l'aide du fil d'âme, s'il n'y a pas de fil noyau libre est mis en attente pour l'exécution.
(2), CachedThreadPool (cache: Cache)
En Huissiers de newCachedThreadPoolcréation, il dispose:
- Un nombre variable de fils, seul fil non-core, le nombre maximal de fils arbitrairement grandes : Numéro de noyau de fils entrant paramètre est 0, le nombre maximum de threads Integer.MAX_VALUE;
- Utilisez threads inactifs d'exécution quand il y a une nouvelle tâche, il n'y a pas de fil à vide crée un nouveau fil à la poignée.
- Chacun des fils de pool de threads inactif comporte un mécanisme de dépassement de temps, souvent pour les années 60 (paramètres: 60L, TimeUnit.SECONDS), inactif pendant plus de 60 ans d'inactivité récupération de fil.
- Pour la mise en œuvre d'un grand nombre de moins de tâche de temps est arrêté lorsque tous les fils seront inactif pendant plus de 60, il reprend peu de ressources système.
, (3). ScheduledThreadPool (le régulier: prédéterminé, prévue)
En Huissiers de newScheduledThreadPoolcréation, il dispose:
- Le nombre fixe fil d'âme, un nombre illimité de fil non-core ;
- fil non-noyau inactif pendant plus de 10 secondes seront recyclés;
- La tâche principale du moment pour effectuer des tâches répétitives et ayant une durée déterminée;
- retard de quatre seulement à l'intérieur d'un cycle de fonctionnement à plusieurs reprises effectué et réalisée
(4), SingleThreadExecutor (piscine de fil mono-thread)
par Executors de newSingleThreadExecutorcréation comprend:
- Seul un fil d'âme, toutes les tâches sont exécutées en séquence dans le même fil.
- Toutes les tâches externes en un seul fil, de sorte que le problème ne nécessite pas thread de traitement de synchronisation.
4, ThreadPoolExecutor Présentation
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory) {
this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
threadFactory, defaultHandler);
}Paramètre Description:
- corePoolSize: nombre de base de fils de la piscine de fil, le fil d'âme par défaut dans le cas aurait été vivant dans la piscine de fil, même au ralenti.
- maximumPoolSize: Le nombre maximum de threads dans le pool de threads peut contenir, lorsque le nombre de threads ce nombre est atteint, le suivi des nouveaux emplois seront bloqués.
- KeepAliveTime: délai d'attente de fil non-core, plus cette fois l' exécution des tâches, fil non-core sera récupéré.
- unité: une unité de temps spécifiée paramètres KeepAliveTime.
- WorkQueue: file d' attente des tâches pool de threads.
- threadFactory: usine de fil, pour fournir la possibilité de créer un nouveau thread pool de threads.
-
gestionnaire: type du gestionnaire RejectedExecutionHandler . Quand un pool de threads ne peut pas effectuer de nouvelles tâches, il appelle le gestionnaire
rejectedExecution(Runnable r, ThreadPoolExecutor e)de méthode pour lancer une exception.
5, ThreadPoolExecutor exécutent des tâches suivent généralement les règles suivantes:
(1) Si le nombre de threads dans le pool n'atteint pas le nombre de threads du noyau démarre directement un thread noyau pour effectuer la tâche.
(2) Si le nombre de fils dans la piscine du fil a atteint ou dépassé le nombre de fils de noyau, la tâche sera insérée dans la file d'attente de tâche en file d' attente pour l' exécution.
(3) Si l'étape 2 ne peut pas insérer une nouvelle tâche, expliquer la file d'attente de tâche est pleine, si pas atteint le nombre maximum prédéterminé de fils, démarrer un fil pour effectuer des tâches non essentielles.
(4) Si la valeur maximale dépasse le nombre spécifié d'unités d'exécution dans l' étape 3, puis a refusé d'utiliser RejectedExecutionHandler tâche et le rejectedExecution(Runnable r, ThreadPoolExecutor e)procédé pour informer l'appelant.
Lien original: https://www.jianshu.com/p/56163a3beb4a
https://cloud.tencent.com/developer/article/1424838
