Tarea prioritaria
En una aplicación, si desea programar subprocesos, la forma más directa es establecer la prioridad del subproceso. Un subproceso con una prioridad más alta tiene una mayor probabilidad de obtener la ejecución de la CPU, mientras que un subproceso con una prioridad más baja tiene una menor probabilidad de obtener la ejecución de la CPU. La prioridad de un hilo está representada por un número entero entre 1 y 10. Cuanto mayor sea el número, mayor será la prioridad. Además de usar números directamente para indicar la prioridad de los subprocesos, también puede usar tres constantes estáticas proporcionadas en la clase Thread para indicar la prioridad de los subprocesos, como se muestra en la tabla.
| Constante estática del hilo | Función descriptiva |
|---|---|
| static int MAX_PRIORITY | Representa la prioridad más alta del hilo, que equivale a un valor de 10 |
| static int MIN_PRIORITY | Representa la prioridad más baja del hilo, equivalente a un valor de 1 |
| static int NORM_PRIORIY | Representa la prioridad normal del hilo, equivalente a un valor de 5 |
Durante la ejecución del programa, cada hilo en estado listo tiene su propia prioridad, por ejemplo, el hilo principal tiene una prioridad normal. Sin embargo, la prioridad del hilo no es fija y se puede establecer mediante el método setPriority (int newPriority) de la clase Thread. El parámetro newPriority en este método recibe un número entero entre 1 y 10 o tres constantes estáticas de la clase Thread. A continuación, se utiliza un caso para demostrar el funcionamiento de dos subprocesos con diferentes prioridades en el programa, como se muestra en el ejemplo.
package 多线程;
// 定义类MaxPriority实现Runnable接口
class MaxPriority implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "正在输出：" + i);
}
}
}
// 定义类MinPriority实现Runnable接口
class MinPriority implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + "正在输出：" + i);
}
}
}
class Example07 {
public static void main(String[] args) {
// 创建两个线程
Thread minPriority = new Thread(new MinPriority(), "优先级较低的线程");
Thread maxPriority = new Thread(new MaxPriority(), "优先级较高的线程");
minPriority.setPriority(Thread.MIN_PRIORITY); // 设置线程的优先级为1
maxPriority.setPriority(10); // 设置线程的优先级为10
// 开启两个线程
maxPriority.start();
minPriority.start();
}
}
Cabe señalar que, aunque Java proporciona 10 prioridades de subprocesos, estas prioridades requieren el soporte del sistema operativo. Los diferentes sistemas operativos tienen un soporte de prioridad diferente, y no pueden ser muy buenos con la prioridad de subprocesos en Java. Correspondencia uno a uno. Por lo tanto, al diseñar aplicaciones multiproceso, la realización de sus funciones no debe depender de la prioridad del subproceso, pero la prioridad del subproceso solo puede usarse como un medio para mejorar la eficiencia del programa.
Concesión de hilo
Las concesiones de subprocesos se pueden lograr a través del método yield (). Este método es similar al método sleep (). Ambos pueden pausar el subproceso que se está ejecutando actualmente. La diferencia es que el método yield () no bloquea el subproceso, solo convierte el subproceso subproceso al estado listo, deje que el programador del sistema reprograme nuevamente. (Si la próxima programación es un subproceso con la misma prioridad, se programará aleatoriamente). Cuando un subproceso llama al método yield (), solo los subprocesos con la misma o mayor prioridad que el subproceso actual pueden tener la oportunidad de ejecutarse. A continuación, se utilizará un caso para demostrar el uso del método yield ().
// 定义YieldThread类继承Thread类
class YieldThread extends Thread {
// 定义一个有参的构造方法
public YieldThread(String name) {
super(name); // 调用父类的构造方法
}
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + "---" + i);
if (i == 3) {
System.out.print("线程让步:");
Thread.yield(); // 线程运行到此，作出让步
}
}
}
}
public class Example09 {
public static void main(String[] args) {
// 创建两个线程
Thread t1 = new YieldThread("线程A");
Thread t2 = new YieldThread("线程B");
// 开启两个线程
t1.start();
t2.start();
}
}
Salto de hilo
En la vida real, a menudo nos encontramos con la situación de "saltar la cola". De manera similar, también se proporciona un método join () en la clase Thread para realizar esta "función". Cuando se llama al método join () de otro hilo en un hilo determinado, el hilo que llama se bloqueará y no continuará ejecutándose hasta que se complete la ejecución del hilo agregado por el método join ().
public class Example10{
public static void main(String[] args) throws Exception {
// 创建线程
Thread t = new Thread(new EmergencyThread(),"线程一");
t.start(); // 开启线程
for (int i = 1; i < 6; i++) {
System.out.println(Thread.currentThread().getName()+"输入："+i);
if (i == 2) {
t.join(); // 调用join()方法
}
Thread.sleep(500); // 线程休眠500毫秒
}
}
}
class EmergencyThread implements Runnable {
public void run() {
for (int i = 1; i < 6; i++) {
System.out.println(Thread.currentThread().getName()+"输入："+i);
try {
Thread.sleep(500); // 线程休眠500毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
