MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS

TEMA 1: PROGRAMACIÓN DE PROCESOS

1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
“Ley de Alzheimer de la programación: si lees un código que escribiste hace más de
dos semanas es como si lo vieras por primera vez”
Danny Hurvitz
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS

1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.1.- Introducción.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.

1.2.- Procesos y sistema operativo.

1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.2.- Procesos y sistema operativo.
1.2.- Procesos y sistema operativo.

Un proceso consiste en
- El código ejecutable del programa
- Los datos y la pila del programa
- El contador del programa
- El puntero de la pila y otros registros
- Toda la información necesaria para ejecutar el programa
1.2.- Procesos y sistema operativo.

Bloque de Control de Proceso (BCP):

- Identificación del proceso.
- Estado del proceso.
- Contador de programa.
- Registros de CPU.
- Información de planificación de CPU
como la prioridad del proceso.
- Información de gestión de memoria.
- Información contable como la cantidad de tiempo de CPU y
tiempo real consumido.
- Información de estado de E/S como la lista de dispositivos
asignados, archivos abiertos, etc.
1.2.- Procesos y sistema operativo.

El comando ps (process status) de Linux

PID: identificador del proceso
TTY: terminal asociado del que lee y al que escribe
TIME: tiempo de ejecución asociado. Es el tiempo total de CPU que el proceso ha
utilizado desde que existe.
CMD: nombre del proceso.
ps –f
UID: nombre de usuario.
PPID: PID del proceso padre.
C: porcentaje de recursos de CPU utilizado por el proceso.
STIME: hora de inicio el proceso.
ps –AF muestra todos los procesos activos con todos los detalles
1.2.- Procesos y sistema operativo.

La orden tasklist de Windows y el monitor de tareas

 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.

1.2.1.- Estados de un proceso.

1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.2.1.- Estados de un proceso.

- En ejecución.

- Bloqueado.

- Listo
1.2.1.- Estados de un proceso.

Transiciones entre los estados:

• En ejecución – Bloqueado.
• Bloqueado – Listo.
• Listo – En ejecución.
• En ejecución – Listo.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.

1.2.2.- Creación de procesos con Java.

1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.2.2.- Creación de procesos con Java.

Java tiene varias clases para la gestión de procesos en el paquete [Link]. Una de ellas es
ProcessBuilder. Cada instancia ProcessBuilder gestiona una colección de atributos del
proceso.
El método start() de la clase ProcessBuilder crea una nueva instancia de Process con esos
atributos.
Por ejemplo, para lanzar el comando DIR del DOS como un proceso escribiríamos:
ProcessBuilder pb = new ProcessBuilder(“CMD”, “/C”, “DIR”);
Process p = [Link]();

indicando en el constructor de ProcessBuilder los argumentos del proceso que se quiere

ejecutar como una lista de cadenas separadas por comas, y después usando el método
start() para iniciar el proceso.
1.2.2.- Creación de procesos con Java.

La clase Process proporciona métodos para realizar la entrada desde el proceso, obtener la
salida del proceso, esperar a que el proceso se complete, comprobar el estado de salida del
proceso y destruir el proceso.
1.2.2.- Creación de procesos con Java.

Por defecto el proceso que se crea no tiene su propio terminal o consola. Toda las
operaciones de E/S serán redirigidas al proceso padre, donde se puede acceder a ellas
usando los métodos getOutputStream(), getInputStream() y getErrorStream(). El proceso
padre utiliza estos flujos para alimentar la entrada y obtener la salida del subproceso.
Cada constructor de ProcessBuilder gestiona los siguientes atributos de un proceso:

- Un comando.
- Un entorno (environment) con sus variables.
- Un directorio de trabajo. El valor por defecto es la ubicación del proceso en curso.
- Una fuente de entrada estándar.
- Un destino para la salida estándar y la salida de error.
- Una propiedad redirectErrorStream.
1.2.2.- Creación de procesos con Java.

Algunos métodos de la clase ProcessBuilder.

1.2.2.- Creación de procesos con Java.

Para iniciar un proceso que utiliza el directorio de trabajo y el entorno del proceso en curso
se utiliza
Process p = new ProcessBuilder(“Comando”, “Argum1”).start();

Ejemplo1 muestra cómo se puede ejecutar una aplicación de Windows (el Notepad). Es el
código que hemos visto antes:
ProcessBuilder pb = new ProcessBuilder(“NOTEPAD”);
Process p = [Link]();
1.2.2.- Creación de procesos con Java.

Hay comandos de DOS que no tienen un archivo ejecutable ya que están “embebidos” en
el intérprete de comandos. Uno de ellos, por ejemplo, es el comando DIR.
Para ejecutar este tipo de comandos es necesario indicar al constructor del proceso que hay
que ejecutar antes el comando [Link]. Para hacer un DIR desde un programa Java
tendríamos que construir por tanto un ProcessBuilder con los argumentos “CMD”, “/C”,
y “DIR”.

CMD inicia una instancia del interprete de comandos de Windows. Para ejecutar un
comando escribimos:
CMD /C comando -> Se ejecuta el comando especificado y luego se finaliza.
CMD /K comando -> Se ejecuta el comando especificado, pero sigue activo.
1.2.2.- Creación de procesos con Java.

El siguiente ejemplo ejecuta el comando DIR usando el método getInputStream() de

Process para leer el stream de salida del proceso.
InputStream is = [Link]();

Para leer la salida se usa el método read() de InputStream que devolverá la salida carácter
a carácter.
Process p = new ProcessBuilder("CMD", "/C", "DIR").start();
try {
InputStream is = [Link]();
// mostramos en pantalla caracter a caracter
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();
} catch (Exception e) {
[Link]();
}
1.2.2.- Creación de procesos con Java.

Código completo:

public class Ejemplo2 {

public static void main(String[] args) throws IOException {

Process p = new ProcessBuilder("CMD", "/C", "DIR").start();

try {
InputStream is = [Link]();
// mostramos en pantalla caracter a caracter
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();
} catch (Exception e) {
[Link]();
}
1.2.2.- Creación de procesos con Java.

Código completo:

// COMPROBACION DE ERROR - 0 bien - 1 mal

int exitVal;
try {
//se recoge la salida de [Link]()
exitVal = [Link]();
[Link]("Valor de Salida: " + exitVal);
} catch (InterruptedException e) {
[Link]();
}
}
}// Ejemplo2
1.2.2.- Creación de procesos con Java.

Código completo:

// COMPROBACION DE ERROR - 0 bien - 1 mal

int exitVal;
try {
//se recoge la salida de [Link]()
exitVal = [Link]();
[Link]("Valor de Salida: " + exitVal);
} catch (InterruptedException e) {
[Link]();
}
}
}// Ejemplo2
1.2.2.- Creación de procesos con Java.

El siguiente ejemplo es un programa Java que ejecuta el programa Java anterior.

public class Ejemplo3 {

public static void main(String[] args) throws IOException {

//creamos objeto File al directorio donde esta Ejemplo2

File directorio = new File(".\\bin");

//El proceso a ejecutar es Ejemplo2

ProcessBuilder pb = new ProcessBuilder("java", "Ejemplo2");

//se establece el directorio donde se encuentra el ejecutable

[Link](directorio);

[Link]("Directorio de trabajo: %s%n",[Link]());

1.2.2.- Creación de procesos con Java.

El siguiente ejemplo es un programa Java que ejecuta el programa Java anterior.

//se ejecuta el proceso

Process p = [Link]();

//obtener la salida devuelta por el proceso

try {
InputStream is = [Link]();
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();
} catch (Exception e) {
[Link]();
}
}
}// Ejemplo3
1.2.2.- Creación de procesos con Java.

Ejercicio 1.1
Realiza un programa java llamado [Link] que reciba desde los
argumentos de main() un nombre y lo visualice en pantalla. Utiliza [Link](1)
para una finalización correcta del programa y [Link](-1) para el caso que no se
hayan introducido los argumentos correctos en main().
A continuación, haz un programa parecido a [Link] para ejecutar
[Link]. Utiliza el método waitFor() para comprobar el valor de salida del
proceso que se ejecuta. Prueba la ejecución del programa dando valor a los
argumentos de main() y sin darle valor. ¿Qué valor devuelve waitFor() en un caso y
otro?
1.2.2.- Creación de procesos con Java.

Ejercicio 1.2
Realiza un programa java que admita argumentos desde main() y devuelva con
[Link]() los siguientes valores:
• Si el número de argumentos es <1 debe devolver 1.
• Si el argumento es una cadena debe devolver 2.
• Si el argumento es un número entero menor que 0 debe devolver 3.
• En cualquier otra situación debe devolver 0.
Realiza un segundo programa java que ejecute al anterior. Este segundo programa
deberá mostrar en pantalla lo que pasa dependiendo del valor devuelto al ejecutar el
programa anterior.
1.2.2.- Creación de procesos con Java.

Ejercicio 1.3
Escribe un programa java que visualice 5 veces la cadena que se le envía desde los
argumentos de main(). Si no se le envía ninguna cadena, que muestre un mensaje
indicándolo y que finalice el programa con [Link](1).
A continuación, crea un segundo programa Java que introduzca por teclado una
cadena y ejecute el programa anterior para visualizar 5 veces esa cadena.
1.2.2.- Creación de procesos con Java.

Ejercicio 1.4
Partiendo del ejercicio 1.3 realiza los cambios necesarios para que la cadena
introducida por teclado se almacene en un fichero de texto, no mostrándola en
pantalla. Guarda los programas en otra carpeta y compílalos y ejecútalos desde la
línea de comandos del DOS.
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Hay procesos que requieren un input, por ejemplo el comando DATE de DOS.

La clase Process tiene el método getOutputStream() que permite escribir en el

stream de entrada del proceso.
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo 4: Ejecutar el proceso DATE con el valor de la fecha actual. El método
write() envía los datos al stream, el método getBytes() codifica la cadena.

public class Ejemplo4 {

public static void main(String[] args) throws IOException {
Process p = new ProcessBuilder("CMD", "/C", "DATE").start();

// escritura -- envia entrada a DATE

OutputStream os = [Link]();
[Link]("15-12-23".getBytes());
[Link](); // vacia el buffer de salida
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo 4:
// lectura -- obtiene la salida de DATE
InputStream is = [Link]();
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();
// COMPROBACION DE ERROR - 0 bien - 1 mal
int exitVal;
try {
exitVal = [Link]();
[Link]("Valor de Salida: " + exitVal);
} catch (InterruptedException e) {
[Link]();
}
}
}//Ejemplo4
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Supongamos que tenemos un programa Java que lee una cadena desde la entrada
estándar y la visualiza:
public class EjemploLectura{
public static void main (String [] args)
{
InputStreamReader in = new InputStreamReader([Link]);
BufferedReader br = new BufferedReader(in);
String texto;
try {
[Link]("Introduce una cadena....");
texto= [Link]();
[Link]("Cadena escrita: " + texto);
[Link]();
}catch (Exception e) { [Link]();}
}
}//EjemploLectura
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Con el método getOutputStream() podemos enviar datos a la entrada estándar del
programa [Link]. Por ejemplo, si queremos enviar la cadena “Hola
Manuel” cambiaríamos varias cosas en el [Link]:

Cada línea que mandemos a EjemploLectura debe terminar con “\n”, igual que
cuando escribimos dese el terminal de lectura terminamos pulsando enter.
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo5

public class Ejemplo5 {

public static void main(String[] args) throws IOException {
File directorio = new File(".\\bin");
ProcessBuilder pb = new ProcessBuilder("java", "EjemploLectura");
[Link](directorio);
// se ejecuta el proceso
Process p = [Link]();
// escritura -- envia entrada
OutputStream os = [Link]();
[Link]("Hola Manuel\n".getBytes());
[Link](); // vacia el buffer de salida
// lectura -- obtiene la salida
InputStream is = [Link]();
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo5

// COMPROBACION DE ERROR - 0 bien - 1 mal

int exitVal;
try {
exitVal = [Link]();
[Link]("Valor de Salida: " + exitVal);
} catch (InterruptedException e) {
[Link]();
}
try {
InputStream er = [Link]();
BufferedReader brer = new BufferedReader(new
InputStreamReader(er));
String liner = null;
while ((liner = [Link]()) != null)
[Link]("ERROR >" + liner);
} catch (IOException ioe) {
[Link]();
}
}
}// Ejemplo5
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejercicio 1.5
Escribe un programa Java que lea dos números desde la entrada estándar y visualice
su suma.
Controla que lo introducido por teclado sean dos números.
Escribe otro programa Java que ejecute el anterior.
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejercicio 1.6
Escribe un programa Java que lea cadenas desde la entrada estándar hasta que se
escriba un asterisco (*). A continuación escribe otro programa que ejecute el anterior.
1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo 6: Usa 2 métodos de la clase ProcessBuilder:

- environment(): Devuelve las variables de entorno del proceso

- command() Sin parámetros devuelve los argumentos del proceso definido en el

objeto ProcessBuilder,

- y command() con parámetros define un nuevo proceso y sus argumentos.

1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo 6:

public class Ejemplo6 {

public static void main(String args[]) {

//File directorio = new File(".\\bin");

ProcessBuilder test = new ProcessBuilder();

Map entorno = [Link]();
[Link]("Variables de entorno:");
[Link](entorno);

test = new ProcessBuilder("java", "LeerNombre", "Maria Jesus");

1.2.2.- Creación de procesos con Java.

ENVIO DE DATOS AL STREAM DE ENTRADA DEL PROCESO.

Ejemplo 6:

// devuelve el nombre del proceso y sus argumentos

List l = [Link]();
Iterator iter = [Link]();
[Link]("\nArgumentos del comando:");
while ([Link]())
[Link]([Link]());

// ejecutamos el comando DIR

test = [Link]("CMD", "/C", "DIR");
try {
Process p = [Link]();
InputStream is = [Link]();

[Link]();
// mostramos en pantalla caracter a caracter
int c;
while ((c = [Link]()) != -1)
[Link]((char) c);
[Link]();

} catch (Exception e) {
[Link]();
}
}
}// Ejemplo6
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Métodos redirectOutput() y redirectError()

Ejemplo 7: ejecuta el comando DIR y envía la salida al fichero [Link]. Si hay algún
error lo envía al fichero [Link]

public class Ejemplo7 {

public static void main(String args[]) throws IOException {
ProcessBuilder pb = new ProcessBuilder("CMD","/C"
,"DIR");

File fOut = new File("[Link]");

File fErr = new File("[Link]");

[Link](fOut);
[Link](fErr);
[Link]();
}
}// Ejemplo7
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Método redirectInput()
Ejemplo 8

public class Ejemplo8 {

public static void main(String args[]) throws IOException {
ProcessBuilder pb = new ProcessBuilder("CMD");

File fBat = new File("[Link]");

File fOut = new File("[Link]");
File fErr = new File("[Link]");

[Link](fBat);
[Link](fOut);
[Link](fErr);
[Link]();
}
}// Ejemplo8
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Ejercicio 1.7
Modifica el [Link] para que la salida del proceso y la salida de error se
almacenen en un fichero de texto, y la entrada la tome desde otro fichero externo.
.
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Para llevar a cabo el redireccionamiento, tanto de entrada como de salida del proceso
que se ejecuta, también podemos usar la clase [Link]. El
redireccionamiento pude ser uno de los siguientes:
• El valor especial [Link], indica que la fuente de entrada y salida
del proceso será la misma que la del proceso actual.
• [Link] (File), indica redirección para leer de un fichero, la entrada al
proceso se encuentra en el objeto File.
• [Link](File), indica redirección para escribir en un fichero, el proceso
escribirá en el objeto File.
• [Link](File), indica redirección para añadir a un fichero, la salida
del proceso se añadirá en el objeto File especificado.
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

El Ejemplo 8 quedaría así
ProcessBuilder pb = new ProcessBuilder("CMD");

File fBat = new File("[Link]");

File fOut = new File("[Link]");
File fErr = new File("[Link]");

[Link]([Link](fBat));
[Link]([Link](fOut));
[Link]([Link](fErr));

Process p = [Link]();
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Ejemplo 9: se muestra en la consola la salida del comando DIR:

public class Ejemplo9 {

public static void main(String args[]) throws IOException {
ProcessBuilder pb = new ProcessBuilder("CMD", "/C", "DIR");

//la salida a consola

[Link]([Link]);
Process p = [Link]();
}
}// Ejemplo9
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Ejercicio 1.8.-
Usando [Link], modifica el [Link] para que la salida del proceso
se muestre en la consola, la entrada la tome desde un fichero de texto, y la salida la lleve a
un fichero de texto.
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Ejercicio 1.9.-
Escribe un programa Java que lea una cadena desde la entrada estándar y visualice en
pantalla si la cadena es o no palíndromo o si la cadena está vacía (la longitud es cero).
Realiza un segundo programa Java que ejecute el anterior. Debe leer la cadena desde el
teclado y mostrar la salida por pantalla. Transforma este ejercicio para que la cadena se
obtenga de un fichero de texto, y se envíe la salida de error a un fichero.
1.2.2.- Creación de procesos con Java.

REDIRECCIONANDO LA ENTRADA Y LA SALIDA

Ejercicio 1.10.-
Modifica el ejercicio 1.6 para que al ejecutar el programa, la entrada al proceso se obtenga
a partir de un fichero de texto.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.

1.3.- Programación concurrente.

1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.- Programación concurrente.

CONCURRENCIA:
(De concurrente).
1. f. Acción y efecto de concurrir.
2. f. Conjunto de personas que asisten a un acto o reunión.
3. f. Coincidencia, concurso simultáneo de varias circunstancias.
4. f. Asistencia, participación.
Real Academia Española © Todos los derechos reservados
En informática: existencia simultánea de varios procesos en ejecución.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.

1.3.1.- Programa y proceso.

1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.1.- Programa y proceso.

Proceso es un programa en ejecución. Es activo.

Programa es un conjunto de instrucciones que se aplican a un conjunto de datos de entrada
para obtener una salida. Es pasivo.
Un programa puede dar lugar a varios procesos, cada uno ejecutando una parte del
programa, como el navegador web.
1.3.1.- Programa y proceso.

Supongamos que tenemos un programa almacenado en el disco y 3 instancias del mismo

ejecutándose, por ejemplo, por 3 usuarios diferentes. Cada instancia del programa es un
proceso, por tanto existen 3 procesos independientes ejecutándose al mismo tiempo sobre
el sistema operativo, tenemos entonces 3 procesos concurrentes.

Proceso Proceso Proceso

P1 P2 P3

SISTEMA OPERATIVO

PROGRAMA
1.3.1.- Programa y proceso.

Dos procesos serán concurrentes cuando la primera instrucción de uno de ellos se ejecuta
después de la primera instrucción del otro y antes de la última, es decir, hay un
solapamiento o intercalado en la ejecución de las instrucciones.
No es lo mismo solapamiento que ejecución simultánea, en este caso hablaríamos de
programación paralela (que necesita un hardware adecuado: multiprocesador).
1.3.1.- Programa y proceso.

Supongamos ahora que el programa anterior al ejecutarse da lugar a 2 procesos más, cada
uno de ellos ejecutando una parte del programa. Entonces la situación anterior se
convertiría en esta:

P1 P1 P2 P2 P3 P3
1 2 1 2 1 2

SISTEMA OPERATIVO

PROGRAMA
1.3.1.- Programa y proceso.

Podemos definir entonces un proceso como:

“Una actividad asíncrona susceptible de ser asignada a un procesador.”

Cuando varios procesos se ejecutan concurrentemente puede haber procesos que

colaboren para un determinado fin (por ejemplo P1.1 y P1.2) y otros que compitan por
los recursos del sistema (por ejemplo P2.1 y P3.1).

Estas tareas de colaboración y competencia por los recursos requieren mecanismos de

comunicación y sincronización entre procesos.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.

1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.2.- Características.

La programación concurrente es la disciplina que se encarga del estudio de las

notaciones que permiten especificar la ejecución concurrente de las acciones de un
programa, así como las técnicas para resolver los problemas inherentes a la ejecución
concurrente (comunicación y sincronización).
1.3.2.- Características.

BENEFICIOS

• Mejor aprovechamiento de la CPU.

• Velocidad de ejecución.

• Solución a problemas de naturaleza concurrente:

o Sistemas de control: Son sistemas en los que hay captura de datos, normalmente a

través de sensores, análisis y actuación en función del análisis.

o Tecnologías web: concurrencia de peticiones.

o Aplicaciones basadas en GUI: El usuario puede interactuar con la aplicación

mientras la aplicación está realizando otra tarea.

o Simulación.

o SGBD: Cada usuario del sistema puede ser visto como un proceso.
1.3.2.- Características.

CONCURRENCIA Y HARDWARE
En un sistema monoprocesador el sistema operativo va alternando el tiempo entre los
procesos. El S.O. va alternando el tiempo entre los distintos procesos, cuando uno necesita
realizar una operación de entrada salida, lo abandona y lo ocupa otro; de esta forma se
aprovechan los ciclos del procesador. En la figura se ve como el tiempo de procesador se
reparte entre 3 procesos, en cada momento sólo hay un proceso. Esta forma de gestionar
los procesos en un sistema monoprocesador se llama multiprogramación:

En un sistema monoprocesador todos los procesos comparten la misma memoria. La forma de

comunicar y sincronizar procesos se realiza mediante variables compartidas.
1.3.2.- Características.

En un sistema multiprocesador podemos tener un proceso en cada procesador

Esto permite que exista paralelismo real entre los procesos. Estos pueden ser de memoria
compartida (fuertemente acoplados) o con memoria local a cada procesador (débilmente
acoplados). Se denomina multiproceso a la gestión de varios procesos dentro de un
sistema multiprocesador, donde cada procesador puede acceder a una memoria común.
1.3.2.- Características.

Sistemas fuertemente acoplados

Sistemas débilmente acoplados

 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.

1.3.3.- Programas concurrentes.

1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.3.- Programas concurrentes.

Un programa concurrente define un conjunto de acciones que pueden ser ejecutadas

simultáneamente.
Si tuviéramos un programa con las siguientes instrucciones:
X := X+1
Y := X+1
La primera instrucción debe ejecutarse antes de la segunda.
En cambio, si tuviéramos
X := 1
Y := 2
Z := 3
El orden de ejecución no interviene en el resultado final.
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Son un conjunto de condiciones formales que determinan si dos procesos pueden ser
ejecutados en paralelo.
Ii: Conjunto de variables de entrada al proceso Pi (read set).
Oi: Conjunto de variables de salida del proceso Pi (write set).
“Variables”: son operandos a ser cargados/almacenados (loaded/stored) en registros o
posiciones de memoria.
Consideremos los procesos P1 y P2, y sus conjuntos de entrada I1 e I2 y de salida O1 y O2.
Las condiciones de Bernstein para dependencia de datos son:
• I1  O2 = 0 (antidependencia)
• I2  O1 = 0 (flujo)
• O1 O2 = 0 (salida)

Si se verifican las tres condiciones, P1 y P2 pueden ejecutarse en paralelo y se denota

como: P1 || P2.
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Es decir que si P1 || P2 el orden de ejecución de dos procesos es irrelevante, en tanto
que
o La salida de uno no es usada como entrada por el otro.
o No escriben sobre las mismas variables de salida.

Propiedades de la relación de paralelismo ||:

o Conmutativa: Pi || Pj  Pj|| Pi
o NO transitiva: Pi || Pj y Pj || Pk  Pi || Pk
o Asociativa: (Pi || Pj) || Pk  Pi || (Pj || Pk)

Por tanto no es una relación de equivalencia.

1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejemplo:
Detectar que instrucciones del siguiente código se pueden ejecutar concurrentemente:
- Instrucción 1 x:=y+1
- Instrucción 2 y:=x-2
- Instrucción 3 z:= a+b-7

En primer lugar, establecemos qué variables son de lectura:

- Para la instrucción 1 es la variable “y”.
- Para la instrucción 2 es la variable “x”.
- Para la instrucción 3 son las variables “a” y “b”.

A continuación, establecemos las variables de escritura

- Para la instrucción 1 es la variable “x”.
- Para la instrucción 2 es la variable “y”.
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejemplo:
• Condición 1: La intersección entre las variables de lectura de un conjunto de
instrucciones 1 y las variables de escritura de un conjunto 2 debe ser vacía.
o Instrucciones 1 y 2: No cumple la condición

Lectura 1 Escritura 2
y y

o Instrucciones 1 y 3: Cumple la condición

Lectura 1 Escritura 3
y z

o Instrucciones 2 y 3: Cumple la condición

Lectura 2 Escritura 3
x z
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejemplo:
• Condición 2: La intersección entre las variables de escritura de un conjunto de
instrucciones 1 y las variables de lectura de un conjunto 2 debe ser vacía.
o Instrucciones 1 y 2: No cumple la condición

Escritura 1 Lectura 2
x x

o Instrucciones 1 y 3: Cumple la condición

Escritura 1 Lectura 3
x a, b

o Instrucciones 2 y 3: Cumple la condición

Escritura 2 Lectura 3
y a, b
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejemplo:
• Condición 3: La intersección entre las variables de escritura de un conjunto de
instrucciones 1 y las variables de escritura de un conjunto 2 debe ser vacía.
o Instrucciones 1 y 2: Cumple la condición

Escritura 1 Escritura 2
x y

o Instrucciones 1 y 3: Cumple la condición

Escritura 1 Escritura 3
x z

o Instrucciones 2 y 3: Cumple la condición

Escritura 2 Escritura 2
y z
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejemplo:
Ahora podemos saber qué instrucciones pueden ejecutarse concurrentemente:

Par de Condición 1 Condición 2 Condición 3 ¿Pueden ejecutarse

instrucciones concurrentemente?

1y2 NO NO SI NO

1y3 SI SI SI SI

2y3 SI SI SI SI
1.3.3.- Programas concurrentes.

CONDICIONES DE BERSTEIN
Ejercicio 1.11.-
Detectar el paralelismo en los siguientes códigos:
a) Un grupo de 5 procesos formados por:
P1: C = D*E
P2: M = G + C
P3: A = B + C
P4: C = L + M
P5: F = G / E

a) Un grupo de 4 procesos formados por:

P1: a = x + y
P2: b = z – 1
P3: c = a – b
P4 w = c + 1
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.4.- Problemas inherentes a la programación concurrente.

A la hora de crear un programa concurrente podemos encontrarnos dos problemas:

• Exclusión mutua. Región crítica.

• Condición de sincronización.

Algunas herramientas para manejar la concurrencia son: la región crítica, los semáforos,
región crítica condicional, buzones, sucesos, monitores y sincronización por rendez-vous.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.

1.3.5.- Programación concurrente con Java.

1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
1.3.5.- Programación concurrente con Java.

Igual que un programa puede ejecutar varios procesos concurrentemente, dentro de un

proceso podemos encontrarnos con varios hilos de ejecución.
Un hilo es como una secuencia de control dentro de un proceso que ejecuta sus
instrucciones de forma independiente.

Los hilos comparten el contexto del proceso, pero cada hilo mantiene una parte local.
1.3.5.- Programación concurrente con Java.

Diferencias entre proceso e hilo:

• Los hilos comparten el espacio de memoria del usuario, muchos comparten datos y
espacios de direcciones; a diferencia de los procesos que generalmente poseen espacios
de memoria independientes en interactúan a través de mecanismos de comunicación
dados por el sistema.
• Hilos y procesos pueden encontrarse en diferentes estados, pero los cambios de estado en
los procesos son más costosos ya que los hilos pertenecen al mismo proceso. A los hilos
también se les llama procesos ligeros.
• Se tarda menos tiempo en crear o en terminar un hilo que un proceso.
• En la comunicación entre procesos debe intervenir el núcleo del sistema, entre hilos no se
necesita que intervenga el núcleo.
1.3.5.- Programación concurrente con Java.

Para programar concurrentemente podemos dividir el programa en hilos. Java proporciona

la construcción de programas concurrentes mediante la clase Thread (hilo). Esta clase
permite ejecutar código en un hilo de ejecución independiente.
En Java hay dos formas de crear un hilo:
• Creando una clase que herede de la clase Thread y sobrecargando el método run().
• Implementando la interface Runnable, y declarando el método run(). Esta forma se
utiliza cuando una clase ya deriva de otra. Por ejemplo, un applet hereda de la clase
Applet por lo que no puede heredar también de Thread.
1.3.5.- Programación concurrente con Java.

Ejemplo que crea un hilo de nombre HiloSimple heredando de la clase Thread. En el

método run() se indican las líneas de código que se ejecutarán simultáneamente con las
otras partes del programa. Cuando se termina la ejecución de este método, el hilo de
ejecución termina también:

public class HiloSimple extends Thread {

public void run(){
for (int i=0; i<5; i++)
[Link](“En el Hilo… “);
}
}
1.3.5.- Programación concurrente con Java.

Para usar el hilo:

public class UsaHilo{

public static void main(String[] args) {
HiloSimple hs = new HiloSimple();
[Link]();
for (int i = 0; i < 5; i++)
[Link](“Fuera del Hilo… “);
}
}
1.3.5.- Programación concurrente con Java.

Usando la interfaz Runnable quedarían así:

public class HiloSimple2 implements Runnable {
public void run(){
for (int i=0; i<5; i++)
[Link]("En el Hilo...");

}
}

public class UsaHilo2{

public static void main(String[] args) {
HiloSimple2 hs = new HiloSimple2();
Thread t = new Thread(hs);
[Link]();
for (int i = 0; i < 5; i++)
[Link]("Fuera del Hilo...");}}
1.3.5.- Programación concurrente con Java.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.

1.4.- Programación paralela y distribuida.

1.4.1.- Programación paralela.
1.4.2.- Programación distribuida..
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.

1.4.1.- Programación paralela.

1.4.2.- Programación distribuida..
1.4.1.- Programación paralela.

Un programa paralelo es un tipo de programa concurrente diseñado para ejecutarse en un

sistema multiprocesador. El sistema puede ser un conjunto de equipos en red, un único
equipo multiprocesador, o una combinación de ambos. El problema a resolver se divide en
partes independientes de tal forma que cada elemento pueda ejecutar la parte de programa
que le corresponda.
1.4.1.- Programación paralela.

En un sistema multiprocesador tenemos dos modelos dependiendo del uso de la memoria:

• Memoria compartida: los procesadores comparten físicamente la memoria, es decir,

todos acceden al mismo espacio de direcciones. Un valor escrito en memoria por un

procesador puede ser leído directamente por cualquier otro.

• Modelo de paso de mensajes: cada procesador dispone de su propia memoria

independiente. Para realizar el intercambio de información cada procesador tiene que

enviar la información al procesador que la necesite. El entorno de programación PVM

utiliza este modelo.

1.4.1.- Programación paralela.

El intercambio de información entre procesadores depende del sistema de almacenamiento

de que se disponga. Las arquitecturas paralelas se clasifican en: Sistemas de memoria
compartida o multiprocesadores: los procesadores comparten físicamente la memoria; y
Sistemas de memoria distribuida o multicomputadores: cada procesador dispone de su
propia memoria.

Dentro de los sistemas de memoria distribuida nos encontramos con los Clústeres. Son
sistemas de procesamiento paralelo y distribuido donde se utilizan múltiples ordenadores
enlazados en una red de forma que el conjunto de ordenadores es visto como un único
ordenador más potente.
Tradicionalmente el paralelismo se ha usado en los centros de supercomputación, pero en
la última década su interés se ha extendido por las limitaciones de la velocidad de los
procesadores y su tendencia a crecer en número de núcleos.
1.4.1.- Programación paralela.

Tradicionalmente el paralelismo se ha usado en los centros de supercomputación, para

resolver problemas de elevado coste computacional en un tiempo razonable, pero en la
última década su interés se ha extendido por las limitaciones de la velocidad de los
procesadores y su tendencia a crecer en número de núcleos.

Centro Nacional de Supercomputación (Barcelona) Procesador Intel Xeon E5 de 16 núcleos

1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Ventajas del procesamiento paralelo:
• Ejecución simultánea de tareas.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Ventajas del procesamiento paralelo:
• El tiempo total de ejecución de una aplicación es menor.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Ventajas del procesamiento paralelo:
• Resolución a problemas complejos y de grandes dimensiones.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Ventajas del procesamiento paralelo:
• Utilización de recursos no locales, por ejemplo, los recursos que están en una red
distribuida, una WAN o la propia red Internet.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Ventajas del procesamiento paralelo:
• Disminución de costos, en vez de gastar en un supercomputador muy caro se pueden
utilizar otros recursos más baratos disponibles remotamente.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Inconvenientes:
• Los compiladores y entornos de programación para sistemas paralelos son más difíciles
de desarrollar.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Inconvenientes:
• Los programas paralelos son más difíciles de escribir.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Inconvenientes:
• El consumo de energía es mayor.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Inconvenientes:
• El acceso a datos es más complejo.
1.4.1.- Programación paralela.

VENTAJAS E INCONVENIENTES
Inconvenientes:
• Tiene que haber comunicación y sincronización entre las subtareas.
 MÓDULO: PROGRAMACIÓN DE SERVICIOS Y PROCESOS
TEMA 1: PROGRAMACIÓN DE PROCESOS
1.1.- Introducción.
1.2.- Procesos y sistema operativo.
1.2.1.- Estados de un proceso.
1.2.2.- Creación de procesos con Java.
1.3.- Programación concurrente.
1.3.1.- Programa y proceso.
1.3.2.- Características.
1.3.3.- Programas concurrentes.
1.3.4.- Problemas inherentes a la programación concurrente.
1.3.5.- Programación concurrente con Java.
1.4.- Programación paralela y distribuida.
1.4.1.- Programación paralela.

1.4.2.- Programación distribuida..

1.4.2.- Programación distribuida..

Uno de los motivos principales para construir un sistema distribuido es compartir recursos.
El sistema distribuido más conocido por todos es Internet. Entre las aplicaciones más
recientes de la computación distribuida se encuentra el Cloud Computing.
Se define un sistema distribuido como aquel en el que los componentes hardware o
software, localizados en computadores en red, comunican y coordinan sus acciones
mediante el paso de mensajes. Esta definición tiene como consecuencias:
• Concurrencia: Lo normal en una red de ordenadores es la ejecución de programas
concurrentes.
• Inexistencia de reloj global. Cuando los programas necesitan cooperar coordinan sus
acciones mediante el paso de mensajes. No hay temporalización.
• Fallos independientes: Cada componente del sistema puede fallar independientemente
sin afectar la continuidad de los demás.
1.4.2.- Programación distribuida..

La programación distribuida es un paradigma de la programación enfocado a desarrollar

sistemas distribuidos, abiertos, escalables, transparentes y tolerantes a fallos.
Una arquitectura típica para el desarrollo de sistemas distribuidos es la arquitectura
cliente-servidor. Los clientes son elementos activos que demandan servicios realizando
peticiones y esperando respuestas. Los servidores son elementos pasivos que realizan las
tareas bajo requerimientos de los clientes.
1.4.2.- Programación distribuida..

Hay varios modelos de programación para la comunicación entre los procesos de un

sistema distribuido:
• Sockets. Proporcionan los puntos extremos para la comunicación entre procesos. Es
actualmente la base de la comunicación.
1.4.2.- Programación distribuida..

Hay varios modelos de programación para la comunicación entre los procesos de un

sistema distribuido:
• Llamada de procedimientos remotos o RPC (Remote Procedure Call). Permite a
un programa cliente llamar a un procedimiento de otro programa en ejecución en un
proceso servidor.
1.4.2.- Programación distribuida..

Hay varios modelos de programación para la comunicación entre los procesos de un

sistema distribuido:
• Invocación remota de objetos. El modelo de POO ha sido extendido para permitir
que los objetos de diferentes procesos se comuniquen uno con otro por medio de una
invocación a un método remoto o RMI (Remote Method Invocation). Un objeto que
vive en un proceso puede invocar métodos de un objeto que reside en otro proceso.
1.4.2.- Programación distribuida..

VENTAJAS
• Se pueden compartir recursos y datos.
1.4.2.- Programación distribuida..

VENTAJAS
• Capacidad de crecimiento incremental.
1.4.2.- Programación distribuida..

VENTAJAS
• Flexibilidad.
1.4.2.- Programación distribuida..

VENTAJAS
• Alta disponibilidad.
1.4.2.- Programación distribuida..

VENTAJAS
• Soporte de aplicaciones inherentemente distribuidas.
1.4.2.- Programación distribuida..

VENTAJAS
• Carácter abierto y heterogéneo.
1.4.2.- Programación distribuida..

INCONVENIENTES
• Aumento de la complejidad.
1.4.2.- Programación distribuida..

INCONVENIENTES
• Problemas de las redes de comunicaciones.
1.4.2.- Programación distribuida..

INCONVENIENTES
• Problemas de seguridad como DDoS.
1.4.2.- Programación distribuida..

Ejercicio 1.12.-
Busca información sobre el proyecto BOINC.
 PROGRAMACIÓN CONCURRENTE, PARALELA Y DISTRIBUIDA

Programación Concurrente: Tenemos varios elementos de proceso (hilos, procesos) que

trabajan de forma conjunta en la resolución de un problema. Se suele llevar a cabo en un
único procesador o núcleo.

Programación Paralela: Es programación concurrente cuando se utiliza para acelerar la

resolución de los problemas, normalmente usando varios procesadores o núcleos.

Programación Distribuida: Es programación paralela cuando los sistemas están distribuidos

a través de una red. Se usa paso de mensajes.