Propósito:
1. Comprender el concepto de subprocesamiento y el ciclo de vida de los subprocesos.
2. Domine la programación multiproceso.
Contenido del experimento:
1. Cree un hilo heredando la clase Thread.
2. Cree un hilo implementando la interfaz Runnable.
3. Operación de prioridad de subprocesos.
4. Juegue al juego de adivinar números con dos hilos.
Pasos experimentales:
1. Cree un hilo que implemente la suspensión (de 1 a 5 segundos) heredando la clase Thread y muestre su tiempo de suspensión y el nombre del hilo.
Código fuente:
package homework.实验10_多线程;
public class sy10_1 {
public static void main(String[] args) {
Runner1 r = new Runner1();
r.start();
for (int i = 0; i < 3; i++) {
if(i==2){
try {
Runner1.sleep(1000); //此处是类名.sleep()
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Runner1.currentThread().getName()+"当前运行的线程名称： "+ i);
}
}
}
class Runner1 extends Thread{
public void run() {
for (int i = 0; i < 5; i++) {
if(i==4){
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println(Runner1.currentThread().getName()+"当前运行的线程名称： "+ i);
}
}
}
2. Cree un subproceso implementando la interfaz Runnable, que requiere la generación de tres objetos de subproceso y, respectivamente, establezca el tiempo de suspensión de los tres subprocesos: el subproceso A duerme durante 1 segundo, el subproceso B duerme durante 2 segundos y el hilo C duerme durante 3 segundos.
Código fuente:
package homework.实验10_多线程;
public class sy10_2 {
public static void main(String[] args){
new Thread(new Sleep("线程A", 1000)).start();
new Thread(new Sleep("线程B", 2000)).start();
new Thread(new Sleep("线程C", 3000)).start();
}
}
class Sleep implements Runnable{
public long time;
public String name;
public Sleep(String name, long time){
this.name = name;
this.time = time;
}
@Override
public void run() {
// TODO Auto-generated method stub
try {
Thread.sleep(this.time);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(this.name+"休眠"+this.time+"毫秒");
}
}
3. Cree tres subprocesos para que uno de ellos tenga la prioridad más alta, uno tenga la prioridad más baja y un subproceso tenga una prioridad intermedia. Es necesario mostrar el nombre de cada hilo y su prioridad.
Código fuente:
package homework.实验10_多线程;
public class sy10_3 {
public static void main(String[] args){
Thread t1 = new Thread(new PriThread());
Thread t2 = new Thread(new PriThread());
Thread t3 = new Thread(new PriThread());
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(6);
t3.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
t3.start();
}
}
class PriThread implements Runnable{
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println(Thread.currentThread().getName()+"的优先级是:"
+Thread.currentThread().getPriority()+"");
}
}
4. Utilice dos hilos para jugar al juego de adivinar números: el primer hilo es responsable de dar aleatoriamente un número entero entre 1 y 100, y el segundo hilo es responsable de adivinar el número. Se requiere que cada vez que el segundo hilo dé su propia suposición, el primer hilo le pregunte "adivina pequeño", "adivina grande" o "adivina bien".
Código fuente:
package homework.实验10_多线程;
import java.util.*;
import java.util.Random;
public class sy10_4{
public static void main(String[] args) {
number num=new number("线程一");
num.start();
guess gue=new guess("线程二");
gue.start();
}
}
//给出整数的线程
class number extends Thread{
String name1;
private static int n;
number(String name){
name1=name;
}
public void run() {
//获取1~100的随机数
Random random=new Random();
n=random.nextInt(100);
System.out.println(name1+"给出的数字为:"+n);
}
//猜数字(静态方法，可通过类名调用)
public static String guessnum(int m) {
if(m<n) {
return "猜小了";
}else if(m>n){
return "猜大了";
}else return "猜对了";
}
}
//猜数线程
class guess extends Thread{
String name2;
//最大值和最小值
private int min=0,max=100,nownum;
//比较结果
String Result;
guess(String name){
name2=name;
}
//获取比较结果
public String getGuess() {
return Result;
}
public void run() {
while(true) {
try{
Thread.sleep(2000);
}catch(InterruptedException e){
e.printStackTrace();
}
Random ran=new Random();
//当前猜的数字（最大值和最小值之间的数）
nownum=min+ran.nextInt(max-min);
//调用给出整数的线程 的猜数字方法guessnum，
Result=number.guessnum(nownum);
if(Result.equals("猜小了")) {
min=nownum;
System.out.println("线程二猜的数字是："+nownum+"---猜小了");
}else if(Result.equals("猜大了")) {
max=nownum;
System.out.println("线程二猜的数字是："+nownum+"---猜大了");
}else {
System.out.println("线程二猜的数字是："+nownum+"---猜对了,结果是"+nownum);
System.exit(0);
}
}
}
}
Captura de pantalla del resultado en ejecución:
Resumen del experimento
Proceso e hilo
Un proceso es un proceso de ejecución dinámica de un programa. Necesita pasar por un proceso completo desde la carga del código, la ejecución del código hasta la finalización de la ejecución. Este proceso es también el proceso del proceso mismo desde la generación, el desarrollo hasta la desaparición final. Un sistema operativo multiproceso puede ejecutar varios procesos (programas) al mismo tiempo. Debido a que la CPU tiene un mecanismo de tiempo compartido, cada proceso puede obtener su propio intervalo de tiempo de CPU de forma cíclica. Debido a que la CPU se ejecuta muy rápido, parece que todos los programas se ejecutan al mismo tiempo.
El multiproceso es un medio eficaz para realizar el mecanismo de concurrencia. Los procesos, como los hilos, son una unidad básica de simultaneidad. Un subproceso es una unidad de ejecución más pequeña que un proceso y un subproceso se divide aún más en función del proceso. El llamado multi-subproceso se refiere a un proceso que puede producir varias unidades de programa más pequeñas durante la ejecución. Estas unidades más pequeñas se denominan subprocesos. Estos subprocesos pueden existir al mismo tiempo y ejecutarse al mismo tiempo. Un proceso puede contener varios subprocesos que se ejecutan simultáneamente.
La forma en que se implementan los hilos en Java
Hay dos formas de implementar subprocesos múltiples en Java, una es heredar la clase Thread y la otra es implementar la interfaz Runnable.
Ejemplo de implementación de la interfaz Runnable:
class MyThread implements Runnable{ // 实现Runnable接口，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法，作为线程 的操作主体
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class RunnableDemo01{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
Thread t1 = new Thread(mt1) ; // 实例化Thread类对象
Thread t2 = new Thread(mt2) ; // 实例化Thread类对象
t1.start() ; // 启动多线程
t2.start() ; // 启动多线程
}
};
Implementar la interfaz Thread
class MyThread extends Thread{ // 继承Thread类，作为线程的实现类
private String name ; // 表示线程的名称
public MyThread(String name){
this.name = name ; // 通过构造方法配置name属性
}
public void run(){ // 覆写run()方法，作为线程 的操作主体
for(int i=0;i<10;i++){
System.out.println(name + "运行，i = " + i) ;
}
}
};
public class ThreadDemo02{
public static void main(String args[]){
MyThread mt1 = new MyThread("线程A ") ; // 实例化对象
MyThread mt2 = new MyThread("线程B ") ; // 实例化对象
mt1.start() ; // 调用线程主体
mt2.start() ; // 调用线程主体
}
};
Se puede ver en el programa que los dos objetos de hilo ahora se ejecutan de manera escalonada. Qué objeto de hilo toma los recursos de la CPU y qué hilo puede ejecutarse, por lo que los resultados del programa deben ser diferentes cada vez que se inicia el hilo. Es el método start (), pero lo que realmente se llama es el cuerpo definido por el método run ().
Cambios en el estado del hilo
Para lograr el subproceso múltiple, se debe crear un nuevo objeto de subproceso en el subproceso principal. Cualquier hilo tiene generalmente 5 estados, a saber, creado, listo, en ejecución, bloqueado y terminado.
创建 ： Subproceso = nuevo hilo ()
Listo: llama al método start () del hilo para iniciar el hilo.
En ejecución: cuando se llama al estado listo y se obtienen los recursos del procesador, el subproceso entra en estado de ejecución. En este momento, se llama automáticamente al método run () del objeto hilo. El método run () define la operación y función del hilo.
Bloqueo: llamando a sleep (), suspend (), wait () y otros métodos, el hilo entrará en el estado de bloqueo
Terminación: cuando el hilo llama al método stop () o después de que finaliza la ejecución del método run (), está muerto. Un subproceso en un estado inactivo no tiene la capacidad de continuar ejecutándose.
En la operación de subprocesos de Java, todos los subprocesos permanecerán en el estado listo antes de ejecutarse. En este momento, qué subproceso tiene una prioridad más alta, qué subproceso se puede ejecutar primero.