Programación JAVA multiproceso
Conceptos básicos:
程序是为完成特定任务、用某种语言编写的一组指令的集合。指一段静态的代码，是一个静态的概念。
进程是具有一定独立功能程序的运行过程，是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。
线程是进程中的一个独立执行线索，是进程中的一个实体，是CPU调度和分派的基本单位，是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。在运行时，只是暂用一些计数器、寄存器和栈
Los subprocesos y procesos se dividen en cinco etapas: creación, preparación, ejecución, bloqueo y terminación
Método para iniciar el proceso:
public class T0 {
public static void main(String[] args) throws IOException {
ProcessBuilder pb = new ProcessBuilder("cmd","/c","ifconfig/all");
Process p = pb.start();
BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String temp = null;
while((temp = br.readLine())!=null)
System.out.println(temp);
}
}
Tres características del proceso: independencia, dinámica y concurrencia
Proceso zombi, proceso huérfano Un proceso
zombi es cuando el proceso hijo termina antes que el proceso padre, y el proceso padre no recicla el proceso hijo y libera los recursos ocupados por el proceso hijo. En este momento, el proceso hijo se convertirá en un zombi proceso. Si el proceso padre sale primero, init se hace cargo del proceso hijo. Una vez que el proceso hijo sale, init recuperará los recursos relevantes que ocupaba, un desperdicio de recursos del sistema y debe resolverse.
—————— Línea divisoria —————————————————————— Un
proceso huérfano es un proceso padre que sale mientras uno o más de sus procesos secundarios aún se están ejecutando, Entonces esos procesos secundarios se convertirán en procesos huérfanos. El proceso de huérfano será adoptado por el proceso de inicio (el número de proceso es 1) y el proceso de inicio completará el trabajo de recopilación de estado para ellos. -No hay daño.
Paralelo y concurrencia (énfasis)
Paralelo: múltiples instancias de CPU o múltiples máquinas ejecutan una parte de la lógica de procesamiento al mismo tiempo, lo cual es cierto al mismo tiempo.
—————— Línea divisoria ——————————————————————
Simultaneidad: a través del algoritmo de programación de la CPU, los usuarios pueden parecer que ejecutan al mismo tiempo, de hecho , desde el nivel de operación de la CPU No realmente al mismo tiempo. La concurrencia a menudo tiene un recurso común en la escena, por lo que para este recurso común a menudo un cuello de botella, usaremos TPS (el número de transacciones procesadas por segundo) o QPS (el número de solicitudes procesadas por segundo) para reflejar el procesamiento del sistema. capacidad.
Subproceso principal El subproceso es una entidad en el proceso, se utiliza para describir la ejecución del proceso, es responsable de ejecutar el código incluido en el espacio de direcciones del proceso. Cuando se crea un proceso, su primer hilo se llama hilo principal, que es generado automáticamente por el sistema.
&& El subproceso principal genera otros subprocesos secundarios; por lo general, el subproceso principal termina la ejecución en último lugar, porque el subproceso principal realiza varias acciones de apagado, pero no absolutas.
La diferencia entre subproceso y proceso La
mayor diferencia entre proceso e subproceso es que el proceso está controlado por el sistema operativo y el subproceso está controlado por el proceso.
Múltiples
subprocesos Múltiples subprocesos significa que hay varios subprocesos en un programa, cada subproceso realiza una tarea independiente y varios subprocesos se pueden ejecutar al mismo tiempo.
4 formas de realizar la programación de hilos
1. Herencia de la clase Thread La clase
Thread esencialmente implementa una instancia de la interfaz Runnable, que representa una instancia de un hilo.
La única forma de iniciar un hilo es a través del método de instancia start () de la clase Thread. No puedes llamar directamente al método run (). El método start () es un método nativo, que iniciará un nuevo hilo y ejecutará el método run (). El multihilo de esta manera es muy simple. Puede extender Thread directamente a través de su propia clase y anular el método run () para iniciar un nuevo hilo y ejecutar su propio método run () definido.
public class T1 {
public static void main(String[] args) {
Thread t1 = new MyThread();
t1.start();
}
}
class MyThread extends Thread{
public void run() {
for(int i = 0;i<10;i++) {
System.out.println("Thread---");
try {
//使当前正在执行的线程休眠等待500ms
Thread.sleep(200);
}catch(InterruptedException e) {
e.printStackTrace();
}
}
}
}
2. Implementar la interfaz Runnable
class RightRunnable implements Runnable{
public void run(){
for(int i=0;i<50;i++)
System.out.println(Thread.currentThread().getName()+"说：右手慢动作重播!");
}
}
//启动方法
//启动通过实现Runnable接口定义的线程对象，不能直接使用Runnable r=new RightRunnable();
Thread t2=new Thread(new RightRunnable());
t2.start();
3. Utilice las interfaces Callable y Future para crear un hilo
Cree una clase de implementación de la interfaz Callable e implemente el método call (). Y use la clase FutureTask para envolver los objetos de la clase de implementación Callable, y use el objeto FutureTask como el objetivo del objeto Thread para crear un hilo.
public class MyCallable implements Callable<Integer>{
int begin=0;
int end=0;
public MyCallable(int begin, int end){
this.begin=begin;
this.end=end;
}
public Integer call()throws Exception{
int res=0;
for(int k=begin; k<=end; k++)
res+=k;
System.out.println(Thread.currentThread()+"---"+res);
return res;
}
}
FutureTask[] arr=new FutureTask[10];
for(int i=0;i<10;i++){
arr[i]=new FutureTask<>(new MyCallable(i*10+1,(i+1)*10));
Thread t=new Thread(arr[i]);
t.start();
}
int res=0;
for(int i=0;i<arr.length;i++)
res+=((Integer)arr[i].get());
System.out.println("计算结果为："+res);
4. Utilice el grupo de subprocesos para crear subprocesos. El
grupo de subprocesos aquí está relacionado con un modo de peso mosca - el modo de peso mosca se puede estudiar en detalle en Baidu "Tutorial de novatos del modo de peso mosca".
Flyweight Pattern se utiliza principalmente para reducir la cantidad de objetos creados para reducir el uso de memoria y mejorar el rendimiento. Este tipo de patrón de diseño es un patrón estructural, que proporciona una forma de reducir el número de objetos para mejorar la estructura del objeto requerida por la aplicación.
Ventajas: reduce en gran medida la creación de objetos y reduce el uso de la memoria del sistema para mejorar la eficiencia de ejecución del programa.
Desventajas: la complejidad del sistema aumenta, el estado externo y el estado interno deben separarse, y el estado externo tiene una naturaleza inherente y no debe seguir al estado interno. El estado cambia y cambia, de lo contrario causará caos en el sistema.
public class T0 {
public static void main(String[] args) {
//创建一个 固定大小为 3 的线程池；
ExecutorService es = Executors.newFixedThreadPool(10);
Future[] fs = new Future[10];
for(int i = 0;i<fs.length;i++) {
Callable<Integer> call = new MyCallable(i*10+1, (i+1)*10);
fs[i] = es.submit(call);
}
int res = 0;
for(int i=0;i<fs.length;i++) {
Object obj = fs[i].get();
if(obj!=null&&obj instanceof Object)
res+=(Integer)obj;
}
es.shutdown();
System.out.println("main"+res);
}
}
class MyCallable implements Callable<Integer>{
private int begin;
private int end;
public MyCallable(int begin, int end) {
super();
this.begin = begin;
this.end = end;
}
public Integer call() throws Exception {
System.out.println(Thread.currentThread().getName());
int res = 0;
for(int i = begin;i<=end;i++)
res+=i;
return res;
}
}
Antes había un pequeño problema con la creación del grupo de subprocesos. El primer problema es: el último rango de la sexta línea de código es incorrecto (corregido). El
segundo problema, el número de grupos de subprocesos en la tercera línea debería ser: 10;
Una última pregunta: el valor de i en la quinta línea desde abajo debe ser menor e igual al final. De lo contrario, al valor de salida le falta el valor final.
Los problemas anteriores se han corregido.