Regardez directement le code source de Thread. Il est clairement indiqué dans les commentaires qu'il existe deux méthodes, et les méthodes ont été données.
Il existe deux manières de créer un nouveau thread d'exécution. La première consiste à * déclarer une classe comme étant une sous-classe de <code>Thread</code>. Cette * sous-classe doit remplacer la méthode <code>run</code> de la classe * <code>Thread</code>. Une instance de la sous-classe peut alors être * allouée et démarrée. Par exemple, un thread qui calcule des nombres premiers * supérieurs à une valeur indiquée pourrait être écrit comme suit :
La première consiste à hériter directement de la classe Thread : (le code est directement copié de la classe Thread officielle) et à appeler la propre méthode d'exécution de Thread.
* class PrimeThread extends Thread {
* long minPrime;
* PrimeThread(long minPrime) {
* this.minPrime = minPrime;
* }
*
* public void run() {
* // compute primes larger than minPrime
* . . .
* }
* }
调用
* PrimeThread p = new PrimeThread(143);
* p.start();public
class Thread implements Runnable {
// Android-removed: registerNatives() not used on Android.
/*
/* Make sure registerNatives is the first thing <clinit> does. *
private static native void registerNatives();
static {
registerNatives();
}
*/La seconde consiste à implémenter l'interface Runable
* class PrimeRun implements Runnable {
* long minPrime;
* PrimeRun(long minPrime) {
* this.minPrime = minPrime;
* }
*
* public void run() {
* // compute primes larger than minPrime
* . . .
* }
* }
* PrimeRun p = new PrimeRun(143);
* new Thread(p).start();la différence:
La classe Thread est une classe abstraite de threads dans le vrai langage Java (Java est développé comme un système orienté objet, et tout est un objet)
La classe Runnable est une abstraction de tâches
Après avoir hérité de la classe Thread, en raison des caractéristiques de l'héritage unique Java, la classe actuelle ne peut pas hériter d'autres classes. Mais si vous implémentez l'interface Runnable, vous pouvez hériter d'autres classes.
Puisque Runnable est un objet tâche, il peut réaliser plusieurs threads partageant un objet tâche, mais Thread ne peut pas le faire.
Comment arrêter un fil de discussion :
La méthode stop() comporte une annotation @Deprecated ajoutée, il n'est donc pas recommandé de l'utiliser.
@Deprecated
public final void stop() {
La méthode stop est un arrêt brutal qui va entraîner une mauvaise libération des ressources occupées par le thread.
Bonne façon d'arrêter un fil :
interrompu () ne termine pas réellement le thread. Il donne en fait au thread actuel un indicateur d'interruption. Le thread ne se terminera pas et vous pouvez l'ignorer. C'est au thread lui-même de décider s'il doit le fermer.
isInterrupted() Cette méthode est utilisée pour renvoyer si le thread actuel a défini l'indicateur d'interruption. Le thread peut utiliser cette méthode pour déterminer s'il doit répondre à l'interruption.
interrompu() vérifie également si le thread actuel a un indicateur d'interruption. C'est une méthode statique.
public statique natif booléen interrompu ();
Début du fil d'analyse :
Les threads sont démarrés en appelant la méthode start() ;
public synchronized void start() {
if (started) //当start()方法调用了两次的时候，直接抛出异常
throw new IllegalThreadStateException();
group.add(this);
started = false;
try {
// start0();
nativeCreate(this, stackSize, daemon);
started = true; //线程调用了start()方法后， started = true; 避免start()方法多次调用
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
}méthode join()
Lorsque la méthode join() du thread B est appelée dans le thread A en cours d'exécution, elle équivaut au thread A donnant le droit d'exécution du processeur à B, et attend que B termine son exécution avant de s'exécuter. La méthode join() sérialise les threads.
package com.example.mylibrary;
import java.util.concurrent.Executors;
public class JVmBean {
public static void main(String[] args) {
System.out.println("------main------------");
ThreadA threadA = new ThreadA();
ThreadB threadB = new ThreadB();
threadA.start();
threadB.start();
// try {
// threadB.join();
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
System.out.println("------main----end--------");
}
static class ThreadA extends Thread{
@Override
public void run() {
super.run();
System.out.println("------A------------");
System.out.println("------end------------");
}
}
static class ThreadB extends Thread{
@Override
public void run() {
super.run();
System.out.println("------B------------");
try {
Thread.currentThread().sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("------B-----end-------");
}
}
}
Résultat de sortie :
------principal------------
------principal----fin--------
------A-------- --------
------fin------------
------B------------
---- --Plier-------
Ensuite, nous laissons B rejoindre la méthode join : évidemment, le thread principal doit attendre que le thread B ait fini de s'exécuter avant de l'exécuter.
------principal------------
------A------------
------fin--------- -------
------B------------
------B----------fin-------
---- --principal----fin--------