Mire directamente el código fuente de Thread, en los comentarios se indica claramente que hay dos métodos y se han proporcionado los métodos.
Hay dos formas de crear un nuevo hilo de ejecución. Una es * declarar una clase como subclase de <code>Thread</code>. Esta * subclase debe anular el método <code>run</code> de la clase * <code>Thread</code>. Luego se puede * asignar e iniciar una instancia de la subclase. Por ejemplo, un hilo que calcula números primos * mayores que un valor indicado podría escribirse de la siguiente manera:
Una es heredar directamente la clase Thread: (el código se copia directamente de la clase Thread oficial) y llamar al método de ejecución propio 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();
}
*/El segundo es implementar la interfaz 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 diferencia:
La clase Thread es una clase abstracta de subprocesos en el lenguaje Java real (Java se desarrolla como un sistema orientado a objetos y todo es un objeto).
La clase Runnable es una abstracción de tareas.
Después de heredar la clase Thread, debido a las características de la herencia única de Java, la clase actual no puede heredar otras clases. Pero si implementas la interfaz Runnable, puedes heredar otras clases.
Dado que Runnable es un objeto de tarea, puede realizar múltiples subprocesos que comparten un objeto de tarea, pero Thread no
Cómo detener un hilo:
El método stop() tiene una anotación @Deprecated agregada, por lo que no se recomienda su uso.
@Deprecated
public final void stop() {
El método de detención es un cierre brutal que hará que los recursos ocupados por el hilo no se liberen correctamente.
Forma correcta de detener un hilo:
interrupción() en realidad no termina el hilo. En realidad, le da al hilo actual un indicador de interrupción. El hilo no terminará y usted puede ignorarlo. Depende del hilo mismo decidir si cerrarlo.
isInterrupted() Este método se utiliza para devolver si el subproceso actual ha establecido el indicador de interrupción. El subproceso puede utilizar este método para determinar si debe responder a la interrupción.
interrumpido () también verifica si el hilo actual tiene un indicador de interrupción. Es un método estático.
público estático nativo booleano interrumpido();
Inicio del hilo de análisis:
Los hilos se inician llamando al método 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étodo unirse ()
Cuando se llama al método join() del subproceso B en el subproceso A en ejecución, es equivalente a que el subproceso A le dé el derecho de ejecución de la CPU a B y espere a que B termine de ejecutarse antes de ejecutarse. El método join() serializa los subprocesos.
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-------");
}
}
}
Resultado de salida:
------principal------------
------principal----fin--------
------A---- --------
------fin------------
------B------------
---- --Doblar-------
Luego dejamos que B se una al método de unión: obviamente, el hilo principal tiene que esperar a que el hilo B termine de ejecutarse antes de ejecutarlo.
------principal------------
------A------------
------fin----- -------
------B------------
------B-----fin-------
---- --principal----fin--------