SERVICIOS Y PROCESOS

1 Programación de
Procesos
DOCUMENTO1
 ÍNDICE

MOTIVACIÓN................................................................... 3
PROPÓSITOS .................................................................. 4
PREPARACIÓN PARA LA UNIDAD ....................................... 5
1. INTRODUCCIÓN ...................................................... 7
2. PROGRAMACIÓN CONCURRENTE ..................... 10
3. FUNCIONAMIENTO BÁSICO DEL SISTEMA
OPERATIVO ............................................................ 12
4. PROCESOS ............................................................ 14
4.1. ESTADOS DE UN PROCESO .................................................... 14
4.2. COLAS DE PROCESOS ........................................................... 15
4.3. PLANIFICACIÓN DE PROCESOS............................................... 16
4.4. CAMBIO DE CONTEXTO .......................................................... 17
5. GESTIÓN DE PROCESOS ..................................... 18
5.1. ÁRBOL DE PROCESOS............................................................... 18
5.2. OPERACIONES BÁSICAS CON PROCESOS ................................... 19
6. COMUNICACIÓN DE PROCESOS ......................... 23
7. SINCRONIZACIÓN DE PROCESOS ...................... 27
7.1. ESPERA DE PROCESOS (OPERACIÓN WAIT) ............................... 27
8. PROGRAMACIÓN MULTIPROCESO ..................... 29
8.1. CLASE PROCESS ..................................................................... 30
CONCLUSIONES ............................................................ 31

1
RECAPITULACIÓN .......................................................... 32
PROPUESTAS DE AMPLIACIÓN ........................................ 33
BIBLIOGRAFÍA................................................................ 35

2
 MOTIVACIÓN
A día de hoy, vivimos en un mundo en el que los dispositivos electrónicos, como
los ordenadores o teléfonos móviles, son capaces de realizar más de una tarea a
la vez. Veremos el funcionamiento de los sistemas operativos, que contienen
estos dispositivos y lo relativo a la ejecución de diferentes programas. También,
veremos el concepto de proceso, viéndolo como un programa en ejecución y
como gestiona uno o varios procesos a la vez el sistema operativo, lo que deno-
minaremos como concurrencia de procesos o multiprogramación.

3
 PROPÓSITOS
En esta unidad se trata de …

 Conocer el funcionamiento de los sistemas y de la ejecución de los pro-

gramas.

 Conocer el concepto de concurrencia y la facilitación del sistema a pro-

porcionar la multiprogramación y la multitarea al usuario.

 Entender la programación de procesos, sus principios y formas de apli-

cación.

4
 PREPARACIÓN PARA LA UNIDAD
Para estudiar esta unidad necesitas conocer:

 Programación básica orientada a objetos.

5
 1. INTRODUCCIÓN
Para poder entender la idea de la concurrencia o multiprogramación, es impres-
cindible adquirir ciertos conceptos.

 Programa: Toda la información (tanto datos como instrucciones) alma-

cenada en un disco duro que al ejecutarse realizan una sentencia

 Proceso: programa en ejecución. Englobando el código de éste y los da-

tos.

Esto incluye tres cosas:

 Un contador del programa: algo que indique por dónde se está

ejecutando.
 Una imagen de memoria: es espacio de memoria que el proceso
está utilizando.
 Estado del procesador: es el valor de los registros del procesa-
dor sobre los cuales se está ejecutando.

Es importante destacar que los procesos son entidades independientes, aunque

ejecuten el mismo programa. De tal forma, pueden coexistir dos procesos que
ejecuten el mismo programa, pero con diferentes datos (es decir, con distintas
imágenes de memoria) y en distintos momentos de su ejecución (con diferentes
contadores de programa).

 Ejecutable: un fichero ejecutable contiene la información necesa-

ria para crear un proceso a partir de los datos almacenados de
un programa. Es decir, llamaremos “ejecutable” al fichero que
permite poner el programa en ejecución como proceso.

7
  Sistema operativo: programa que hace de intermediario entre el
usuario y las aplicaciones que utiliza y el hardware del ordena-
dor. Entre sus objetivos, se pueden destacar:

Ejecutar los programas del usuario. Es el que tiene la la-

bor de crear los procesos a partir de los ficheros ejecuta-
bles de los programas y de enfocar su instanciación para
evitar problemas y mejorar el rendimiento del ordenador.

Hacer que el computador sea cómodo de usar. Hace de in-

terfaz entre el usuario y los recursos del ordenador, permi-
tiendo el acceso tanto a ficheros y memoria como a dispo-
sitivos hardware. Esta serie de abstracciones permiten al
programador acceder a los recursos hardware de forma
sencilla.

Para que un proceso se pueda ejecutar, ha de estar en memoria la información

que necesita, depende del tamaño de la memoria, es posible que se requiera
también del disco duro parte del espacio para el proceso.

Utilizar los recursos del computador de forma eficiente. Los recursos del
ordenador son compartidos tanto por los programas como por los diferen-
tes usuarios. El sistema operativo es el encargado de repartir los recursos
en función de sus políticas a aplicar.

8
 Figura 1. Sistema operativo como intermediario entre aplicaciones

 Demonio: proceso que está en ejecución y oculto a los procesos norma-

les en un segundo plano, además no es interactivo, es decir, es un pro-
ceso dominado por el S.O. en el que trabajemos sin que el usuario ten-
ga interacción con el mismo, suelen servir de base para otros procesos.

Si un usuario pulsa en el icono de una aplicación para instanciarlo la in-

terfaz gráfica es la que hace la solicitud para crear el correspondiente proceso.

Podemos mirar más información sobre este tema en internet ya que exis-
ten una gran cantidad de documentos.

9
 2. PROGRAMACIÓN
CONCURRENTE
La programación concurrente se identifica por el hecho de permitir simultá-
neamente varios procesos en ejecución, por consecuente permite hacer varias
tareas en el mismo tiempo unos claros ejemplos de esto es consumir multimedia
radio tv, Pensad en todo el tiempo que perderíamos si todas esas tareas se tu-
vieran que realizar una tras otra. Estas tareas se pueden iniciar:

Con un único núcleo o procesador del ordenador (multiprogramación). En este

caso, aunque para la persona le parezca que varios procesos se ejecutan al
mismo tiempo, si exclusivamente existe un único núcleo o procesador, solamen-
te a un proceso se le permite estar en un tiempo determinado activo o ejecután-
dose. Para poder conmutar en los distintos procesos, el sistema operativo se
encarga de conmutar el proceso en ejecución después de un período corto de
tiempo (tratándolo en milisegundos). Esto da pie a que en un segundo puedan
ejecutarse una cantidad considerable de procesos, camuflando al usuario esta
secuencia y haciéndole pensar que todos los programas se ejecutan en el mismo
tiempo.

Esta descripción se suele identificar con el nombre de programación concu-

rrente. La programación concurrente no mejora el tiempo de ejecución global de
los programas ya que se ejecutan intercambiando unos por otros en el procesa-
dor. Sin embargo, permite que varios programas parezca que se ejecuten al
mismo tiempo. Varios núcleos en un mismo procesador (multitarea). La existen-
cia de varios núcleos o cores en un ordenador es cada vez mayor, apareciendo
en Dual Cores, Quad Cores, en muchos de los modelos i3, i5 e i7, etc. Cada
núcleo podría estar ejecutando una instrucción diferente al mismo tiempo.

El sistema operativo, al igual que para un único procesador, se tiene que ocupar
de asignar las tareas que se ejecutan en cada núcleo y cambiar unos procesos
por otros habilitándose así la multitarea. En este caso todos los cores comparten

10
la misma memoria por lo que es posible utilizarlos de forma coordinada mediante
la llamada y conocida programación paralela.

La programación paralela mejora la eficiencia del programa si este se ejecuta de

forma paralela en diferentes núcleos ya que da paso a que se ejecuten varias
instrucciones simultáneamente. Cada instancia en un único core será una tarea
del mismo programa pudiendo cooperar entre sí. El concepto de “tarea” (o “hilo
de ejecución”) Y, por supuesto, se permite utilizar sin problemas de compatibili-
dad con la programación concurrente, dando paso a la vez a la llamada multi-
programación.

Teniendo varios ordenadores distribuidos en la red. Cada ordenador tendrá sus

propios atributos hardware. La manera de administrarlos y enlazarlos forma parte
de lo que se llama programación distribuida.

La programación distribuida facilita la utilización de varios dispositivos además

de los ordenadores de manera paralela, lo que facilita conseguir buenas mejoras
en el proceso de la inicialización de programas distribuidos.

Sin embargo, como cada ordenador mantiene atributos individuales (memoria

RAM, disco duro) dificulta a los procesos la comunicación compartiendo memo-
ria, teniendo que utilizar otros esquemas de comunicación más complejos y cos-
tosos a través de la red que los interconecte.

La programación distribuida es una de las más utilizadas actualmente en cual-

quier empresa.

http://pegasus.javeriana.edu.co/~scada/concurrencia.html
https://es.slideshare.net/percyjavier/programacion-concurrente-presentation
https://www.youtube.com/watch?v=zcGsAFATYP0

11
 3. FUNCIONAMIENTO BÁSICO
DEL SISTEMA OPERATIVO
El núcleo del ordenador que tiene la funcionalidad básica del S.O. se llama Ker-
nel. Es una parte software pequeña del sistema operativo, si la comparamos con
lo necesario para implementar su interfaz (y más hoy en día que es muy visual).
A todo lo demás del sistema se le denomina programas del sistema. El kernel
es el encargado de administrar los recursos de que disponga el ordenador, per-
mitiendo su uso a través de peticiones llamadas “peticiones al sistema”.

En general, el kernel o núcleo del sistema está activo mediante interrupciones.

Una interrupción es un parón momentáneo en la ejecución de un proceso, para
después ejecutar una función que aplique esta interrupción y suceda lo que se
haya programado anteriormente. Esta rutina será dependiente del sistema ope-
rativo. Es importante destacar que mientras se está atendiendo una interrupción,
se deshabilita la llegada de nuevas interrupciones. Cuando el algoritmo termina,
se habilita de nuevo el proceso en el mismo lugar en el que se inhibió.

Es decir, el sistema operativo no es un proceso demonio propiamente dicho que

proporcione funcionalidad al resto de procesos, sino que él solo se ejecuta res-
pondiendo a interrupciones. Cuando salta una interrupción se transfiere el con-
trol a la rutina de tratamiento de la interrupción. Así, las rutinas de tratamiento de
interrupción pueden ser vistas como el código propiamente dicho del kernel.

Las interfaces que proporciona el núcleo o kernel para que los programas crea-
dos por el usuario accedan al sistema son implementadas con el nombre de lla-
madas al sistema. Los errores de un programa podrían afectar a otros progra-
mas o al propio sistema operativo, por consecuente para asegurar la ejecución
de la forma óptima, el sistema incluye una interfaz de llamadas para evitar que
ciertas sentencias conflictivas sean por el usuario ejecutadas.

12
El modo dual es un atributo del hardware que da la función al sistema operativo
de protegerse. El procesador tiene dos formas de funcionamiento indicados en
un bit:

 usuario (1). Es el que permite ejecutar los programas diseñados por el

usuario.

 kernel (0), también llamado “supervisor” o “privilegiado”. En este estado

debemos estar para ejecutar las opciones con más riesgo y problemáti-
cas del procesador.

Una interrupción es producida cuando se da “Una llamada al sistema donde está

el programa de usuario “(en este caso denominada trap). La interfaz de llamadas
al sistema lanza la interrupción correspondiente que trata el sistema de la forma
adecuada.

Dentro de los procesos la operación créate es la que nos facilitara la ejecución

mediante start y Runtime.exec.

13
 4. PROCESOS
Como ya se ha explicado, el que se encarga de administrar procesos es el S.O.
a medida que se ejecuta un proceso, pasando por varios estados. Cuando un
proceso cambia su estado es debido también al S.O.

https://es.wikipedia.org/wiki/Proceso_(inform%C3%A1tica)

https://www.youtube.com/watch?v=GgDxlVbOmYI

4.1. ESTADOS DE UN PROCESO

Los estados en los que aparece un proceso son:

 Nuevo. El proceso está en fase de compilación y desarrollo.

 Listo: el proceso no ha sido iniciado, aunque está predispuesto. El sis-

tema operativo no le ha asignado todavía un procesador para ejecutar-
se. El planificador del sistema operativo es el responsable deseleccionar
que proceso está en ejecución, por lo que es el que indica cuando el
proceso pasa a ejecución.

 En ejecución: el proceso se está ejecutando. El sistema operativo utiliza

el mecanismo de interrupciones para controlar su ejecución. Si el proce-
so necesita un recurso, incluyendo la realización de operaciones de en-
trada/salida (E/S), llamará a la llamada del sistema correspondiente. Si
un proceso en ejecución se ejecuta durante el tiempo máximo permitido
por la política del sistema, salta un temporizador que lanza una interrup-
ción. En este último caso, si el sistema es de tiempo compartido, lo para
y lo pasa al estado Listo, seleccionando otro proceso para que continúe
su ejecución.

14
  Bloqueado: el proceso está bloqueado esperando que ocurra algún su-
ceso (esperando por una operación de E/S, bloqueado para sincronizar-
se con otros procesos, etc.). Cuando ocurre el evento que lo desblo-
quea, el proceso no pasa directamente a ejecución, sino que tiene que
ser planificado de nuevo por el sistema.

 Terminado: el proceso ha terminado su cometido por consiguiente libera

de la memoria su imagen. Para terminar un proceso, el mismo debe
llamar al sistema para indicárselo o puede ser el propio sistema el que
finalice el proceso mediante una excepción (una interrupción especial).

Algunos procesos pueden pasar por más estados, pero los más comunes y es-
tandarizados son los explicados anteriormente.

4.2. COLAS DE PROCESOS

la multiprogramación es lo que persigue el sistema operativo, esto significa mejor
optimización al tratar varios procesos de forma simultánea en memoria para ex-
primir al máximo el procesador del ordenador. Esto funciona así:
los procesos se irán intercambiando el uso del procesador para su ejecución de
forma concurrente. Para ello, el sistema operativo organiza los procesos en va-
rias colas intercalándolos de unas colas a otras:
 Una cola de procesos que almacena todos los procesos del sistema.
 Una cola de procesos pendientes de ejecución.
 Varias colas de dispositivo que almacenan los procesos que inactivos y
esperando alguna operación de E/S.
Supongamos que varios procesos (1, 2, 3, 4 y 5) se están ejecutando concurren-
temente en un ordenador. El proceso 1 se está ejecutando cuando realiza una
petición de E/S al disco. En ese momento, el proceso 2 pasa a ejecución, ha-
ciendo otra operación de E/S, en este caso por la tarjeta de red. El proceso 3
pasa a ejecutarse.

15
En ese momento, las colas de procesos serán las siguientes:

En ejecución P3

Preparados P5 P4

E/S Disco P1

E/S Red P2

(En ese momento supongamos que el proceso 3 realiza una petición de E/S te-
niendo que esperar por el disco duro. Dibuja el estado de las colas correspon-
dientes e identifica cuál sería el proceso que se ejecutará utilizando la filosofía
FIFO para sacar los procesos de las colas.

4.3. PLANIFICACIÓN DE PROCESOS

Si necesitamos administrar colas de procesos, basta con aplicar un planificador
de procesos. El planificador es el encargado de seleccionar los movimientos de
procesos entre las diferentes colas. A continuación, dos tipos de planificaciones:

 A corto plazo: elije un proceso de la cola de procesos preparados para

que pase a iniciados. Se invoca muy frecuentemente (en tiempos de mi-
lisegundos, cuando sucede algún cambio en el estado del proceso) por
lo que tiene que ser bastante veloz en la decisión. Esto implica codifica-
ción rápida y precisa:
– Planificación cooperativa. Si el proceso se bloquea o termina es-
te es cambiado por otro.

– Planificación apropiativa.
Se sucede cuando un proceso con más prioridad que el actual to-
ma la ejecución del proceso con más prioridad esto sucede por un
desbloqueo del propio proceso antes bloqueado o la instanciación
de uno nuevo.

– Tiempo compartido: ocurre aleatoriamente, pues pasado un

tiempo un proceso es relevado por otro distinto, es decir, mantie-
nen un nivel de prioridad equitativo.

16
  Largo plazo: escoge que procesos han de ser incluidos en la cola de
procesos en estado preparado, se ejecuta una vez cada bastante tiem-
po, dando a más tiempo a la hora de seleccionar que procesos deben
ser incluidos.

Un proceso de otro son entidades absolutamente independientes, aunque

ambos estén corriendo el mismo programa son ajenos entre sí.

4.4. CAMBIO DE CONTEXTO

Al momento de cambiar la ejecución de un proceso por otro proceso suceso que
se repite con frecuencia, el sistema debe retener el contexto del proceso actual y
consiguientemente restaurar el elegido para sustituirle, el momento de guardar el
contexto es efectuado cuando suceden las interrupciones.
Es identificado como contexto a:

 Estado del proceso.

 Estado del procesador: valores de los registros del procesador.
 Información de uso de memoria: reserva de memoria para el proceso.

El cambio de contexto se conoce como tiempo que se ha perdido puesto que el

procesador pierde ese tiempo que puede invertir en cosas de utilidad. Únicamen-
te el tiempo que permanece en el cambio de contexto está determinado por có-
mo está diseñado la arquitectura del procesador.

17
 5. GESTIÓN DE PROCESOS
5.1. ÁRBOL DE PROCESOS
El sistema operativo que se encarga de administrar e iniciar los instanciados
procesos siguiendo las indicaciones del usuario. Así, cuando un usuario quiere
abrir un programa, el sistema operativo es el responsable de crear y poner en
ejecución el proceso correspondiente que lo ejecutara. Aunque el responsable
del proceso de creación es el sistema operativo, ya que es el único que puede
acceder a los recursos del ordenador, el nuevo proceso se crea siempre por pe-
tición de otro proceso. La puesta en ejecución de un nuevo proceso se produce
debido a que hay un proceso en concreto que está pidiendo su creación en su
nombre o en nombre del usuario.
En este sentido, cualquier proceso en ejecución mantiene una relación con el
proceso que lo creo, estableciéndose una relación entre los procesos. A su vez,
el nuevo proceso le es permitido crear nuevos procesos, con lo que da resultado
a un árbol de procesos. Cuando se arranca el ordenador, y se carga e memoria
el kernel del sistema a partir de su imagen en disco se crea el proceso inicial del
sistema. A partir de este proceso, se crea el resto de procesos de forma jerárqui-
ca, estableciendo padres, hijos, abuelos, etc.

Una manera inequívoca de identificar un proceso de otros, los sistemas operati-

vos, agregan un campo PID como identificador del proceso. La utilización del
PID es básica a la hora de gestionar procesos, ya que es la forma que tiene el
sistema de referirse a los procesos que gestiona.

18
Ejemplo de algunos procesos y sus identificadores,

PID Process Name

0 Kernel_task

1 Launchd

113 Mds

158 Windowserver

138 Coreservicesd

48054 Diskimages-helper

115 Loginwindow

45649 Fseventsd

301 Coreaudiod

55644 Cupsd

15 Configd

49045 eapolclient

Se pueden ver con más profundidad los arboles de procesos en el siguien-

te enlace. http://sopa.dis.ulpgc.es/ii-
dso/lecminix/introduc/cap4/lec4_2.htm

5.2. OPERACIONES BÁSICAS CON

PROCESOS
Siguiendo el vínculo entre procesos establecido en el árbol de procesos, el pro-
ceso que crea se le identifica con el nombre de padre y el proceso que ha sido
creado como hijo. A su vez, los hijos pueden crear nuevos hijos. A la operación
de creación de un nuevo proceso la denominaremos create.

19
Cuando se crea un nuevo proceso tenemos que saber que padre e hijo se ejecu-
tan concurrentemente. Ambos procesos comparten la CPU y se irán intercam-
biando siguiendo la política de planificación del sistema operativo para propor-
cionar multiprogramación. Si el proceso padre necesita esperar hasta que el hijo
termine su ejecución para poder continuar la suya con los resultados obtenidos
por el hijo, puede hacerlo mediante la operación wait.

Como se ha visto al inicio del capítulo, los procesos son independientes y tienen
su propio espacio de memoria asignado, llamado imagen de memoria. Hijos y
Padres ambos dos son procesos, aunque compartan un vínculo, conservan esta
particularidad.

Ambos procesos utilizan espacios en memoria independientes entre sí. En gene-

ral, parece que el hijo ejecuta un programa diferente al padre, pero en algunos
sistemas operativos esto no tiene por qué ser así. Por ejemplo, mientras que en
sistemas tipo Windows existe una función createProcess() que crea un nuevo
proceso a partir de un programa distinto al que está en ejecución, en sistemas
tipo UNIX, la operación a utilizar es fork(), que crea un proceso hijo con un dupli-
cado del espacio de direcciones del padre, es decir, un duplicado del programa
que se ejecuta desde la misma posición. Sin embargo, en ambos casos, los pa-
dres e hijos (aunque sean un duplicado en el momento de la creación en siste-
mas tipos UNIX) son independientes y las modificaciones que uno haga en su
espacio de memoria, como escritura de variables, no afectarán al otro.

Como padre e hijo tienen espacios de memoria independientes, pueden compar-

tir recursos para intercambiarse información. Estos recursos pueden ir desde
ficheros abiertos hasta ubicaciones compartidas en memoria. La memoria com-
partida está abierta al tratamiento de varios procesos para compartir información
siendo esta una zona de memoria. Los procesos se comunican escribiendo y
leyendo datos en dicha región. El sistema operativo solamente interviene a la
hora de crear y establecer los permisos de qué procesos pueden acceder a di-
cha zona. Los procesos son los responsables del formato de los datos comparti-
dos y de su ubicación.

Al terminar el uso de un proceso, es vital advertir al S.O. de que ha sido acabado

para liberar los recursos que hubieran sido asignados a ese proceso. En general,
es el propio proceso el que le indica al sistema operativo mediante una opera-
ción denominada exit que quiere terminar, pudiendo aprovechar para mandar
información respecto a su finalización al proceso padre en ese momento.

El proceso hijo tiene dependencia tanto del proceso padre como del sistema
operativo. Por consecuente el padre es quien decide cuando finaliza la ejecución
de su proceso hijo. Entre estos motivos podría darse que el hijo excediera el uso
de algunos recursos o que la funcionalidad asignada al hijo ya no sea necesaria
por algún motivo.

20
Para ello puede utilizar la operación destroy. Esta relación de dependencia entre
padre e hijo, lleva a casos como que, si el padre termina, en algunos sistemas
operativos no se permita que sus hijos continúen la ejecución, produciéndose lo
que se denomina “terminación en cascada”.

En definitiva, cada sistema operativo tiene unas características únicas, y la ges-

tión de los procesos es diferente en cada uno de ellos. Por simplificación y por-
tabilidad, evitando así depender del sistema operativo sobre el cual se esté eje-
cutando hemos decidido explicar la gestión de procesos para la máquina virtual
de Java (Java Virtual Machine [JVM]). JVM es un entorno de ejecución ligero y
gratuito multiplataforma que permite la ejecución de binarios o bytecode del len-
guaje de programación Java sobre cualquier sistema operativo, salvando las
diferencias entre ellos. La idea que hay detrás de ello se conoce como Write On-
ce, Run Anywhere (“escribe una vez y ejecuta en cualquier lugar”, entendiendo
“cualquier lugar” como plataforma o sistema operativo). Las próximas secciones
del capítulo estarán basadas por tanto en la utilización de Java.

Es conveniente saber que a cada programa se le asigna un proceso pero a

su vez ese programa puede tener varios procesos para ejecutarlo y
permanecer en memoria.

Creación de procesos (operación créate)

La clase que representa un proceso en Java es la clase Process. Los mé-

todos de Runtime() y PB.start().
exec() crean un proceso nativo en el S.O. subyacente donde ha sido ini-
ciado la JVM y retorna un objeto Java de la siguiente clase “Process” que
puede tiene la particularidad de poder tratar dicho proceso.
 Process ProcessBuilder.start(): instancia un proceso creado utili-
zando los atributos inherentes al objeto. Este proceso ejecuta el
método command(), ocurriendo en el directorio especificado por di-
rectory(), haciendo uso de las variables de entono enenvironment().
 Process Runtime.exec(String[] array, String[] entorno, File ruta): ins-
tancia la sentencia especificada y parámetros en array en un proce-
so hijo independiente con el entorno y el directorio en ruta.
Ambos métodos comprueban que el comando a ejecutar es un comando o
ejecutable válido en el sistema operativo subyacente sobre el que ejecuta
la JVM. El ejecutable se ha podido obtener mediante la compilación de có-
digo en cualquier lenguaje de programación. Al final, crear un nuevo pro-
ceso depende del sistema operativo en concreto que esté ejecutando por
debajo de la JVM. En este sentido, pueden ocurrir múltiples problemas,
como:
a) No encuentra el ejecutable debido a la ruta indicada.

21
 b) No tener permisos de ejecución.
c) No ser un ejecutable válido en el sistema.
En la mayoría de los casos, se lanza una excepción dependiente del sis-
tema en concreto, pero siempre será una subclase de IOException.
Terminación de los procesos (destroy)
Un proceso puede finalizar a un proceso hijo en cualquier momento. Para
ello el padre tiene como recurso la sentencia “destroy”. Dicha sentencia bo-
rra el proceso hijo, liberando sus recursos en el sistema operativo subya-
cente. En caso de Java, los recursos correspondientes los eliminará el
garbage collector cuando considere.
Si no se fuerza la finalización de la ejecución del proceso hijo de forma
anómala, el proceso hijo realizará su ejecución completa terminando y libe-
rando sus recursos al finalizar. Esto se produce cuando el hijo realiza la
operación exit para finalizar su ejecución.

22
 6. COMUNICACIÓN DE
PROCESOS
Como ya sabemos, un proceso es un programa en ejecución y por lo tanto, cap-
tura información, la modifica y fabrica resultados. Esto es manipulado a través
de:

Si queremos manejarnos con los procesos además del lenguaje java con-
viene aprender el lenguaje de programación c puesto que está más cer-
cano al sistema operativo y sus procesos.

La entrada estándar (stdin): de donde se vale el proceso para leer información.

Con entrada estándar se entiende el teclado, también sería posible transmitirlos
de un fichero, del dispositivo de red o de algún proceso. La lectura de datos a lo
largo de un programa (por ejemplo, mediante scanf en C) leerá los datos de su
entrada estándar.

La salida estándar (stdout): en donde el proceso guarda los datos que adquie-
re y está preparado a mostrar. Habitualmente la pantalla del ordenador, aun
siendo válidos la impresora u otro proceso que necesite, esos datos, como en-
trada estándar. La escritura de los datos que se realice en un programa (por
ejemplo, mediante printf en C o System.out.println en Java) se produce por la
salida estándar.

La salida de error (stderr): ubicación y destino de los mensajes de errores de

un proceso. Normalmente comparte la pantalla de la salida estándar, también
por ejemplo un fichero de texto para poder consultar los errores de un modo más
pausado.

La utilización de System.out y System.err en Java se puede ver como un ejemplo

de utilización de estas salidas.

En casi cualquier S.O. las entradas y salidas en un proceso son una copia idénti-

23
ca de las entradas y salidas de las que dispone el proceso padre. Es decir, un
proceso padre que lee de un fichero y escribe en fichero, el proceso hijo escribirá
y leerá de fichero, teniendo en cuenta el lenguaje Java no da atributos al proceso
hijo, con lo cual no es posible directamente la comunicación con él, pero sí que
se pueden ver maneras de comunicaciones con los distintos flujos del hijo hacia
el padre.

Todas sus salidas y entradas de información (stdin, stdout y stderr) se redirigen

al proceso padre a través de los siguientes flujos de datos o streams:

OutputStream: flujo de salida perteneciente al hijo. El stream está enlazado me-

diante pipe (tubería) a la entrada (stdin) del proceso hijo.

InputStream: flujo de entrada perteneciente al hijo. El stream está enlazado me-

diante pipe (tubería) a la salida (stdout) del proceso hijo.

ErrorStream: flujo de error perteneciente al hijo. El stream está enlazado median-

te pipe (tubería) a la salida (stderr) del proceso hijo. Sin embargo, hay que saber
que, por defecto, para la máquina virtual de JAVA, stderr está enlazado al mismo
sitio que stdout.

Para hacerlo más simple y fácil de distinguir se puede verlos por separado, exis-
te el método redirectErrorStream(boolean), para este propósito, perteneciente a
la clase ProcessBuilder. Si se pasa un valor true como parámetro, los flujos de
datos correspondientes a stderr y stdout en la máquina virtual de JAVA, serán
distintos y cada uno representara su propia salida estándar.

Mediante dichos streams, el padre puede intercambiar datos al hijo para que
este le envíe mensajes de errores en caso de haberlos.

Es conveniente saber que tenemos limitaciones con respecto a que sistema ope-
rativo estemos usando, la capacidad de los buffers de entrada y salida puede
verse con ciertas limitaciones. Por lo tanto, si sucede un error al escribir o leer en
los flujos del hijo puede provocar que el proceso hijo se bloquee. Por eso, en
Java se la comunicación entre padre e hijo se da a través de un buffer utilizando
los streams anteriores.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;

public class ComunicationBetweenProcess {

public static void main(String args[]) throws IOException {
Process process = new ProcessBuilder(args).start();
InputStream is = process.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
String line;
System.out.println("Salida del proceso " + Arrays.toString(args) +

24
":");
while ((line = br.readLine()) != null) {
System.out.println(line);
}
}
}

Posiblemente te cueste un poco interpretar los códigos, no te desesperes,

en los siguientes temas te serán mucho más familiares.

Por último, hay que tener en cuenta cómo se está codificando la información que
se envía y se recibe entre los diferentes procesos. La codificación de la informa-
ción depende del sistema operativo subyacente donde se está ejecutando el
proceso hijo.

GNU Linux, Mac OS, Android, UNIX, iOS, etc. utilizan el formato de codificación
de caracteres UTF-8, que utiliza por debajo el estándar Unicode. Unicode es un
estándar de codificación de caracteres diseñado para facilitar el tratamiento in-
formático, transmisión y visualización de textos de múltiples lenguajes y discipli-
nas técnicas. El término “Unicode” proviene de los tres objetivos perseguidos:
universalidad, uniformidad y unicidad.

Sin embargo, diferentes versiones de Microsoft Windows no utilizan UTF-8, sino

sus propios formatos de codificación no compatibles con el resto, como Win-
dows-Western.

Un proceso puede esperar recibir por su entrada estándar los datos con los que
operar en un formato específico. Por ejemplo, si el proceso se crea a partir de un
ejecutable en Unix, la comunicación de datos con el mismo debería producirse
en UTF-8. Si los datos de entrada no contienen caracteres extraños (saltos de
línea, tildes, ñ, etc.), esto no suele ser necesario, pero aun así veremos cómo
puede hacerse.

//Importamos todos los paquetes necesarios.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
public class UnixInteractor {
public static void main(String[] command) {
String line;
//Preparamos el comando a ejecutar
ProcessBuilder pb = new ProcessBuilder(command);
pb.redirectErrorStream(true);
try {
//Se crea el Nuevo proceso hijo
Process shell = pb.start();

25
//Se obtiene stdout del proceso hijo
InputStream is = shell.getInputStream();
//Se convierte el formato de UTF-8 al de un String de Java
BufferedReader br = new BufferedReader (new
InputStreamReader(is,”UTF-8”));
System.out.println(“La salida del proceso
hijo” + Arrays.toString(command) + “:” );
//Se muestra la salida del hijo por pantalla
while ((line = br.readLine()) != null) {
System.out.println(line);
}
//Cuando finaliza se cierra el descriptor
//de salida del hijo
is.close();
} catch (IOException e) {
System.out.println(“Error ocurrió ejecutando el comando.
Descripción:” + e.getMessage());
}
}
}

Modifica el ejemplo visto para que la comunicación se realice de forma efectiva

con un ejecutable de Microsoft Windows. Justifica cualquier cambio realizado
incluyendo los paquetes a utilizar.
Además de la posibilidad de comunicarse mediante flujos de datos, existen otras
alternativas para la comunicación de procesos:
Usando sockets para la comunicación entre procesos.

Utilizando JNI (Java Native Interface). La utilización de Java permite abstraerse

del comportamiento final de los procesos en los diferentes sistemas operativos.
Sin embargo, al ser un lenguaje de alto nivel oculta funcionalidad de procesos de
bajo nivel que puede depender del sistema subyacente. Por ejemplo, un pipe es
un canal de comunicación unidireccional de bajo nivel que permite comunicarse
a los procesos de forma sencilla.

La comunicación de procesos en Java solo se puede hacer mediante los streams

explicados, perdiendo parte de la funcionalidad ofertada por los pipes de bajo
nivel. Sin embargo, se puede utilizar JNI para acceder desde Java a aplicaciones
desarrolladas en otros lenguajes de programación de más bajo nivel, como C,
que pueden sacar partido al sistema operativo subyacente.

La mayoría de los sistemas operativos actuales están desarrollados en C. C es

un lenguaje de bajo nivel cercano a la arquitectura que obtiene un elevado ren-
dimiento. Al ser más cercano a la arquitectura del sistema, permite comunicar
diferentes procesos utilizando métodos más cercanos al sistema operativo.

https://www.youtube.com/watch?v=qmCi67TlBWQ

https://es.wikipedia.org/w iki/Comunicaci%C3%B3n_entre_procesos

26
 7. SINCRONIZACIÓN DE
PROCESOS

Los métodos de comunicación pueden ser considerados como métodos de sin-

cronización puesto que facilita al padre llevar una sincronización con el recibo y
envió de mensajes. Concretamente, los envíos y recepciones por los flujos de
datos permiten a un proceso hijo comunicarse con su padre a través de un canal
de comunicación unidireccional bloqueante.

Aunque el programa este codificado de una cierta manera depende el pro-

ceso que contenga la parte del código ejecutado puede que se muestre
esa línea de una forma no esperada.

7.1. ESPERA DE PROCESOS (OPERACIÓN

WAIT)
Además de la utilización de los flujos de datos se puede esperar por la finaliza-
ción del proceso hijo y obtener su información de finalización mediante la opera-
ción wait(). Esta instrucción mantiene al padre bloqueado esperando un resulta-
do esperado del proceso hijo o que finaliza su ejecución mediante exit(). A conti-
nuación, se recibe un valor como acuse de haber sido terminado el proceso hijo.
Dicho valor de retorno viene dado mediante un entero. El valor significa que fue
lo que sucedió finalmente. No tiene nada que ver con los mensajes que se pasan
padre e hijo a través de los streams. Por convención se utiliza 0 en caso de que
no haya habido ningún problema.
Usando waitFor() de Process el padre se mantiene en espera hasta que el hijo
termine, volviendo inmediatamente si el hijo ha finalizado con anterioridad o si
alguien le interrumpe (en este caso se lanza la interrupción

27
InterruptedException). Además se puede solicitar el método exitValue() para re-
cuperar el dato de como finalizo el hijo. El proceso hijo debería haberse termina-
do en otro caso, saltaría la excepción IllegalThreadStateException

import java.io.IOException;
import java.util.Arrays;

public class ProcessSincronization {

public static void main(String[] args) throws IOException,
InterruptedException {
try {
Process process = new ProcessBuilder(args).start();
int retorno = process.waitFor();
System.out.println("Comando " + Arrays.toString(args) +
"devolvió:"
+ retorno);
} catch (IOException e) {
System.out
.println("Error ocurrió ejecutando el coman-
do. Descripción: "
+ e.getMessage());
} catch (InterruptedException e) {
System.out
.println("El comando fue interrumpido Des-
cripción del error: "
+ e.getMessage());
}
}
}

Esto es muy parecido a como se haría en otros lenguajes de programa-

ción, solo hay que usar la misma lógica y otra sintaxis.]]

https://www.youtube.com/watch?v=cdr-C_rnVFE

28
 8. PROGRAMACIÓN
MULTIPROCESO
La programación concurrente es una forma eficaz de procesar la información al
permitir que diferentes sucesos o procesos se vayan alternando en la CPU para
proporcionar multiprogramación. La multiprogramación puede producirse entre
procesos totalmente independientes, como podrían ser los correspondientes al
procesador de textos, navegador, reproductor de música, etc., o entre procesos
que pueden cooperar entre sí para realizar una tarea común.

El sistema operativo se encarga de proporcionar multiprogramación entre todos

los procesos del sistema, ocultando esta complejidad tanto a los usuarios como
a los desarrolladores. Sin embargo, si se pretende realizar procesos que coope-
ren entre sí, debe ser el propio desarrollador quien lo implemente utilizando la
comunicación y sincronización de procesos vistas hasta ahora.

A la hora de realizar un programa multiproceso cooperativo, se deben seguir las

siguientes fases:

 Descomposición funcional. Es necesario identificar previamente las

diferentes funciones que debe realizar la aplicación y las relaciones
existentes entre ellas.

 Partición. Distribución de las diferentes funciones en procesos estable-

ciendo el esquema de comunicación entre los mismos. Al ser procesos
cooperativos necesitarán información unos de otros por lo que deben
comunicarse. Hay que tener en cuenta que la comunicación entre pro-
cesos requiere una pérdida de tiempo tanto de comunicación como de
sincronización. Por tanto, el objetivo debe ser maximizar la independen-
cia entre los procesos minimizando la comunicación entre los mismos.

29
  Implementación. Una vez realizada la descomposición y la partición se
realiza la implementación utilizando las herramientas disponibles por la
plataforma a utilizar. En este caso, Java permite únicamente métodos
sencillos de comunicación y sincronización de procesos para realizar la
cooperación.

Si no se siguen estas fases es posible que el programa no sea del todo efi-
ciente en un futuro.
https://www.youtube.com/watch?v=z56J_fMjO3I

8.1. CLASE PROCESS

A la hora de realizar un algoritmo multiproceso en Java se utiliza la clase Pro-

cess. Se presenta por simplicidad una tabla con los métodos recogidos más im-
portantes explicados a lo largo del capítulo:
Método Ti

Método Tipo de retorno Descripción

getOutputStream() OutputStream Obtiene el flujo de salida del proceso
hijo conectado al stdin
getInputStream() InputStream Obtiene el flujo de entrada del proceso
hijo conectado al stdout del proceso
hijo
getErrorStream() InputStream Obtiene el flujo de entrada del proceso
hijo conectado al stderr del proceso
hijo

destroy() Void Implementa la operación destroy

waitFor() Int Implementa la operación wait
exitValue() int Obtiene el valor de retorno del proce-
so hijo

Descripción

30
 CONCLUSIONES
Hemos visto que es un proceso y las distintas formas de estudio de procesos ya
sea mediante sus estados cuando son ejecutados, las distintas formas de ejecu-
tarlo y crearlo también a identificar en el administrador de tareas cual es cada
proceso mediante su PID

31
 RECAPITULACIÓN
En esta unidad se ha tratado:
 El concepto de procesos
 Gestión de procesos
 Comunicación de procesos
 Operaciones básicas con procesos

32
 PROPUESTAS DE AMPLIACIÓN
 http://es.slideshare.net/anuskaeg/programacin-de-servicios-y-procesos-
27324747
 https://es.wikipedia.org/wiki/Comunicaci%C3%B3n_entre_proceso

33
 BIBLIOGRAFÍA
 Eugenia Perez Martinez. (2015) Programación de servicios y procesos.
Propuestas de formación. Formación profesional para el Empleo.
Eduforma.
 Alicia Ramos martin, Mª Jesus Ramos Martín.(2013). Programación de
servicios y procesos.

Nombre. Autor. (año). Nombre libro. Editorial.

35