PROGRAMACIÓN

MULTIPROCESO
PROGRAMACIÓN DE SERVICIOS Y PROCESOS. 2º D.A.M. 2022/2023
PROGRAMACIÓN MULTIPROCESO

Ejecutables. Procesos. Servicios.

Ejecutable. archivo con la estructura necesaria para que el SO pueda poner en marcha el programa que hay
dentro.(WINDOWS, .EXE)

JAVA: .jar y .class no son ejecutables, los ejecuta el intérprete java.exe (Proceso JIT, al instante)

java.exe traduce y puede averiguar en qué micro se ejecuta y optimizar rendimiento.

Un EXE puede no contener las instrucciones de los micro más modernos.

PROGRAMACIÓN MULTIPROCESO

Ejecutables. Procesos. Servicios.

Proceso. Archivo en ejecución y bajo control SO. Ciclo de vida:

● En ejecución: está dentro del microprocesador.

● Pausado/detenido/en espera: el proceso tiene que seguir en ejecución pero en ese momento el S.O
tomó la decisión de dejar paso a otro.
● Interrumpido: el proceso tiene que seguir en ejecución pero el usuario ha decidido interrumpir la
ejecución.
● Existen otros estados pero ya son muy dependientes del sistema operativo concreto.
PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.

Servicio. Proceso que no muestra ninguna ventana ni gráfico en pantalla (NO USUARIO)

Habitualmente, un servicio es un programa que atiende a otro programa.

Hilo, concepto más avanzado que un proceso:

Proceso cada uno tiene su propio espacio en memoria.

hilo es mucho más ligero, código y los datos se comparten de una forma distinta.

Procesos no tienen acceso a datos entre sí, los hilos sí.

PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.

Programación concurrente crear programas que pueden tener varios procesos/hilos

que colaboran para ejecutar un trabajo ( máximo rendimiento de sistemas multinúcleo) Un
solo ordenador puede ejecutar varias tareas a la vez (lo que supone que tiene 2 o más
núcleos).

Programación paralela, capacidad de un núcleo de ejecutar dos o más tareas a la vez

(repartiendo tiempo de proceso entre tareas)
PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
Paralelismo Concurrencia

- 2+ tareas al mismo tiempo - 2+ tareas NO al mismo tiempo

- 1 tareas por núcleo de la CPU - varias tareas por núcleo de la CPU
- A cada tarea se asigna un tiempo CPU
PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
Paralelismo y concurrencia a la vez.
- Suele ser lo más normal.
- Única manera de ejecutar más
hilos que núcleos.
- SO también añade tareas a
los núcleos.
PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
NO se puede elegir cómo ejecutar los hilos por cómo trabaja JAVA.

JAVA manda orden a SO y él se organiza.

2 hilos -> 2 Núcleos -> PARALELO… NO NECESARIAMENTE..

 PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.

Creación de procesos.

En Java es posible crear procesos utilizando algunas clases que el entorno ofrece para esta tarea. En este tema, veremos en profundidad
la clase ProcessBuilder.

El ejemplo siguiente muestra cómo lanzar un proceso de Acrobat Reader:

 PROGRAMACIÓN MULTIPROCESO
public class LanzadorProcesos {
public void ejecutar(String ruta){

ProcessBuilder pb;
try {
pb = new ProcessBuilder(ruta);
pb.start();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
/**
* @param args
*/
public static void main(String[] args) {
String ruta=
"C:\\Program Files (x86)\\Adobe\\Reader 11.0\\Reader\\AcroRd32.exe";
LanzadorProcesos lp=new LanzadorProcesos();
lp.ejecutar(ruta);
System.out.println("Finalizado");
}
 PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
Necesitamos crear un programa que aproveche al máximo el número de CPUs para realizar alguna tarea
intensiva. Supongamos que dicha tarea consiste en sumar números.

Enunciado: Crear una clase Java que sea capaz de sumar todos los números comprendidos entre dos valores
incluyendo ambos valores.

Crear clase Sumador que tenga un método que acepte dos nºs n1 y n2 y que devuelva la suma del intervalo.

Incluir un método main que ejecute la operación de suma tomando los números de la línea de comandos (es
decir, se pasan como argumentos al main).
 PROGRAMACIÓN MULTIPROCESO
Ejecutables. Procesos. Servicios.
PROGRAMACIÓN MULTIPROCESO

Ejecutables. Procesos. Servicios.

Para ejecutar esto en Eclipse hay

que indicar que deseamos enviar
argumentos al programa. Por
ejemplo, si deseamos sumar de 2
a 10, deberemos ir a la venta
«Run configuration» y en la
pestaña «Arguments» indicar los
argumentos (que en este caso
son los dos números a indicar).
 PROGRAMACIÓN
MULTIPROCESO

Ejecutables. Procesos. Servicios. public class Sumador {

public int sumar(int n1, int n2){
Una vez hecha la prueba de la int resultado=0;
clase sumador, le quitamos el for (int i=n1;i<=n2;i++){
main, y crearemos una clase que resultado=resultado+i;
sea capaz de lanzar varios }
return resultado;
procesos. La clase Sumador se
}
quedará así:
}
 package com.ies;

public class Lanzador {

public void lanzarSumador (Integer n1, Integer n2){
PROGRAMACIÓN String clase ="com.ies.Sumador" ;
ProcessBuilder pb;
MULTIPROCESO try {
pb = new ProcessBuilder(
"java",clase,
n1. toString (),
Ejecutables. Procesos. Servicios. n2. toString ());
pb. start();
} catch (Exception e) {
// TODO Auto-generated catch block
e. printStackTrace ();
Ahora, una clase que lanza }
}
procesos de esta forma: public static void main(String[] args){
Lanzador l =new Lanzador();
l. lanzarSumador (1, 51);
l. lanzarSumador (51, 100);
System. out.println("Ok");
}
}
PROGRAMACIÓN
MULTIPROCESO

Comunicación entre procesos.

Multiproceso -> comunicar información entre muchos procesos

Obliga usar mecanismos específicos de comunicación que ofrecerá Java (o a diseñar alguno
separado que evite los posibles problemas).
PROGRAMACIÓN
MULTIPROCESO

En el ejemplo, el segundo proceso

suele sobreescribir el resultado del
primero, así que modificaremos el
código del lanzador para que cada
proceso use su propio fichero de
resultados.
PROGRAMACIÓN
MULTIPROCESO

Cuando se lanza un programa desde Eclipse no ocurre lo mismo que

cuando se lanza desde Windows. Eclipse trabaja con unos directorios
predefinidos y puede ser necesario indicar a nuestro programa cual es
la ruta donde hay que buscar algo.

Usando el método .directory(new File("c:\\dir\\)) se puede

indicar a Java donde está el archivo que se desea ejecutar.
PROGRAMACIÓN
MULTIPROCESO

Ejercicio
Crear un programa que permita parametrizar el lanzamiento de
sumadores, que vuelque el contenido de las sumas en ficheros y que
permita al programa principal recuperar las sumas de los ficheros
parciales.
PROGRAMACIÓN
MULTIPROCESO

En el listado
siguiente se muestra
la clase Sumador:
 public class Main {

static final int NUM_PROCESOS=4;

PROGRAMACIÓN static final String PREFIJO_FICHEROS="fich";

MULTIPROCESO
public static void lanzarSumador(
int n1, int n2,String fichResultados) throws
IOException{
String comando;
comando="es.ies.multiproceso.Sumador";
Se muestra la
File directorioSumador;
clase Main directorioSumador=new File("C:\\Users\\"+
"ogomez\\workspace\\"+
"MultiProceso1\\bin\\");
File fichResultado=new File(fichResultados);
ProcessBuilder pb;
pb=new ProcessBuilder("java",
comando,
String.
valueOf(n1),
String.
valueOf(n2) );
pb.directory(directorioSumador);
pb.redirectOutput(fichResultado);
pb.start();
}
 public static int getResultadoFichero(
String nombreFichero){
int suma=0;
PROGRAMACIÓN try {
MULTIPROCESO FileInputStream fichero=
new FileInputStream(nombreFichero);
InputStreamReader fir=
new InputStreamReader(
fichero);
BufferedReader br=new BufferedReader(fir);
String linea=br.readLine();
suma= new Integer(linea);
return suma;
} catch (FileNotFoundException e) {
System.out.println(
"No se pudo abrir "+nombreFichero);

} catch (IOException e) {
System.out.println(
“No hay nada en "+nombreFichero);
}
return suma;
}
 public static int getSumaTotal(int numFicheros){
int sumaTotal=0;
for (int i=1; i<=NUM_PROCESOS;i++){
PROGRAMACIÓN sumaTotal+=getResultadoFichero(
PREFIJO_FICHEROS
+String.valueOf(i) );
MULTIPROCESO }
return sumaTotal;
}

/* Recibe dos parámetros y hará

* la suma de los valores comprendidos
* entre ambos parametros
*/
public static void main(String[] args) throws IOException,
InterruptedException{
int n1=Integer.parseInt(args[0]);
int n2=Integer.parseInt(args[1]);
int salto=( n2 / NUM_PROCESOS ) - 1;
for (int i=1;i<=NUM_PROCESOS; i++){
System.out.println("n1:"+n1);
int resultadoSumaConSalto=n1+salto;
PROGRAMACIÓN System.out.println("n2:"+resultadoSumaConSalto);
lanzarSumador(n1, n1+salto ,
MULTIPROCESO
PREFIJO_FICHEROS+String.valueOf(i));
n1=n1 + salto + 1;
System.out.println("Suma
lanzada...");
}
Thread.sleep(5000);
int
sumaTotal=getSumaTotal(NUM_PROCESOS);
System.out.println("La suma total
es:"+

sumaTotal);
}
}
PROGRAMACIÓN Sincronización entre procesos.
MULTIPROCESO

Si se lanza más de un proceso de una misma sección de código no se sabe qué

proceso ejecutará qué instrucción en un cierto momento .PELIGROSO

int i,j; Si dos o más procesos avanzan por esta sección

i=0;
if (i>=2){
de código es perfectamente posible que unas
i=i+1; veces nuestro programa multiproceso se ejecute
j=j+1 bien y otras no.
}
System.out.println("Ok");
i=i*2;
j=j-1;

Zonas de código peligrosas “SECCIONES CRÍTICAS”

(DEBEN PROTEGERSE)
 Mecanismos para controlar secciones críticas
PROGRAMACIÓN
MULTIPROCESO Los mecanismos más típicos son los ofrecidos por UNIX/Windows:

● Semáforos.
● Colas de mensajes.
● Tuberías (pipes)
● Bloques de memoria compartida.

REALMENTE estos mecanismos se utilizan más para

intercomunicar procesos.

PROGRAMADORES JAVA resuelven «sección crítica» +simple.

 /* La máquina virtual Java evitará que más
de un proceso/hilo acceda a este método*/
PROGRAMACIÓN synchronized
public void
MULTIPROCESO actualizarPension(int nuevoValor){
/*..trozo de código largo
omitido*/
synchronized }
this.pension=nuevoValor

Palabra clave y la /* Otro ejemplo, ahora no hemos

máquina virtual Java protegido un método entero,
sino solo un pequeño trozo de código.*/
protege el código for (int i=0; i=i+1; i++){
automáticamente. /* Código omitido*/
synchronized {
i=i*2;
j=j+1;
}
PROGRAMACIÓN Depurar un programa multiproceso/multihilo,
MULTIPROCESO por desgracia puede ser muy difícil.

Depuración 1. No todos los depuradores son capaces.

2. A veces si un depurador interviene en un proceso puede que el
resto de procesos consigan ejecutarse en el orden correcto y dar
lugar a que el programa parezca que funciona bien.
3. Error muy típico es la NullPointerException, que muchas
veces se debe al uso de referencias Java no inicializadas o a la
devolución de NULLs que luego no se comprueban en alguna
parte del código.
PROGRAMACIÓN Depurar un programa multiproceso/multihilo,
MULTIPROCESO por desgracia puede ser muy difícil.
4. Se puede usar el método redirectError pasándole un objeto de tipo
Depuración File para que los mensajes de error vayan a un fichero.

5. Recordar que la «visión» de Eclipse del sistema puede ser muy

diferente de la que tiene el proceso lanzado. Problema común es que el
proceso lanzado no encuentre clases, obligará a indicar el CLASSPATH .

6. Buen método para determinar errores es utilizar el entorno de

consola para lanzar comandos para ver «cómo es el sistema» que ve un
proceso fuera de Eclipse (o de cualquier otro entorno).
PROGRAMACIÓN Depurar un programa multiproceso/multihilo,
MULTIPROCESO por desgracia puede ser muy difícil.

Depuración
synchronized

En general todos los fallos en un programa

multiproceso vienen derivado de no usar
synchronized de la forma correcta.