1. unirse al hilo :
Durante la ejecución del subproceso, a veces desea que otro subproceso se ejecute primero, como dividir un problema grande en muchos problemas pequeños y asignar subprocesos a cada problema pequeño, pero después de procesar todos los problemas pequeños, deje que el subproceso principal realice más operaciones. En este momento, podemos llamar al método join () de otros subprocesos en el subproceso principal para bloquear el subproceso que llama (aquí, el subproceso principal).
Código de muestra:
Copie el código de código de la siguiente manera:
paquete org.frzh.thread;
clase pública JoinThread extiende Thread{
//Proporciona un constructor parametrizado para establecer el nombre del hilo
público JoinThread (nombre de cadena) {
super(nombre);
}
ejecución pública vacía() {
para (int i = 0; i < 100; i++) {
System.out.println(getName() + " " + i);
}
}
público estático vacío principal (String [] argumentos) {
//Iniciar hilo secundario
new JoinThread("nuevo hilo").start();
para (int i = 0; i < 100; i++) {
si (yo == 20) {
JoinThread jt = new JoinThread("tema que se unirá");
jt.start();
// El hilo principal llama al método de unión del hilo jt, luego el hilo principal debe esperar a que jt termine de ejecutarse antes de poder ejecutarse
intentar {
jt.join();
} captura (Excepción interrumpida e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName() + " " +i);
}
}
}
Originalmente había tres conjuntos de subprocesos (dos subprocesos y un subproceso principal). Cuando i = 20, el subproceso principal se bloquea y tiene que esperar hasta que se ejecute el "hilo unido" antes de tener la oportunidad de ejecutarse, por lo que hay. Solo se ejecutan dos subprocesos a partir de entonces.
Tres formas sobrecargadas del método join():
join(): espera a que el hilo unido termine de ejecutarse;
unirse (millis largos): el tiempo más largo para esperar a que se ejecute el subproceso unido es de millones de milisegundos. Después de eso, incluso si el subproceso unido no ha terminado de ejecutarse, no esperará más;
unirse (long millis, int nanos): el tiempo máximo para esperar a que se ejecute el subproceso unido es milisegundos + nanos microsegundos. (Este método es básicamente inútil).
2: Hilo de fondo :
Hay un hilo que se ejecuta en segundo plano y su tarea es servir a otros hilos. Este hilo se llama "hilo de fondo", "hilo de demonio" o "hilo de elfo". Cuando todos los hilos de primer plano mueran, el hilo de fondo morirá automáticamente.
Código de muestra:
Copie el código de código de la siguiente manera:
paquete org.frzh.thread;
la clase pública DaemonThread extiende Thread{
ejecución pública vacía() {
para (int i = 0; i < 1000; i++) {
System.out.println(getName() + " " +i);
}
}
público estático vacío principal (String [] argumentos) {
DaemonThread dt = nuevo DaemonThread();
//Establecer este hilo como hilo de fondo
dt.setDaemon(verdadero);
dt.start();
para (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " " + i);
}
// El hilo de primer plano finaliza, luego el hilo de fondo dt también finalizará, por lo que no se ejecutará 999
}
}
El hilo principal está predeterminado en el hilo de primer plano, los subprocesos creados por el hilo de primer plano están predeterminados en el hilo de primer plano y los subprocesos creados por el hilo de fondo están predeterminados en el hilo de fondo.
3. Hilo de dormir (dormir):
El método de unión anterior es dejar que el hilo que llama espere a que el hilo unido termine de ejecutarse antes de continuar, mientras que el método sleep() es dejar que el hilo que llama se bloquee durante un período de tiempo antes de volver a entrar en el estado listo y esperar a ser programado. Por lo tanto, se utiliza a menudo para pausar la ejecución del programa.
Código de muestra:
Copie el código de código de la siguiente manera:
paquete org.frzh.thread;
importar java.util.Fecha;
clase pública SleepThread{
público estático vacío principal (String [] argumentos) {
para (int i = 0; i < 10; i++) {
System.out.println("Hora actual: " + nueva fecha());
intentar {
Hilo.dormir(1000);
} captura (Excepción interrumpida e) {
// TODO Bloque de captura generado automáticamente
e.printStackTrace();
}
}
}
}
Dos métodos de sobrecarga del método sleep():
suspensión vacía estática (milis largos): deje que el hilo actual se detenga durante milisegundos y entre en el estado de bloqueo. Este método se ve afectado por la precisión y exactitud de los temporizadores del sistema y los programadores de subprocesos.
suspensión vacía estática (millis largos, int nanos): pausa millones de milisegundos + nanos microsegundos y entra en el estado de bloqueo. También se verá afectado por la precisión y exactitud del temporizador del sistema y el programador de subprocesos. Básicamente no es necesario.
4. Rendimiento del hilo :
El método rendimiento () es algo similar al método de suspensión. También puede pausar el hilo que se está ejecutando actualmente, pero no bloqueará el hilo, sino que simplemente lo transferirá al estado listo (tenga en cuenta que no es un estado de bloqueo). El método yield() solo dará a los subprocesos con la misma prioridad o mayor prioridad la oportunidad de ejecutarse, por lo que un subproceso puede reprogramarse para continuar con la ejecución después de llamar a este método.
Código de muestra:
Copie el código de código de la siguiente manera:
paquete org.frzh.thread;
clase pública YieldThread extiende Thread{
hilo de rendimiento público () {
}
hilo de rendimiento público (nombre de cadena) {
super(nombre);
}
ejecución pública vacía() {
para (int i = 0; i < 100; i++) {
System.out.println(getName() + " " +i);
si (yo == 20) {
//El hilo actual produce
Hilo.rendimiento();
}
}
}
público estático vacío principal (String [] argumentos) {
//Inicia dos hilos simultáneos
YieldThread yt1 = new YieldThread("Avanzado");
//Establece yt1 como la prioridad más alta
yt1.setPriority(Thread.MAX_PRIORITY);
yt1.start();
YieldThread yt2 = new YieldThread("bajo nivel");
yt2.setPriority(Thread.MIN_PRIORITY);
yt2.start();
/*
* Si la prioridad del subproceso no está establecida, la prioridad de los dos subprocesos es la misma, por lo que los dos subprocesos se ejecutarán alternativamente y cuando se llame a rendimiento, el otro subproceso se ejecutará;
* Sin embargo, después de establecer las prioridades anteriores para los dos subprocesos respectivamente, la ejecución avanzada del subproceso recién comenzó. Cuando i = 20, se llama a rendimiento, pero porque el método de rendimiento solo lo hará.
* Brinde oportunidades de ejecución a subprocesos con la misma prioridad o mayor prioridad, de modo que el subproceso de alto nivel todavía se esté ejecutando en este momento y no se le dará a subprocesos de bajo nivel.
*/
}
}
5: Cambiar la prioridad del hilo :
Esto es relativamente simple, simplemente llame al método de instancia setPriority (int prioridad). Cada hilo tiene por defecto la misma prioridad que su hilo principal, y el hilo principal tiene por defecto la prioridad normal (5). Java proporciona prioridades del 1 al 10 y también puede utilizar tres constantes estáticas:
PRIORIDAD_MAX:10
PRIORIDAD_MÍN:1
PRIORIDAD_NORMAL:5
Nota: Aunque Java proporciona 10 prioridades, diferentes sistemas admiten diferentes prioridades, así que trate de evitar el uso directo de números entre 1 y 10 y utilice constantes estáticas para garantizar una buena portabilidad.