2

PROCESOS DEL SISTEMA

MÓDULO PROFESIONAL:
ADMINISTRACIÓN DE SISTEMAS OPERATIVOS
Índice

RESUMEN INTRODUCTORIO.......................................................................................................... 3
INTRODUCCIÓN ............................................................................................................................. 3
CASO INTRODUCTORIO ................................................................................................................. 4
1. PROCESOS.................................................................................................................................. 4
1.1 Tipos de procesos ................................................................................................................ 6
1.2 Características propias de los procesos .............................................................................. 8
1.3 Estados de los procesos .................................................................................................... 10
1.3.1 Transiciones entre los procesos ................................................................................. 12
1.3.2 Estructura de los procesos ......................................................................................... 13
1.3.3 Tabla de procesos....................................................................................................... 13
1.4 Prioridades ........................................................................................................................ 14
1.5 Jerarquía entre procesos ................................................................................................... 15
2. PROCESOS HABITUALES DEL SISTEMA .................................................................................... 19
2.1 Funciones de los procesos habituales ............................................................................... 20
2.2 Medidas de seguridad ante la aparición de procesos no identificados ............................ 21
3. GESTIÓN DE LOS PROCESOS EN SISTEMAS OPERATIVOS LIBRES ............................................ 23
3.1 Línea de orden................................................................................................................... 23
3.2 Entorno gráfico .................................................................................................................. 25
4. GESTIÓN DE LOS PROCESOS EN SISTEMAS OPERATIVOS PROPIETARIOS ............................... 30
4.1 Línea de orden................................................................................................................... 31
4.2 Entorno gráfico .................................................................................................................. 31
5. SECUENCIA DE ARRANQUE DEL SISTEMA EN SISTEMAS OPERATIVOS LIBRES Y PROPIETARIOS
..................................................................................................................................................... 35
5.1 Secuencia de arranque del sistema................................................................................... 36
5.2 Demonios .......................................................................................................................... 38
5.3 Servicios............................................................................................................................. 40
6. ALGORITMO DE PLANIFICACIÓN ............................................................................................. 41
6.1.Políticas de planificación Linux ......................................................................................... 43
6.2 El algoritmo de planificación en Linux............................................................................... 44
7. SINCRONIZACIÓN Y COMUNICACIÓN ENTRE PROCESOS ........................................................ 45
7.1 Esquema de sincronización síncrona ................................................................................ 46
7.2 Sección crítica .................................................................................................................... 47
7.3 Exclusión mutua ................................................................................................................ 49
7.4 Modelo de sincronización por semáforos ......................................................................... 50
RESUMEN FINAL .......................................................................................................................... 54

2
RESUMEN INTRODUCTORIO

En la presente unidad, conoceremos los diferentes procesos del sistema, tanto en sistemas
operativos libres como propietarios. Profundizaremos en los tipos y sus estructuras, así como
las prioridades de los procesos, sus jerarquías y funciones. También conoceremos más en
profundidad aspectos como los algoritmos de planificación, las secuencias de arranques en
sistemas operativos libres y propietarios, y cómo se comunican y sincronizan los procesos.

INTRODUCCIÓN

La administración de los procesos es más que iniciar programas o detenerlos, y hay que tener
un buen conocimiento sobre cómo funcionan los sistemas operativos al nivel de los procesos,
la información que se recoge, los estados que puede adoptar y cómo cambia entre ellos.

Un proceso es un programa o tarea en ejecución al cual el sistema operativo asigna recursos,

controlando su ejecución. Los procesos están formados por órdenes que se cargan en memoria
para su ejecución y, al ser almacenados en la memoria del ordenador, se crea una estructura
de datos que identificará a cada proceso, permitiendo controlar todos los aspectos de su
ejecución.

Al ejecutar varios procesos a la vez, los sistemas operativos exigen llevar a cabo
multiprogramación, lo que permite la concurrencia de procesos (más de un proceso siendo
ejecutado a la vez), teniendo procesos en primer plano y otros en segundo plano y viceversa.

3
CASO INTRODUCTORIO

Trabajas como administrador de sistemas informáticos en una empresa de instalación de

cocinas, y te han facilitado un ordenador para poder trabajar desde casa. Sin embargo, el
ordenador va demasiado lento, y trabajar con él se hace imposible.

Una vez finalizado el módulo, serás capaz de gestionar los procesos del sistema de manera
adecuada, tanto en sistemas operativos libres como propietarios.

1. PROCESOS

Trabajas como administrador de los sistemas operativos de una empresa de instalación de

cocinas. Tu ordenador corre con un sistema operativo Ubuntu Linux, y quieres que sea lo más
eficiente posible para desempeñar unas tareas concretas. Para ello, sabes cómo cambiar las
prioridades de los procesos para que el ordenador de más recursos a los procesos más críticos.

Un proceso es un programa en ejecución, una sucesión de instrucciones con el objetivo de

llegar a un estado final, o de realizar una tarea concreta. El sistema operativo es el software
básico de un ordenador, con el que los usuarios son capaces de interactuar gracias a una
interfaz gráfica o el terminal de comandos y transmitirle órdenes. El sistema operativo
ejecutará dichas ordenes mediante procesos.

RECUERDA

Un proceso es un programa en ejecución.

El sistema operativo es una parte más de un sistema de computación, que podríamos dividir
en cuatro componentes principales:

1. El hardware, la memoria y los dispositivos de entrada y salida proporcionan los

recursos de computación básicos
2. El sistema operativo gestiona los recursos del sistema, ejecuta los servicios para las
aplicaciones, así como las ordenes de los usuarios.
3. Los programas de aplicación definen la forma en la que los recursos serán empleados
para resolver los problemas de computación de los usuarios.
4. Los usuarios, que hacen uso de los recursos del sistema informático para realizar
tareas y resolver problemas.

4
 División de un sistema de computación
Fuente: Elaboración propia

Por lo tanto, un proceso no es más que un programa en ejecución, y por ello pueden llegar a
confundirse ambos términos. Un proceso incluye también los datos, la pila, el contador de
programa y los valores almacenados en los registros, además del programa en sí (la secuencia
de código ejecutable).

Por su parte, un programa no refleja su estado de ejecución, lo que resulta fundamental a

efectos de continuar su procesamiento futuro si en un determinado momento se le retira el
control del procesador, lo que constituye la base de la multiprogramación.

Los hilos de ejecución (threads) se distinguen de los procesos tradicionales en que los
procesos son generalmente independientes, llevan mucha información de estados e
interactúan únicamente a través de mecanismos de comunicación dados por el propio sistema.

Muchos hilos de ejecución, por lo general, comparten otros recursos directamente. En muchos
de los sistemas operativos que proveen de facilidades para los hilos de ejecución, resulta más
rápido cambiar de un hilo a otro dentro del mismo proceso, que cambiar de un proceso a otro.
Esto se debe a que los hilos de ejecución comparten datos y espacios de direcciones, mientras
que los procesos, al ser independientes, no lo hacen.

5
 ¿SABÍAS QUE…?

Para guardar la información de los procesos se utiliza la tabla de procesos, que son unas estructuras
donde cada una de ellas contiene los datos que definen el estado de un proceso determinado. Las
informaciones de un proceso se actualizan en numerosos momentos, al menos cada vez que se le va
a quitar el uso del procesador.

Los campos que componen cada entrada en la tabla de procesos varían de un sistema
operativo a otro, y generalmente son numerosos. Resulta típicos algunos como:

• Estado del proceso.

• Área de memoria empleada.
• Identificador.
• Contador de programa.
• Valores de los registros.
• Tabla de ficheros abiertos.
• Directorio actual.

Todo proceso presente en un sistema operativo se identifica por un número entero, conocido
como identificador de proceso (PID).

1.1 Tipos de procesos

Podemos dividir los procesos en dos grandes grupos:

• Los procesos que se ejecutan en modo usuario.

• Los procesos que se ejecutan en modo núcleo (kernel).

Un proceso ejecutándose en modo usuario sólo podrá acceder a unas partes de su propio
espacio de direcciones, como el código, los datos y pila. No obstante, no podrá acceder a otras
partes de su propio espacio de direcciones, como las reservadas para estructuras de datos
asociadas al proceso usadas por el núcleo (kernel). De igual modo, tampoco podrá acceder al
espacio de direcciones de otros procesos o del mismo núcleo.

Por otra parte, un proceso que se ejecuta en modo núcleo podrá acceder a su propio espacio
de direcciones, así como al espacio de direcciones del núcleo, no así al espacio de direcciones
de otros procesos. No obstante, también podemos dividir los procesos entre aquellos que se
ejecutan en primer plano y los que se ejecutan en segundo plano.

6
Cuando un proceso se ejecuta en primer plano es porque el usuario está interactuando
directamente con él, mientras que, si el proceso se ejecuta en segundo plano, éste sigue activo
aun cuando el usuario no esté actuando directamente con el proceso.

EJEMPLO PRÁCTICO

En tu trabajo como administrador de sistemas informáticos en la empresa de instalación de cocinas,

quieres conocer los identificadores de procesos (PID) en uno de los ordenadores. El sistema
operativo del ordenador es Windows.

Para ver el PID de los procesos en Windows, lo primero que haces es acceder al administrador de
tareas. Pulsamos CTLR + ALT + SUPR y hacemos clic en Administrador de tareas.

La columna de PID no suele estar visible, por lo que hacemos clic derecho sobre las columnas y en el
panel que nos aparece, marcamos PID.

Botón derecho y seleccionamos PID

Fuente: Elaboración propia

Y ya puedes ver la columna de identificadores de procesos.

7
 Columna de PID
Fuente: Elaboración propia

PARA SABER MÁS

Un proceso informático puede definirse como aquellas instrucciones que serán ejecutadas por el
microprocesador al leer un programa determinado. Haz clic en el siguiente enlace para conocer más
acerca de los procesos:

1.2 Características propias de los procesos

No todos los equipos de cómputo procesan el mismo tipo de trabajos, y un algoritmo de

planificación que en un sistema operativo determinado puede funcionar bien, podría dar un
rendimiento poco eficiente en otro cuyos procesos tienen características diferentes. Estas
características pueden ser:

• Atributos: Son las circunstancias que debe conocer un sistema operativo sobre un
proceso para decidir sobre él.

8
• Nombre: Se trata de la referencia que se debe conocer de un atributo para que otro
proceso, o el sistema operativo, puedan “llamarle”.
• Estado actual: O lo que es lo mismo, la situación de ese proceso e n ese instante. Si
un proceso pasa de un estado activo a uno de suspensión, sus parámetros se
guardan en su bloque de control de procesos.
• Prioridad: Virtud de los procesos por la que se determina cuál de ellos accederá
con preferencia a la CPU antes que otro. Una de las técnicas que se usan en la
asignación de prioridades es la llamada de envejecimiento. Esta técnica rata de
aumentar la prioridad de aquellos procesos que llevan más tiempo en lista de espera,
con lo que se evita que un proceso no se active nunca o que quede obsoleto.
• Cantidad de Entrada/Salida: Hay procesos que realizan una gran cantidad de
operaciones de entrada y salida, otros no.
• Cantidad de Uso de CPU: hay procesos que no realizan muchas operaciones de
entrada y salida, en su lugar emplean la unidad central de procesamiento de manera
intensiva.

Consumo de CPU de diversos procesos en Windows 10

Fuente: Elaboración propia

• Procesos de Lote o Interactivos: Es más eficiente en cuanto a la lectura de datos.

Por su parte, un programa interactivo espera más tiempo por las respuestas de los
usuarios.
• Procesos en Tiempo Real: Si los procesos tienen que dar respuesta en tiempo
real, es necesario que tengan prioridad para los turnos de ejecución.
• Longevidad de los Procesos: Hay procesos que requerirán de varias horas para
finalizar su cometido, mientras que otros solo necesitan de algunos segundos.
• Derechos: Son útiles cuando se trata de recursos compartibles.

9
1.3 Estados de los procesos

El estado de los procesos es totalmente aleatorio en el tiempo, y el comportamiento de un

grupo procesos dependerá de condiciones concretas en un instante determinado. Esto
significa que los programas no pueden ser desarrollados asumiendo lo que sucederá en el
futuro cuando se están procesando. Por ello, los procesos pueden tener diferentes estados
durante su existencia.

¿SABÍAS QUE…?

El número de estados de un proceso dependerá del diseño del sistema operativo.

Hay tres estados que siempre estarán presentes en la vida de un proceso:

• Estado en ejecución: cuando el proceso está en posesión de la CPU.

• Estado bloqueado: cuando el proceso está a la espera de que se lleve a cabo un
evento externo (una entrada o salida de datos).
• Estado listo: cuando el proceso está en listo para ser ejecutado, pero está detenido
para permitir la ejecución de otro proceso.

Con transiciones entre estos diferentes estados, obtendríamos un grafo como el que siguiente:

Estados de los procesos

Fuente: Elaboración propia

Además de estos estados básicos, hay dos estados útiles al sistema operativo:

• Nuevo: El proceso acaba de ser creado, pero todavía no ha entrado en el grupo de

ejecutables.

10
 • Terminado: El proceso ha sido excluido del grupo de procesos ejecutables.

Estado de los procesos

Fuente: Elaboración propia

ARTÍCULO DE INTERÉS

En un sistema operativo, todo proceso presenta un estado que indica la situación de la ejecución en
que se encuentra, y el número de estados varía de un sistema a otro. En el artículo, podrás encontrar
más información sobre los estados de los procesos.

11
1.3.1 Transiciones entre los procesos

Existen cuatro transiciones básicas entre los procesos, las cuales podemos observar en la
siguiente figura:

Transiciones entre los procesos

Fuente: Elaboración propia

• La transición 1: el proceso se bloquea en la entrada. Esta transición implica que el

proceso estaba siendo ejecutado, pero ha sido bloqueado ya que ha de esperar la
ocurrencia de un evento externo. Esta transición se obtiene con la ejecución de una
llamada al sistema con este mismo fin, aunque también puede ser forzado por el
sistema operativo (se realizó una solicitud que no puede ser satisfecha en ese
instante).

• La transición 2, el planificador elige otro proceso. Esta segunda transición ocurre

cuando el planificador del sistema operativo decide que se debe entregar el control de
la CPU a un proceso, aun cuando el actual estaría en condiciones de continuar. Esta
decisión la motiva el hecho de que el proceso ya consumió el quantum de tiempo
asignado o porque está listo otro proceso de más prioridad que el actual.

• La transición 3, el planificador elige este proceso. Esta transición es llevada a cabo por
el planificador del procesador y se trata de entregar el control de este a un proceso
que ya está listo (debido a que el actual terminó, se bloqueó o se le quitó).

• La transición 4, la entrada vuelve a estar disponible. Esta transición se desarrolla

cuando el evento externo que el proceso estaba esperando, ocurre. Si en ese instante
no hay otro proceso en ejecución, o su prioridad es superior al que se está ejecutando,
tendrá lugar la transición 3. En caso contrario habrá que esperar en el estado de listo.

12
1.3.2 Estructura de los procesos

Los procesos en Linux tienen un modelo de memoria plano y se encuentran estructurados en

dos zonas de memoria:

• Zona de usuario: normalmente, los tres primeros gigabytes de las direcciones lógicas.
• Zona del núcleo: lo ocupa el cuarto gigabyte.

La zona del núcleo de Linux está mapeada en todos los procesos del sistema, vemos en la
siguiente imagen la estructura interna de algunos procesos en un instante de su ejecución.

Esta estructura coincide con los dos modos del procesador que utiliza Linux:

• El código de la zona del núcleo se ejecuta siempre en modo supervisor.

• El código presente en la zona del usuario se ejecuta en modo usuario.

Estructura de los procesos en Linux

Fuente: http://sop.upv.es/gii-dso/es/t3-procesos-en-linux/gen-t3-procesos-en-
linux.html#:~:text=En%20Linux%2C%20cada%20proceso%20del,%5Binclude%2Flinux%2Fsched.&text=h%230020%5D%20contiene
%20informaci%C3%B3n%20de%20bajo%20nivel%20sobre%20el%20proceso.

1.3.3 Tabla de procesos

En todos los sistemas operativos, los procesos están representados por una estructura de
datos donde se guarda toda la información relevante de éste: el PCB (Process Control Block).
Cada proceso del sistema en Linux tiene dos estructuras que lo identifican:

• El PCB, que es una estructura del tipo struct task_struct.

• Una estructura del tipo struct thread_info.

13
BLOQUE DE CONTROL DEL PROCESO DE PCB. Los datos que se describen a continuación
ayudan a fijar una idea sobre la utilización de estos PCBs:

• Identificación del proceso: Número único del proceso.

• Credenciales: Propietario real y efectivo, permisos.
• Estado actual del proceso: En ejecución, Preparado, Bloqueado, etc.
• Contador de programa: Dirección de la siguiente instrucción a ejecutar del proceso
• Parámetros de planificación: Por ejemplo, prioridad, y en general, la información
necesaria para planificar el proceso.
• Gestión de memoria: Información necesaria para manipular y gestionar los aspectos
relacionados a la memoria.
• Gestión de E/S: Incluye las solicitudes de E/S pendientes, los dispositivos usados por el
proceso.
• Información diversa: Generalmente referidas a aspectos contables, como tiempo real
y CPU utilizados, hora de inicio, etc.

ENLACE DE INTERÉS

El proceso es un programa de ejecución compuesto por un código o instrucciones, el contador del

programa, así como los registros y las variables que contienen toda la información relativa al entorno
donde se ejecutan. Si quieres ampliar información sobre las tablas de proceso, puedes acceder al
siguiente enlace.

1.4 Prioridades

Como la mayoría de los sistemas operativos modernos, Linux tiene la capacidad de ejecutar
múltiples procesos, compartiendo la CPU y los recursos del sistema entre ellos.

En Linux existen 140 valores de prioridades, aunque estos se dividen en dos tipos distintos:

• Nice, permite cambiar la prioridad del proceso. Su valor por defecto es 0, y el rango al
que permite modificar los procesos va del más alto (-20) al más bajo (19).
• Renice, permite alterar la prioridad en tiempo real y no detiene el proceso.

14
 • Prioridad en tiempo real, cuyo valor de prioridad va de 1 a 99.

Para modificar las prioridades de los procesos empleando el terminal de comandos:

Nice (sin argumentos, devolverá la prioridad por defecto: 0).

Nice -n -5 (iniciará el comando con una prioridad de -5).

Cambiar la prioridad de un proceso en Linux mediante GUI

Fuente: elaboración propia

1.5 Jerarquía entre procesos

Un proceso puede crear otros procesos y, de igual forma, los nuevos procesos pueden crear
otros y así sucesivamente. Para representar de manera gráfica el proceso de creación sucesiva
de procesos, se emplea un grafo de procesos, y este no es más que un árbol dirigido con raíz,
con un arco que va del nodo Pi al nodo Pj. Así, se dice que Pi es el padre de Pj o que Pj es hijo
de Pi. Cada proceso tendrá un solo padre, pero tantos hijos como sean necesarios.

Árbol de procesos
Fuente: elaboración propia

Existen varias formas para que un proceso cree otro al hacer uso de una operación con este
objetivo (como un fork). Para ello, se debe tener en cuenta cómo continúa la ejecución y como
se compartirán los recursos.

Si nos fijamos en cómo continúa la ejecución, se pueden instrumentar dos casos:

• Construcción fork/join: El padre continúa la ejecución concurrentemente con el hijo.

• Construcción parbegin/parend: El padre espera hasta que el hijo termina.

15
Por otro lado, de compartir los recursos, se podrán instrumentar también dos casos:

• Construcción fork/join: El padre y el hijo comparten todas las variables.

• Esquema de Unix: El hijo tiene acceso solo a un subconjunto de las variables del padre.

Un proceso termina cuando ejecuta su última instrucción, sin embargo, existen circunstancias
en que se requiere terminarlo en forma forzada. Un proceso termina a otro mediante una
instrucción del tipo Kill Id.

¿SABÍAS QUE…?

La operación kill se invoca únicamente por un proceso padre para terminar la ejecución de un
proceso hijo. Ya que la instrucción necesita de la identificación del proceso a ser terminado, la
instrucción fork devuelve esta información (Id = fork L).

ENLACE DE INTERÉS

En el artículo podrás saber más sobre la jerarquía de los procesos.

En muchos sistemas operativos se establece como condición que los procesos hijos no podrán
continuar su ejecución si el padre ya ha sido finalizado. Cuando un proceso no termina su
ejecución durante todo el tiempo en que el sistema operativo esté funcionando se dice que es
un proceso estático. Un proceso que finaliza se denomina proceso dinámico. Cuando un
sistema operativo consiste en un número limitado de procesos estáticos, su grafo de procesos
será también estático; es decir, nunca cambiará. En caso contrario, será dinámico. No
obstante, la estructura estática solo está presente en sistemas operativos muy simples.

16
 EJEMPLO PRÁCTICO
Como administrador de sistemas informáticos en una empresa de informática, te han pedido que
crees un proceso. Para ello, sabes que el núcleo de UNIX dispone de varias estructuras de datos para
gestionar los procesos, siendo la más importante de ellas la tabla de procesos, que contiene una
entrada por cada proceso. En UNIX, los procesos se crean a partir de otros procesos, y la jerarquía es
como sigue:

• Todo proceso tiene un padre.

• Todo proceso puede tener ninguno o varios hijos.
o La excepción: el proceso cuyo PID es cero.
o Un proceso sin padre se denomina huérfano.
• El proceso cuyo PID es 1 se convierte automáticamente en el padre de los huérfanos.

En UNIX, los primeros procesos que sea crean son:

1. PID 0: swapper.
2. PID 1: init.
3. PID 2: demonio de páginas.

Así, para crear un proceso en UNIX usamos la llamada:

Si la llamada fork() tiene éxito.

• Se crea un nuevo proceso, denominado proceso hijo.
• El proceso hijo es una copia del proceso padre.

Devuelve:
• El valor –1 en caso de error.
• El valor 0 al proceso hijo y PID del proceso hijo al proceso padre, en caso de éxito.

La compilación del fichero.C se realiza desde el terminal de la siguiente manera:

gcc -c Nombrefichero.c Compilar

gcc -o Nombrefichero.exe Nombrefichero.o Enlazar
./Nombrefichero.exe Ejecutable

Ahora, copiamos el siguiente código en lenguaje C, que creará procesos y ejecutará la orden ls –l.

Recuerda que debes anotar el PID de los procesos padre e hijo.

Creamos un documento con el siguiente contenido llamado practica.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <unistd.h> // librerias para procesos
#include <sys/types.h>

main() {
pid_t IdentificadorDeProceso ;
printf("Soy el proceso %d \n", getpid()) ;
printf("Voy a crear un proceso hijo\n") ;

17
 IdentificadorDeProceso = fork() ;
if (IdentificadorDeProceso == -1)
printf("Se ha producido un error al crear el hijo\n") ;
else if (IdentificadorDeProceso == 0){
printf("Soy el nuevo proceso hijo (%d)\n", getpid()) ;
printf("mi proceso padre es (%d)\n", getppid()) ;
printf("voy a ejecutar el comando LS -l (%d)\n", getppid()) ;
execl("/bin/ls", "ls", "-l", NULL);

}
else {
printf("Sigo siendo el proceso padre. He creado") ;
printf("el proceso %d\n", IdentificadorDeProceso) ;

} /* else */
wait(NULL);
return(0);
} /* main */

En el terminal, se debe ejecutar el comando gedit practica.c para abrir un editor de texto, a
continuación, escribir las siguientes líneas:

Practica.c
Fuente elaboración propia

En el último paso, el documento se guarda, se compila, se enlaza y se ejecuta.

Ejecución practica.c
Fuente elaboración propia

18
 VÍDEO DE INTERÉS

Si quieres saber más sobre la jerarquía y los estados de un proceso, puedes acceder al vídeo y ampliar
tus conocimientos sobre el tema.

2. PROCESOS HABITUALES DEL SISTEMA

En tu trabajo como administrador los sistemas informáticos de la empresa de instalación de

cocinas, uno de los empleados de atención al cliente ha abierto un archivo que le han enviado
por mail y piensa que puede ser un virus. Accedes al administrador de tareas para ver los
procesos activos y, viendo uno que desconoces, haces una búsqueda en línea para informarte
sobre él. Realizando estos pasos, compruebas que es un proceso de Windows y que no hay
problema alguno.

Tanto en los sistemas operativos Windows como UNIX, existen una serie de procesos que son
de vital importancia para el óptimo funcionamiento del sistema. En los sistemas operativos
UNIX, los procesos están identificados por el PID, así como por el espacio de memoria que
emplean, dividido en tres segmentos: el código, los datos y la pila.

Igualmente contiene información de control de proceso, que hace referencia a la planificación

y estado del proceso, su estructura de datos y la comunicación entre los procesos. La
identificación de usuario (UID), el número de identificación del grupo de usuarios al que
pertenece el proceso (GID) y el bloque de control de proceso (PCB) también son información
importante. En UNIX, la creación y destrucción de procesos son: fork (creación), exit
(destrucción) y wait (espera).

Por su parte, los programas en Windows son controlados por eventos. De esta forma, el
programa principal aguarda la llegada de un evento (hacer clic derecho en el ratón) para
invocar un procedimiento que procese tal evento. La creación de procesos en Windows se
lleva a cabo mediante la llamada CreateProcess, que primero crea el proceso y luego carga el
programa en el nuevo proceso.

19
2.1 Funciones de los procesos habituales

En la tabla siguiente se recogen las funciones de los procesos habituales del sistema operativo
UNIX:

PROCESO FUNCIÓN
Crear un nuevo proceso idéntico al proceso
Fork
padre.
Exit Finalizar un proceso.
Bloquear el proceso que lo ha llamado hasta
Wait
que uno de los procesos hijos sea destruido

En la tabla siguiente, se exponen algunos de los procesos más habituales del sistema operativo
Windows:

PROCESO FUNCIÓN

La función de este proceso es la de actualizar

Jusched.exe
Java.
Es el proceso usado por los servicios de
Svchost.exe
Windows para ejecutar tareas.
Desktop Window Manager, el proceso
Dwm.exe encargado de gestionar las ventanas de
Windows.
Es el proceso que se encarga de las librerías
Rundll32.exe
del sistema.
Es el proceso encargado de administrar toda
Explorer.exe
la parte gráfica del sistema operativo.

En la tabla siguiente, se observan llamadas del sistema operativo Windows y su equivalencia

con las llamadas del sistema UNIX:

WINDOWS UNIX FUNCIÓN

CreateProcess Fork Crear un proceso nuevo

Esperar a que un proceso

WaitForSingleObject Waitpid
termine
Crear un archivo / abrir uno
CreateFile Open
existente

20
 WINDOWS UNIX FUNCIÓN

ReadFile Read Leer los datos de un archivo

WriteFile Write Escribir datos en un archivo

CreateDirectory Mkdir Crear un nuevo directorio

RemoveDirectory Rmdir Eliminar un directorio

TerminateProcess kill Eliminar un proceso

2.2 Medidas de seguridad ante la aparición de procesos no

identificados

Cuando aparecen procesos que no tenemos identificados en el sistema, conviene realizar una
investigación previa en internet. En los sistemas Windows actuales, si accedemos al
administrador de tareas, disponemos de una opción de buscar en línea, abriendo el navegador
y mostrando información sobre ese proceso.

Opción buscar en línea, administrador de tareas de Windows

Fuente: elaboración propia

21
 COMPRUEBA LO QUE SABES

¿Qué crees que sucedería si detuvieses un proceso system?

Coméntalo en el foro de la unidad.

EJEMPLO PRÁCTICO

Estás utilizando el Administrador de Tareas de Windows y ves un proceso que desconoces, igfxEM
Module. Ante la duda de que sea un proceso malicioso, como un virus, decides buscar en línea para
saber más acerca de él.

Haces clic con el botón derecho sobre el proceso que quieres investigar, y luego haces clic en Buscar
en línea.

Buscar en línea
Fuente: elaboración propia

Se abrirá una ventana en el navegador de internet, que te lleva al buscador de Microsoft, Bing. A la
derecha de la ventana, podrás ver información referente al proceso en cuestión.

22
 Información sobre el proceso igfxEM.exe de Windows
Fuente: elaboración propia.

3. GESTIÓN DE LOS PROCESOS EN SISTEMAS

OPERATIVOS LIBRES

Trabajas con un ordenador con un sistema operativo Ubuntu Linux. Tu jefe quiere adquirir
nuevo software para la administración de las bases de datos, y tiene tres opciones en mente.
Para ver cuál de los tres programas es más eficiente, los instalas y accedes a la pestaña
recursos, donde ves información relativa a los recursos que cada programa consume,
averiguando qué programa es el más eficiente.

3.1 Línea de orden

Un proceso consiste en un entorno formado por todos los recursos que el sistema necesita
para ejecutar programas. Para el sistema operativo, un proceso es un objeto más que debe
gestionar y al que dar servicio. Para ver los procesos en modo consola en Linux, empleamos el
comando ps. De no añadir ningún otro parámetro, el comando ps mostrará todos los procesos
del usuario con el que estamos conectados al sistema.

Otros de los parámetros más básicos son los siguientes:

• Ps -a: muestra todos los procesos de todos los usuarios.

23
 • Ps -l: muestra información como el UID y el valor “nice”.
• Ps -u: muestra información relativa al usuario conectado en ese momento.

Por defecto, el comando ps nos mostrará las columnas TIME, CMD, PID, TTY.

Ejecutando el comando ps l en Ubuntu Linux

Fuente: Elaboración propia

Algunos de los datos que podemos obtener empleando el comando ps son:

• USER: usuario.
• TTY: terminal.
• CMD: programa que ha iniciado el proceso.
• PID: identificador del proceso.
• NI: prioridad del proceso.
• STAT: estado del proceso.

Ejecutar el comando ps -a
Fuente: elaboración propia

Otros comandos ampliamente usados en Unix son los siguientes:

COMANDO FUNCIÓN
Nice Ajusta las prioridades de -20 a 19
Bg Pone un proceso en segundo plano

Pkill Termina procesos por nombres o atributos

Kill Mata un proceso por su PID

Ps aux Lista de procesos
Se coloca al final de una sentencia de
& comandos para ejecutarla en segundo
plano

24
 COMANDO FUNCIÓN
Fg Trae un proceso a primer plano
Killall Mata un proceso por su nombre
Permite matar los procesos que se
Top
muestran
Pstree Muestra el árbol de procesos

RECUERDA

PID es la abreviatura de Process ID, identificador de proceso. Se trata de un número que identifica de
manera inequívoca un proceso.

VÍDEO DE INTERÉS

La gestión de los procesos es una parte importante del cometido de un sistema operativo. Haz clic en
el siguiente video para conocer más al respecto:

3.2 Entorno gráfico

En este apartado conoceremos las distintas formas con las que podemos monitorizar los
procesos y aplicaciones en sistemas operativos GNU/Linux.

El Monitor del sistema de Linux nos informa sobre los procesos del sistema operativo, el
hardware instalado, los programas y aplicaciones y sus servicios. Para acceder al Monitor del
sistema, podemos hacerlo con la opción de buscar, escribiendo monitor, o accediendo a
Sistema, luego Administración y por último Monitor de sistema.

25
 Monitor del sistema en Ubuntu
Fuente: elaboración propia

Una vez dentro, podremos ver una ventana con tres opciones destacadas: procesos, recursos
y sistemas de archivos.

Monitor del sistema en Linux

Fuente: elaboración propia

SISTEMA DE ARCHIVOS.

La pestaña de Sistema de archivos nos proporciona información del sistema de archivos del
sistema operativo Linux. Destacará el tipo de formato, la capacidad total, el espacio usado y el
disponible.

26
 Sistemas de archivos, Linux
Fuente: elaboración propia

RECURSOS.

Accediendo a la pestaña Recursos, veremos una serie de gráficas relativas a los recursos
globales del sistema operativo, indicando el consumo de CPU, la memoria RAM y la tarjeta de
RED.

Pestaña recursos del monitor de recursos de Linux

Fuente: elaboración propia

En las gráficas de consumo de CPU y memoria se mostrarán el eje Y los porcentajes y en el eje
X los segundos. Los gráficos de red muestran en el eje Y los KB/s que se reciben y envían a lo
largo del tiempo.

27
PROCESOS.

En esta pestaña veremos los procesos que están corriendo en este momento, y se mostrará
información como el nombre del proceso, el usuario, el consumo de la CPU, el identificador del
proceso, la memoria usada y la prioridad del proceso. En la esquina superior derecha aparecen
diferentes opciones, y se nos permite filtrar entre: procesos activos, todos los procesos, mis
procesos y dependencias.

Pestaña procesos en el monitor del sistema en Linux

Fuente: elaboración propia

Seleccionando un proceso de la lista haciendo clic con el botón derecho del ratón, veremos las
posibles acciones que podemos efectuar sobre ellos:

• Detener proceso.
• Propiedades del proceso.
• Finalizar proceso.
• Cambiar prioridad.
• Matar procesos.
• Continuar proceso.
• Mapas de memoria y archivos abiertos.

28
 Acciones a realizar sobre los procesos Fuente: elaboración propia
Fuente: elaboración propia

EJEMPLO PRÁCTICO

Trabajas como administrador de sistemas informáticos en una empresa de renovación de cocinas,

pero hoy el ordenador parece no querer hacerte caso. Por lo tanto, pruebas a realizar algunos
cambios en la prioridad de los procesos que te hacen más falta ahora, y matar otros.

Para ello accede al Monitor del sistema.

1. Busca el proceso asociado a la aplicación abierta.

2. Lo seleccionas y le asignas una prioridad alta.

29
 Cambiar prioridad del proceso
Fuente: elaboración propia

3. Tras ello, vas a matar el proceso que no te interesa. Al igual que antes, haces clic derecho
sobre el proceso en cuestión y haces clic en Matar Proceso.

Matar proceso
Fuente: elaboración propia

4. Se abrirá un mensaje de advertencia, informando de que matar el proceso puede afectar a la

sesión de trabajo.

Matar proceso
Fuente: elaboración propia

5. Haces clic en Matar Proceso.

4. GESTIÓN DE LOS PROCESOS EN SISTEMAS

OPERATIVOS PROPIETARIOS

Como administrador de sistemas informáticos de la empresa de instalación de cocinas, una de

tus funciones es que todos los equipos informáticos, como ordenadores o servidores, funcionen
con eficiencia. A través del Administrador de Tareas de Windows, puedes gestionar los recursos
que los procesos que el sistema operativo lleva a cabo.

30
4.1 Línea de orden

El uso de comandos en Windows para gestionar procesos es de bastante utilidad. Disponemos

de varios, entre los que destacamos los siguientes:

Nombre del comando: tasklist

Consulta de ayuda: tasklist/?

Descripción: Muestra la información de los procesos en ejecución en un equipo local o

remoto. Entre los datos a tener en cuenta aparecen: PID, nombre de sesión, número de
sesiones o uso de la memoria.

Opciones:
• /s: sistema remoto al que se conecta.
• /v: da información detallada de la tarea.
• /fi: filtro (status, PDI, CPUtime…).

Nombre del comando: taskkill

Consulta de ayuda: taskkill/?
Descripción: Finaliza un proceso en ejecución.

Opciones:
• /s: sistema remoto al que se conecta.
• /v: finaliza el proceso especificado junto a todos los procesos iniciados por él.
• /fi: filtro (status, PDI, CPUtime…)

Otros operadores que podemos aplicar en un filtro son:

• EQ: igual que.
• NE: no igual que.
• GT: mayor que.
• GE: mayor o igual que.
• LT: menor que.
• LE: menor o igual que.

4.2 Entorno gráfico

La optimización de los recursos del sistema se puede llevar a cabo mediante la monitorización,
mejorando el rendimiento. Dicha monitorización la suele realizar el administrador del equipo y
para ello dispone de una serie de herramientas en los sistemas operativos, y otras que se
pueden instalar, facilitando la detección de posibles incidencias en el sistema, y obteniendo
información de aspectos que le ayuden a resolverla.

31
El administrador de tareas de Windows nos ofrece información relativa a aplicaciones,
programas, procesos del sistema operativo, actividad de red, rendimiento y usuarios. Entre
algunas de las tareas que se pueden realizar con el administrador de tareas, está cerrar
aplicaciones o procesos de manera manual.

Para acceder al administrador de tareas en Windows podemos hacerlo de diferentes maneras:

• Combinación de las teclas CTRL + ALT + SUP.

• Combinación de las teclas CTRL + Mayus + Esc.
• A través del menú contextual barra de tareas y luego haciendo clic en iniciar el
administrador de tareas.
• Ejecutando el comando taskmgr.exe.

Una vez dentro del administrador de tareas, podemos ver una serie de fichas que hacen
referencia a los procesos, el rendimiento, los usuarios, detalles o servicios del sistema
operativo.

La actualización de estos diversos elementos puede controlarse al hacer clic sobre Vista y
luego, Velocidad de actualización, donde se abre otro panel que nos permite elegir entre
cuatro opciones: alta, normal, baja o en pausa.

Velocidad de actualización.
Fuente: Elaboración propia

En este sentido, la monitorización de procesos permite controlar fallos en los servicios o el

hardware, recursos consumidos o accesos no autorizados, entre otros aspectos. Accediendo a
la ficha Detalles, podremos visualizar los procesos que se están ejecutando en el equipo en
este momento. Algunos de los detalles que observaremos son:

• Nombre del proceso (nombre del fichero ejecutable que está siendo ejecutado).
• PIP (identificador del proceso).
• Estado del proceso.
• Usuario que está ejecutando el proceso.
• Uso de la CPU del proceso.
• Memoria que el proceso está consumiendo.

32
 • Breve descripción del proceso en ejecución.

Pestaña detalles del administrador de tareas

Fuente: elaboración propia

En este apartado, las acciones que realizar sobre los procesos son varias:

• Finalizar la tarea.
• Establecer una prioridad entre varias tareas.
• Buscar en línea. Permite abrir el navegador y buscar el proceso en internet,
conociendo de sus características más importantes).
• Abrir la ubicación del archivo.

Acciones que podemos realizar sobre los procesos en la pestaña Detalle del Administrador de tareas
Fuente: elaboración propia

33
Los procesos que aparecen en este apartado pueden ser iniciados tanto por el sistema como
por los distintos usuarios del equipo. Las aplicaciones podremos verlas dentro de la pestaña
Procesos. En otras variantes de Windows Server, esta opción aparece en una ficha diferente.
Esta pestaña nos permite ver las aplicaciones que se están ejecutando y están situadas en la
barra de tarea del usuario, así como realizar acciones sobre ellas.

Acciones sobre procesos

Fuente: elaboración propia

Existe la posibilidad de ejecutar tareas desde el menú Archivo. Para ello, pulsamos sobre él, y
luego hacemos clic en Ejecutar nueva tarea y escribimos el nombre del programa, carpeta o
recurso a abrir.

Abriendo Notepad desde el administrador de tareas

Fuente: elaboración propia

34
 EJEMPLO PRÁCTICO

Trabajas como administrador de los sistemas informáticos de una empresa de instalación de cocinas.
Hoy quieres aplicar un filtro con el que obtener aquellos procesos cuyo PID sea menor que 500.

1. Accedes al terminal de comandos, haciendo clic en la Tecla Windows + R, y escribiendo cmd.

2. Con el terminal de comandos abiertos, consultas la ayuda del proceso para ver de qué
manera proceder.

3. Luego, ves los filtros que puedes aplicar.

4. Tras ello, ejecutas la orden tasklist

5. SECUENCIA DE ARRANQUE DEL SISTEMA EN

SISTEMAS OPERATIVOS LIBRES Y PROPIETARIOS

Trabajas con un sistema operativo Windows en uno de los ordenadores de la empresa de

instalación de cocinas. Quieres ver qué servicios operan en segundo plano en tu ordenador,
para ello, empleas el comando services.msc.

En este apartado, repasaremos algunos conceptos que ya vimos en el módulo de implantación

de sistemas operativos. A la secuencia de arranque se le denomina boot en inglés, y es el
proceso que inicia el sistema operativo.

35
Cuando en un ordenador se dispone de uno o más sistemas operativos, el usuario ha de tener
opción de elegir con cuál de ellos quiere iniciar sesión. Esta es una de las funciones del gestor
de arranque.

5.1 Secuencia de arranque del sistema

Podemos simplificar la secuencia de arranque de un sistema operativo de la forma siguiente:

1. La BIOS realiza un chequeo de los componentes de hardware cuando el usuario

enciende el ordenador. Para entrar a la BIOS, pulsamos F2, SUP u otra tecla,
dependiendo del ordenador.
2. Seguidamente, la BIOS comprueba determinados aspectos del equipo (la hora del
sistema, la secuencia de arranque, etc.) necesarios para el arranque.
3. En el paso siguiente, la BIOS carga en memoria el gestor de arranque, que se
encuentra almacenado en el primer sector (sector 0, y que tiene un tamaño de 512
bytes). El gestor de arranque contiene las instrucciones, en código máquina, que
pondrán en marcha el ordenador.
4. En caso de que el gestor de arranque sea multi-arranque, es decir, que permita el
arranque de diferentes sistemas operativos, mostrará un menú en el que el usuario
puede seleccionar el sistema operativo que desea utilizar. Una vez escogida la opción
deseada, el gestor transferirá el control al primer sector de la partición del disco duro,
donde se ubica el programa cargador de dicho sistema operativo.

Selección de diferentes sistemas operativos al arrancar Ubuntu Linux

Fuente: elaboración propia

36
 5. El programa cargador del sistema operativo carga el núcleo (kernel), que continuará
con la secuencia de arranque hasta quedar listo para el inicio de sesión, por parte del
usuario.
6. El usuario accede en el sistema.

ENLACE DE INTERÉS

El primer sector de la memoria se llama Master Boot Record (MRB), y se utiliza para iniciar los
ordenadores. Haz clic en el siguiente enlace para conocer más sobre él:

Todo disco duro dispone de un sector 0 denominado Master Boot Record (MBR). Este es el
sector de arranque del disco duro, donde se aloja el programa encargado de pasar el control,
en secuencia de arranque, al sector cero de la partición que contiene el sistema operativo que
el usuario ha seleccionado.

Sector MBR

Toda partición, ya sea primaria o extendida, tiene su sector 0, o sector de arranque de la

partición. En este sector se ubica el programa encargado de arrancar el sistema operativo
instalado en dicha partición. A veces, este programa es parte del gestor instalado en el MBR.

Al ser lo primero que se carga cuando se inicia el ordenador, un gestor de arranque permite
tener diferentes sistemas operativos, así como diferentes versiones, en un mismo disco duro.
Algunos de los gestores de arranque más populares son los siguientes:

37
 • GRUB: el gestor de arranque más popular en las distribuciones Linux. Permite el
arranque de una amplia gama de sistemas operativos, como Windows, Ubuntu o
Debian. Sus principales características son las siguientes:
o Es flexible.
o Entiende distintos tipos de núcleos.
o Dispone de un archivo de configuración.
o Entiende diversos sistemas de archivos (ext2, ext3).
o Dispone de dos modos de trabajo.

• SYSLINUX: usado para arrancar desde sistemas de archivos FAT en Linux.

• PXELINUX: derivado de SYSLINUX y que es utilizado para arrancar de GNU/Linux por
red.
• Boot manager: este es el gestor de arranque de Windows.

¿SABÍAS QUE…?

En Windows podemos modificar el arranque del sistema mediante el comando BCDEDIT.

RECUERDA

Un gestor de arranque es un programa básico que no tiene la totalidad de las funcionalidades de un

sistema operativo. Su cometido es el de preparar todo lo que se necesita para iniciar el sistema
operativo.

5.2 Demonios

Los demonios, daemons en inglés, son procesos no interactivos que funcionan en segundo
plano. Estos procesos son cargados en memoria, a la espera de que se lance alguna señar para
realizar una acción en concreto. Por lo general, se inician y detienen en la ruta
/etc/init.d/nombredemonio.

38
 RECUERDA

Los demonios no disponen de interfaz para su manipulación.

La orden service se emplea para la administración de los servicios en Linux. Se pueden

arrancar, parar o pausar los servicios.

• Parar un servicio: service nombreServicio stop

• Ver el estado de un servicio: service nombreServicio status

También disponemos de otras opciones:

• Parar un servicio: sudo /etc/init.d/nombreServivio stop

• Reanudar un servicio: sudo /etc/init.d/nombreServivio start

ENLACE DE INTERÉS

¿Quieres conocer más acerca de los daemons? Haz clic en el siguiente enlace para descubrir más
sobre su historia o el origen de su curioso nombre:

39
5.3 Servicios

En los sistemas operativos Windows, los demonios son conocidos como servicios. Al igual que
los demonios, los servicios son programas cargados en el sistema operativo, que corren en
segundo plano. En Windows podemos verlos mediante el comando services.msc.

Ejecución de services.msc en Windows 10

Fuente: elaboración propia

A través del terminal de comandos, emplearemos el comando sc.

Nombre del comando: SC

Consulta ayuda: SC /?
Descripción: Es un programa usado para la comunicación con el administrador de control de
servicios.
Opciones:
• Query: consulta estado de un servicio.
• Pause: pausa un servicio.
• Start: inicia un servicio.
• Stop: para un servicio.

40
 COMPRUEBA LO QUE SABES

¿Por qué crees que los demonios o servicios actúan en segundo plano?
Comenta y razona tu respuesta en el foro de la unidad.

EJEMPLO PRÁCTICO

En tu trabajo como administrador de los sistemas informáticos de la empresa dedicada a la

instalación de cocinas quieres comprobar el estado del servicio dhcp.

1. Abres el terminal de comandos como administrador, empleando la combinación de teclas

Windows + R y escribiendo cmd.

2. Luego, ejecutas la orden SC query dhcp, obteniendo una información similar a la

siguiente:

6. ALGORITMO DE PLANIFICACIÓN

En tu trabajo como administrador de sistemas informáticos, debes tener en cuenta las

necesidades de las tareas a realizar y cómo serán dispuestas por los ordenadores a tu cargo.
Conociendo los algoritmos de planificación, puedes sacar el máximo provecho a tus sistemas.

El algoritmo de planificación es el encargado de elegir, en un momento dado, el proceso más

prioritario del sistema de entre los que están preparados para ejecución. En Linux, la

41
planificación de procesos se lleva a cabo en la función schedule() [kernel/sched.c]. Además,
existen otras funciones que también están involucradas en el reparto del tiempo de ejecución.

Planificación de procesos
Fuente: http://sopa.dis.ulpgc.es/ii-dso/leclinux/procesos/planificador/LEC6_CHEDULER.pdf

El algoritmo de planificación de Linux utiliza diversas políticas en función del tipo de proceso y
deberá repartir de la forma más justa posible el uso de la CPU entre diversos tipos de
procesos:

• Los procesos de tiempo real son aquellos cuyo tiempo de respuesta tiene que estar
acotado para que no excedan un cierto umbral máximo.
• Los procesos de segundo plano, como compiladores o procesos de cálculo, no tienen
interacción con el usuario, y su tiempo de respuesta no es crítico.
• Los procesos interactivos no suelen requerir mucho tiempo de cómputo, pero cuando
lo requieren, su respuesta debe ser relativamente rápida.

Los procesos de segundo plano, al igual que los procesos interactivos, pueden llegar a tener
una fuerte actividad de entrada y salida (E/S), por lo que a veces serán difíciles de distinguir.

VÍDEO DE INTERÉS

Para conocer más sobre la planificación de procesos que hace el sistema operativo, te recomendamos
acceder al siguiente tutorial.

42
6.1 Políticas de planificación Linux

A las políticas de planificación se les conoce también como scheduling, y tienen varios
objetivos:

• Satisfacer un tiempo de respuesta adecuado.

• Ofrecer un buen rendimiento para los trabajos en segundo plano.
• Evitar la inanición de procesos.
• Reconciliar las necesidades de los procesos de baja y alta prioridad.

Linux dispone de tres políticas de planificación para dos tipos de procesos: los procesos
normales de UNIX y los procesos de tiempo real. Estos procesos normales de UNIX incluyen
los procesos interactivos, y se planifican bajo la política SCHED_NORMAL. Esta política es del
tipo Round Robin, donde cada proceso tiene un quantum diferente, y en la que se potencia el
tiempo de respuesta de los procesos interactivos.

¿SABÍAS QUE…?

La planificación Round Robin es uno de los algoritmos de planificación de procesos más simples
dentro de un sistema operativo, que asigna a cada proceso una porción de tiempo equitativa y
ordenada.

Por su parte, los procesos de tiempo real han de tener un tiempo de respuesta asegurado, por
lo que el sistema les da prioridad. El procesador se le concederá al proceso de tiempo real con
mayor prioridad preparado para ejecución. Existen dos variantes:

• SCHED_FIFO: son procesos que no pierden el procesador hasta que se bloquean ellos
mismos, o cuando se activa un proceso de tiempo real que tenga más prioridad.

• SCHED_BR: se comportan como SCHED_FIFO, excepto cuando se les acaba el tiempo

que tengan asignado (quantum), donde cederán el procesador a otros procesos de
tiempo real con una prioridad idéntica, y se colocarán al final de la cola de su
prioridad.

43
 RECUERDA

La prioridad de los procesos en tiempo real es fija y se indica en el campo rt_priority de su

task_struct.

6.2 El algoritmo de planificación en Linux

Linux emplea un algoritmo sencillo para planificar las prioridades y seleccionar un proceso.
Cuando elige un nuevo proceso para que sea ejecutado, el planificador salvará el estado del
proceso en curso, los registros específicos del procesador y otros contextos en la estructura de
datos task_struct. Tras ello, restaurará el estado del nuevo proceso y lo ejecutará, dándole
control del sistema.

En este sentido, el algoritmo de planificación solo tiene que decidir qué proceso será el
siguiente en utilizar el procesador, eligiendo un proceso entre todos aquellos que no estén
bloqueados.

EJEMPLO PRÁCTICO

En la empresa para la que trabajas, disponen de un ordenador con un sistema operativo el cual tiene
un algoritmo de planificación similar al de Linux. Este sistema operativo tiene dos algoritmos de
planificación, donde uno es empleado para procesos de tiempo compartido y el otro es empleado
para los procesos en tiempo real.

Cada proceso puede utilizar cualquiera de las políticas de planificación, pero queremos evaluar cómo
seleccionar un algoritmo para nuestro sistema.

Para decidir un criterio o criterios a utilizar, llevaremos una evaluación analítica del sistema, y
obtendremos una fórmula o número que evalúe el rendimiento a partir de:

– El criterio.
– El algoritmo.
– La carga de trabajo del sistema.

44
 ENLACE DE INTERÉS

¿Quieres descubrir más acerca de los algoritmos de planificación de procesos? Haz clic en el siguiente
enlace:

7. SINCRONIZACIÓN Y COMUNICACIÓN ENTRE

PROCESOS

En la organización para la que trabajas, tu jefe está preocupado porque no entiende quién es el
responsable de las operaciones de sincronización de procesos. Le informas que de eso se
encarga el sistema operativo para que los usuarios como él puedan centrarse en utilizar el
ordenador y sus herramientas.

La comunicación entre procesos es necesaria, ya que varios procesos pueden necesitar

colaborar para realizar una tarea. Los mecanismos de comunicación y sincronización son
dinámicos. Cuando se requiere de un mecanismo de este estilo, se crea, usa y destruye para
que no se establezca ningún mecanismo de comunicación de forma definitiva, ya se podrían
producir efectos no deseados.

Los servicios básicos de comunicación son los siguientes:

• Crear: el proceso solicita la creación del mecanismo.

• Enviar o escribir: el proceso emisor envía la información requerida al proceso
receptor.
• Recibir o leer: el proceso receptor recibe y procesa la información enviada.
• Destruir: el proceso solicita la destrucción del mecanismo de comunicación.

Por su parte, la comunicación puede ser de dos tipos:

45
 • Síncrona: en la que los dos procesos ejecutan servicios de forma simultánea. El emisor
ejecuta el servicio enviar, mientras el receptor ejecutará recibir.
• Asíncrona: en la que el emisor envía el proceso y prosigue su ejecución. El sistema
operativo ofrece un almacenamiento intermedio donde guardar la información que ha
sido enviada, hasta que el receptor la solicite.

7.1 Esquema de sincronización síncrona

En los sistemas operativos multitarea, como Windows o Linux, los procesos compiten por
acceder a los recursos compartidos o cooperan dentro de una misma aplicación para
comunicar la información requerida. Ambas situaciones son tratadas por el sistema operativo
mediante mecanismos de sincronización, los cuales permiten un acceso de forma coordinada a
recursos y elementos de comunicación compartidos.

La gestión de estos cambios de estado son un ejemplo de la sección crítica de código dentro
del sistema operativo que tiene que ser ejecutada por éste en exclusión mutua. Otros
ejemplos de código que hay que proteger al ser tratados como sección crítica son la
programación de los dispositivos de entrada y salida o el acceso a estructuras de datos y
buffers compartidos.

PARA SABER MÁS

Cuando los procesos necesitan acceder a algún dispositivo, como en una operación de E/S, pasando
de estado bloqueado a estado preparado, abandonan la CPU una vez la operación ha terminado y
volver eventualmente a ejecución.

El espacio de direcciones es único en el interior del núcleo del sistema operativo, por lo que la
comunicación se resuelve empleando variables de memoria compartida. Como contrapartida a
la agilidad de este esquema, es necesario emplear mecanismos explícitos de sincronización
que garanticen el acceso exclusivo a las variables compartidas. De definir buffers o colas
compartidas a las que se proporcione acceso exclusivo, es posible usar esquemas de
comunicación más elaborados, como el del productor-consumidor.

46
 ¿SABÍAS QUE…?

En el esquema cliente-servidor los clientes producen peticiones que son consumidas por el servidor
de un recurso determinado.

Cuando los procesos que se comunican mediante los esquemas de estructura cliente-servidor,
no comparten el espacio de direcciones, lo que sucede especialmente en sistemas basados en
micronúcleo. En este caso, son necesarias las primitivas de comunicación por paso de
mensajes que, al gestionar la sincronización de forma implícita, simplifican la programación de
la comunicación.

ARTÍCULO DE INTERÉS

La comunicación entre procesos es una función básica de los sistemas operativos que provee un
mecanismo que permite a los procesos comunicarse y sincronizarse entre sí, normalmente a través
de un sistema de bajo nivel de paso de mensajes que ofrece la red subyacente.

7.2 Sección crítica

La sección crítica es la porción de código de un programa de computador que accede a un

recurso compartido, ya sea una estructura de datos o un dispositivo, que no debe de ser
accedido por más de un hilo en ejecución (thread). La sección crítica suele terminar en un
tiempo determinado, por lo que el hilo, proceso o tarea podrá entrar tras este.

Se requiere de un mecanismo de sincronización en la entrada y salida de la sección crítica para

asegurar la utilización del recurso en exclusiva, por ejemplo, un semáforo. El acceso
concurrente se controla prestando atención a las variables que se modifican dentro y fuera de
la sección crítica. La sección crítica se emplea cuando un programa multihilo actualiza

47
múltiples variables sin un hilo de ejecución separado que lleve los cambios conflictivos a esos
datos.

¿SABÍAS QUE…?

La sección crítica puede ser utilizada para asegurarse de que un recurso compartido (un monitor), sea
accedido por un solo proceso a la vez.

La forma en cómo se implementan las secciones varía dependiendo del sistema operativo. Sólo
un proceso puede estar en una sección crítica a la vez. Si un proceso quiere entrar a la sección
crítica, se seguirán los pasos siguientes:

1. Ejecutará el código accediendo en la sección crítica, y si la sección crítica está ocupada,

el proceso esperará.
2. Ejecutará la sección crítica
3. Dejará la sección crítica, para que entre uno de los procesos en espera.

La decisión de qué proceso es el elegido para entrar en el paso 3, puede tener consecuencias
que hay que tener en cuenta. En general, puede asumirse disciplina FIFO. Un aspecto a
destacar es cómo se lleva a cabo la espera en el código que entra en la sección crítica, lo que
determina el tipo de mecanismo de sincronización que se ha de emplear. Esto depende del
tiempo que el proceso tiene que esperar para acceder a la sección crítica.

Respecto a las propiedades del acceso exclusivo a secciones críticas, Dijkstra señala los
siguientes criterios de validez de un mecanismo de sincronización para el acceso exclusivo a
una sección crítica:

• Exclusión mutua: se refiere a que no puede haber más de un proceso

simultáneamente ocupando la CPU.
• No interbloqueo: hace referencia a que ningún proceso fuera de la SC puede impedir
que otro entre a la sección crítica.
• No inanición: indica que un proceso no puede ser dejado en espera por tiempo
indefinido para entrar a la sección crítica.
• Independencia del hardware: dice que no se pueden hacer suposiciones sobre del
número de procesadores o de la velocidad relativa de los procesos.
• Suposición inicial adicional: donde las instrucciones del Lenguaje Máquina son
atómicas y se ejecutan secuencialmente.

Existen otros criterios que determinan la calidad del mecanismo y que hacen referencia a su
rendimiento. Estos son:

48
 • La productividad, hace referencia al número de operaciones de sincronización por
unidad de tiempo que el mecanismo puede soportar.
• El tratamiento equitativo entre los procesos como, por ejemplo, seguir una política
FIFO para acceder a la sección crítica.

VÍDEO DE INTERÉS

En el vídeo podrás conocer con más detalle qué son los conceptos de concurrencia y paralelismo en el
contexto de los lenguajes de programación.

7.3 Exclusión mutua

Los algoritmos de exclusión mutua (mutex) se emplean en programación concurrente para

evitar que fragmentos de código (secciones críticas) accedan a la vez a recursos que no deben
ser compartidos. La mayor parte de estos recursos son señales, contadores, colas y otros datos
que se utilizan en la comunicación entre el código que se ejecuta cuando se da servicio a una
interrupción y el código que se ejecuta el resto del tiempo. Se trata de un problema
importante porque, si no se toman las precauciones debidas, una interrupción puede ocurrir
entre dos instrucciones cualesquiera del código normal y esto puede provocar graves fallos.

La técnica que se emplea por lo común para conseguir la exclusión mutua es inhabilitar las
interrupciones durante el conjunto de instrucciones más pequeño, que impedirá la corrupción
de la estructura compartida (la sección crítica). Esto impide que el código de la interrupción se
ejecute en mitad de la sección crítica.

En un sistema multiprocesador de memoria compartida, se usa la operación indivisible test-

and-set sobre una bandera, para esperar hasta que el otro procesador la despeje.

49
 ¿SABÍAS QUE…?

La operación test-and-set realiza ambas operaciones sin liberar el bus de memoria a otro procesador.
Así, cuando el código deja la sección crítica, se despeja la bandera. Esto se conoce como spin lock o
espera activa.

Algunos sistemas tienen instrucciones multioperación indivisibles similares a las anteriormente

descritas para manipular las listas enlazadas, que se utilizan para las colas de eventos y otras
estructuras de datos que los sistemas operativos usan comúnmente. La mayoría de los
métodos de exclusión mutua clásicos reducen la latencia y espera activa empleando las colas y
cambios de contexto.

PARA SABER MÁS

Los semáforos permiten interbloqueos (deadlocks) en los que un proceso obtiene un semáforo, otro
proceso obtiene el semáforo y ambos se quedan a la espera de que el otro proceso libere el
semáforo. Haz clic en el siguiente enlace para conocer más acerca de los deadlocks:

7.4 Modelo de sincronización por semáforos

Edsger W. Dijkstra dio en 1968 con una solución al problema de la exclusión mutua,
introduciendo del concepto de semáforo binario. Esta técnica resuelve muchos de los
problemas de sincronización entre procesos, y a día de hoy forma parte del diseño de la
mayoría de sistemas operativos y lenguajes de programación concurrentes.

50
 Edsger W. Dijkstra, científico de la computación
Fuente: https://optienterazavala.wordpress.com/2014/09/15/biografia-de-edsger-w-dijkstra/

Un semáforo binario consiste en un indicador (S) de condición que registra cuando un recurso
está disponible o no. Un semáforo binario sólo emplea dos valores: 0 y 1. Cuando para un
semáforo binario S = 1, el recurso está disponible y la tarea lo puede utilizar.

Si, por el contrario, para el semáforo binario S = 0, el recurso no está disponible y el proceso
tendrá que esperar. Los semáforos se implementan con una cola de tareas o de condición, a la
cual se añaden los procesos que están en espera del recurso. Sólo se permiten tres
operaciones sobre un semáforo:

• Inicializar.
• Espera (wait).
• Señal (signal).

¿SABÍAS QUE…?

La notación empleada originalmente por Dijkstra para referirse a las operaciones fue P (espera) y V
(señal)

De esta forma, un semáforo binario es un tipo de datos que únicamente puede tomar los
valores 0 y 1, que trae una cola de tareas asociada y con tres operaciones para actuar sobre él.

Una operación es un procedimiento que se implementa como una acción indivisible. Por ello,
la comprobación y el cambio de valor del indicador se realizan como si fuese una sola

51
operación, lo que es de especial importancia cuando se quiere diseñar el planificador de
tareas. Las operaciones se describen de la siguiente forma:

Inicializa (S: Semáforo Binario; v: Entero).

El valor del semáforo S cambia al valor v (0 o 1).
Espera (S)
if S = 1 then
S := 0
else
suspende la tarea que hace la llamada y la pone a la cola de tareas.
Señal (S)
if (la cola de tareas está vacía) then
S := 1
Else
reanuda la primera tarea de la cola de tareas.

En los sistemas de procesador único, es necesario inhibir las interrupciones durante la

ejecución de las operaciones del semáforo. Por su parte, en los sistemas multiprocesador, este
método no resulta posible, ya que las instrucciones de los procesadores pueden entrelazarse
de cualquier manera. La solución consiste en emplear instrucciones de hardware especiales, o
bien, introducir soluciones software como las ya vistas, que sirven para sistemas
uniprocesador y multiprocesador.

Aspectos para tener en cuenta:

• La operación inicializa se debe realizar antes de que se inicie la ejecución concurrente

de los procesos, ya que función es la de dar un valor inicial al semáforo.
• Un proceso que corre la operación espera y encuentra el semáforo a 1, lo pone a 0 y
continua su ejecución.
• Si el semáforo está a 0, el proceso queda en estado de espera hasta que el semáforo se
libere.

52
 EJEMPLO PRÁCTICO

Tienes dos procesos recurrentes donde A no puede ejecutar A2 hasta que B haya ejecutado B2,
¿cómo podrías solucionar este problema?

La solución está en usar un semáforo con valor inicial 0, tal que así:

Semáforo sync = 0

B A
… …
B1 A1
Sync.signal() Sync.wait()
B2 A2
… …

VÍDEO DE INTERÉS

Si quieres saber cómo programar semáforos con POSIX y sus funciones, puedes acceder al siguiente
tutorial.

53
RESUMEN FINAL

Hay dos tipos de procesos: los que se ejecutan en modo usuario, que únicamente puede
acceder a unas partes de su propio espacio de direcciones, y los que se ejecutan en modo
núcleo (kernel), que puede acceder tanto a su propio espacio de direcciones como al espacio
de direcciones del núcleo.

Si un proceso se ejecuta en primer plano, significa que el usuario está interactuando

directamente con él. Si el proceso se ejecuta en segundo plano, éste sigue activo aun cuando
el usuario no esté actuando directamente con el proceso.

Las características de los procesos son: atributos, nombre, estado actual, prioridad, cantidad
de entrada/salida, cantidad de uso de CPU, procesos de lote o interactivos, procesos en
tiempo real, la longevidad del proceso y sus derechos.

Un proceso puede estar en tres estados diferentes: en ejecución, si está en posesión de la CPU;
bloqueado, si está a la espera de un evento externo; y listo, cuando está detenido a la espera
de que se ejecute otro proceso.

En Windows a los procesos se les conoce como servicios, mientras que en Linux los
denominamos daemons (demonios). En ambos sistemas operativos podemos interactuar con
los procesos, acceder a su información, detenerlos, matarlos (kill) y gestionarlos, tanto
mediante herramientas gráficas (como el administrador de tareas de Windows o Monitor de
tareas en Linux) como mediante comandos en el terminal de comandos de Windows o Linux.

La secuencia de arranque (boot) de un sistema operativo es el primer proceso activo al

encender un ordenador. Mediante un gestor de arranque podemos disponer de más de un
sistema operativo en nuestro ordenador, y acceder al que queramos al arrancar el sistema. Los
algoritmos de planificación son los encargados de decidir qué proceso es el prioritario para el
sistema de entre los que están preparados para su ejecución.

La comunicación entre procesos, así como su sincronización en sistemas multitarea es de vital

importancia para el óptimo funcionamiento del sistema. La comunicación entre procesos
puede ser síncrona o asíncrona. Gracias a Edsgeer W. Dijkstra disponemos de la solución a la
exclusión mutua entre procesos, con la introducción del concepto de semáforo binario.

54