Contenido

Contenido................................................................................................................................................. i
Lista de figuras ........................................................................................................................................ ii
Objetivo.................................................................................................................................................. iii
Introduccin ............................................................................................................................................ 1
Historia .................................................................................................................................................... 2
Paradigmas de programacin concurrente ............................................................................................ 3
Espacio de direcciones global particionado (PGAS) ............................................................................ 3
Modelo actor....................................................................................................................................... 4
Comunicacin de procesos secuenciales (CSP)................................................................................... 4
Concurrente orientado a objetos ....................................................................................................... 5
Programacin de flujo de datos .......................................................................................................... 6
Multihilo .............................................................................................................................................. 6
Estudios de comparacin en modelos de programacin concurrentes ................................................. 8
Programacin concurrente en idiomas especficos ................................................................................ 9
Ada ...................................................................................................................................................... 9
Especificaciones de task y cuerpos de task. .................................................................................... 9
Fases de un task. ........................................................................................................................... 10
Erlang ................................................................................................................................................ 11
Procesos. ....................................................................................................................................... 11
Procesos concurrentes y paso de mensajes. ................................................................................ 12
Actores en Erlang. ......................................................................................................................... 13
Go (Golang) ....................................................................................................................................... 14
CSP: goroutines. ............................................................................................................................ 14
CSP: channels. ............................................................................................................................... 15
Java.................................................................................................................................................... 16
Estados de un hilo ......................................................................................................................... 17
Conclusin ............................................................................................................................................. 19
Bibliografa ............................................................................................................................................ 20
 ii

Lista de figuras

Figura 1 Partes de un task.................................................................................................................... 10

Figura 2 Estados de tarea..................................................................................................................... 10
Figura 3 Ejemplo de mdulo Erlang ..................................................................................................... 12
Figura 4 Comunicacin entre procesos ............................................................................................... 13
Figura 5 actores en Erlang ................................................................................................................... 13
Figura 6 creacion de un goroutine ....................................................................................................... 14
Figura 7 modelo fork-join de Go ........................................................................................................... 15
Figura 8 ejemplo de channel en Go ..................................................................................................... 16
Figura 9 Modelo de hilos en Java......................................................................................................... 17
Figura 10 Estados de un hilo ................................................................................................................ 17
 iii

Objetivo

Proporcionar una comparacin de los diferentes enfoques de los Lenguajes concurrentes,

discutir sus fortalezas y debilidades e identificar las reas de aplicacin para las que son ms
adecuadas. Esto requiri resolver problemas relevantes (desde el punto de vista de
concurrencia) utilizando cada enfoque. Tambin fue necesario decidir sobre la metodologa de
la comparacin.
 1

Introduccin

La reciente transicin de la computacin de propsito general a arquitecturas multincleo ha

cambiado drsticamente el campo de la computacin. Esta transicin fue causada por las
restricciones fsicas que impiden la escala de frecuencia. Ya no es el caso que la prxima
generacin de hardware har que los programas sean mucho ms rpidos, a menos que se creen
con la concurrencia en mente, una tarea que desde hace tiempo se reconoce como difcil y
propensa a errores.
Aunque se han propuesto muchos lenguajes de programacin para hacer que la escritura
de programas concurrentes sea ms simple que el multihilo tradicional, en gran medida se
desconoce si alguno de los lenguajes recin creados realmente mejora algn aspecto de la
productividad del programador. Este informe se enfoca en el subconjunto de aquellos lenguajes
que estn orientados hacia arquitecturas multi-core.
Esos lenguajes intentan facilitar la vida del programador introduciendo abstraccin de
alto nivel y ocultando la mayora de los detalles de bajo nivel utilizados para implementarlos.
El problema con esas abstracciones es que podran eliminar la flexibilidad que sera necesaria
para resolver de manera eficiente algunos problemas relacionados a la concurrencia.
 2

Historia

En la ltima dcada, el campo de la programacin concurrente se ha ampliado desde

aplicaciones de sistema operativo "puro" a una multitud de programas distribuidos y en tiempo
real.
Desde finales de la dcada de 1960, la programacin concurrente se ha considerado
necesaria para la implementacin de objetos relacionados con la computadora en los sistemas
operativos, como los procesos de usuario y los controladores de dispositivos. Los primeros
desarrollos de la programacin simultnea surgieron en un esfuerzo por dar a la comunidad
relativamente pequea de programadores de ncleo de sistema un conjunto de operaciones para
fomentar el desarrollo de sistemas operativos ms confiables.
En ina vision ms reciente, la programacin concurrente se considera como un enfoque
para lograr una representacin ms fiel de los objetos en el mundo modelados por un programa.
Muchos programas son, de hecho, simulaciones de algn sistema en el mundo fsico: un avin
que se mueve en el espacio, un banco con cajeros y clientes. El mundo fsico se compone de
muchos objetos que operan independientemente el uno del otro, necesitando ocasionalmente
sincronizar, comunicarse o referirse a informacin compartida. En esta vista, la programacin
simultnea es til porque proporciona un mapeo ms natural de estos objetos del mundo real a
los segmentos del programa. Se dice que una representacin ms natural es ms fcil de
codificar, depurar y mantener.
Dado que un nmero cada vez mayor de programas se codifica mejor como
concurrentes, un nmero cada vez mayor de programadores necesita aprender a hacer una
programacin concurrente de manera confiable y correcta. A medida que la concurrencia ha
pasado de los sistemas operativos a las aplicaciones, la necesidad de hacer una programacin
concurrente ha pasado de un pequeo crculo de programadores de sistemas a una comunidad
mucho ms amplia de programadores de aplicaciones.
 3

Paradigmas de programacin concurrente

Los lenguajes de programacin concurrente, son lenguajes de programacin que usan

construcciones de lenguaje para concurrencia. Estas construcciones pueden implicar multi-
threading (Multihilo), soporte para computacin distribuida, paso de mensajes, recursos
compartidos (incluyendo memoria compartida) o futuros y promesas.
Dichos lenguajes a veces se describen como lenguajes orientados a la concurrencia o
lenguajes de programacin orientados a la concurrencia (COPL). Muchos lenguajes de
programacin concurrentes se han desarrollado ms como lenguajes de investigacin (por
ejemplo, Pict) que como lenguajes para uso de produccin. Sin embargo, lenguajes como
Erlang, Limbo y occam, han visto el uso industrial en varios momentos en los ltimos 20 aos.
Los paradigmas de programacin en los que la concurrencia juega un papel importante
son:

Espacio de direcciones global particionado (PGAS)

Espacio de direcciones global particionado o Partitioned Global Address Space (PGAS), es un

espacio global de direcciones con parte de la memoria local para cada procesador (YELICK,
2007, pg. 24).
Es un modelo de programacin paralelo. Asume un espacio de direcciones de memoria
global que est particionado lgicamente y una parte de l es local para cada proceso,
subproceso o elemento de procesamiento. La novedad de PGAS es que las porciones del
espacio de memoria compartida pueden tener una afinidad por un proceso particular,
explotando as la localidad de referencia.

El modelo PGAS es la base de los siguientes lenguajes:

1) Chapel
2) Coarray Fortran
3) Fortress
4) High Performance Fortran
5) Titanium
6) Unified Parallel C
7) X10
8) ZPL
 4

Modelo actor

Modelo actor o Actor Model, los actores envan mensajes asincrnicos a otros actores (AGHA,
1986, pg. 8).
El modelo actor en ciencias de la computacin es un modelo matemtico de
computacin concurrente que trata a los "actores" como primitivas universales de la
computacin concurrente. En respuesta a un mensaje que recibe, un actor puede: tomar
decisiones locales, crear ms actores, enviar ms mensajes y determinar cmo responder al
siguiente mensaje recibido. Los actores pueden modificar su propio estado privado, pero solo
pueden afectarse mutuamente a travs de mensajes (evitando la necesidad de bloqueos).
El modelo actor se origin en 1973. Se ha utilizado tanto como un marco para una
comprensin terica de la computacin y como la base terica para varias implementaciones
prcticas de sistemas concurrentes.
Varios lenguajes de programacin diferentes emplean el modelo actor o alguna
variacin del mismo. Estos lenguajes incluyen a:

1) Axum - un lenguaje de dominio especfico desarrollado por Microsoft.

2) Elixir (runs on the Erlang VM)
3) Erlang
4) Janus
5) Red
6) SALSA
7) Scala/Akka (toolkit)
8) Smalltalk
9) Akka.NET

Comunicacin de procesos secuenciales (CSP)

Comunicacin de procesos secuenciales o communicating sequential processes (CSP),

composicin paralela de un nmero fijo de procesos secuenciales que se comunican de forma
sncrona utilizando mensajes en un patrn fijo (HOARE, 1978, pg. 677).
Es un lenguaje formal para describir patrones de interaccin en sistemas concurrentes.
Es un miembro de la familia de teoras matemticas de concurrencia conocidas como lgebras
de procesos, o clculos de procesos, que se basan en mensajes que pasan por canales. CSP fue
 5

muy influyente en el diseo del lenguaje de programacin occam, adems a influido en el

diseo de lenguajes de programacin tales como:

1) Limbo
2) RaftLib
3) Go
4) Crystal
5) Clojure's core.async

Concurrente orientado a objetos

Concurrente orientado a objetos o Concurrent Object-Oriented, lenguaje orientado a objetos

extendido con concurrencia (MORANDI, 2010, pg. 23).
es un paradigma de programacin basado en el concepto de "objetos", que puede contener datos,
en forma de campos, a menudo conocidos como atributos; y cdigo, en forma de
procedimientos, a menudo conocidos como mtodos y que tambin puede implementar
concurrencia.

Los lenguajes OOP que soportan concurrencia son los siguientes:

1) C++
2) Ada
3) C*
4) C#
5) C++ AMP
6) Charm++
7) D Programming Language
8) Eiffel SCOOP (Programacin Simple concurrente Orientada a Objetos)
9) Emerald (tambin programacin distribuida)
10) Java
11) Join Java - Un lenguaje basado en Java con caractersticas de join-calculus.
12) ParaSail
13) Smalltalk
 6

Programacin de flujo de datos

Programacin de flujo de datos o Dataflow programming, es un paradigma de programacin

que modela un programa como un grfico dirigido de los datos que fluyen entre las operaciones,
implementando as los principios del flujo de datos y la arquitectura (William & Edward, 2013,
pg. 14).
Los lenguajes de programacin de Dataflow comparten algunas caractersticas de los
lenguajes funcionales, y generalmente se desarrollaron para llevar algunos conceptos
funcionales a un lenguaje ms adecuado para el procesamiento numrico.
Los lenguajes Dataflow que soportan concurrencia son:

1) CAL
2) E (tambin orientado a objetos)
3) Joule (tambin programacin distribuida)
4) LabView (tambin asincrona)
5) Lustre (tambin asincrona)
6) Preesm (tambin asincrona)
7) Signal (tambin asincrona)
8) SISAL

Multihilo

Multihilo o Multithreading, El subprocesamiento mltiple se encuentra principalmente en

sistemas operativos multitarea. Multithreading es un modelo de programacin y ejecucin
generalizado que permite que mltiples hilos existan dentro del contexto de un proceso (Lewis,
2003, pg. 15).
Estos subprocesos comparten los recursos del proceso, pero pueden ejecutarse de forma
independiente. El modelo de programacin con hilos proporciona a los desarrolladores una
abstraccin til de ejecucin concurrente. El multihilo tambin se puede aplicar a un proceso
para permitir la ejecucin en paralelo en un sistema de multiprocesamiento.
Los lenguajes Multihilo son:

1) Cilk
2) Cilk Plus
 7

3) C#
4) Clojure
5) Fork - Lenguaje de programacin para el modelo PRAM.
6) Java
7) ParaSail
8) Rust
9) SequenceL
 8

Estudios de comparacin en modelos de programacin concurrentes

(NANZ, 2011) Present un estudio emprico para comparar la facilidad de uso (comprensin
del programa, depuracin y escritura) de dos enfoques de programacin de concurrencia
(SCOOP y Java de subprocesos mltiples). Usan autoestudio para evitar el sesgo de enseanza,
la autoevaluacin para verificar la equivalencia de los grupos evaluados y las tcnicas de
evaluacin estndar para evitar la subjetividad en la evaluacin de las respuestas. Llegan a la
conclusin de que SCOOP es de hecho ms fcil de usar que Java de subprocesos mltiples en
lo que respecta a la comprensin y depuracin de programas, y equivalente en lo que respecta
a la escritura de programas.

PHILIPPSEN (2000), es un extenso catlogo de 111 lenguajes concurrentes orientados a

objetos y sus principales caractersticas con respecto a los mecanismos utilizados para iniciar
y coordinar la concurrencia. Se analizan las ventajas, desventajas e interdependencias de estas
caractersticas. Se discute el grado de computacin y localidad de datos que se puede lograr.
El rendimiento se evala en trminos de factores de rendimiento clave conocidos (despliegue
en abanico, concurrencia dentro del objeto y localidad), no en trminos de puntos de referencia
de ningn tipo. Las desventajas de las caractersticas se expresan en trminos de encapsulacin
discontinua, anomalas de herencia, expresividad de las limitaciones de coordinacin y eleccin
de implementacin (lenguaje frente a biblioteca). Los entornos de programacin orientados a
la programacin distribuida no son considerados. (pgs. 917980)

(SCAIFE, 1996) Discute problemas en el diseo y seleccin de lenguajes orientados a objetos

concurrentes y describe algunos principios generales, examinando 29 lenguajes de
programacin.

(Wyatt, Kavi, & Hufnagel, 1992) Presento una comparacin de 14 lenguajes concurrentes
orientados a objetos con respecto a comunicacin, sincronizacin, administracin de procesos,
herencia e intercambios de implementacin. Llegan a la conclusin de que ninguno de ellos
cumpli con los siete requisitos de Meyer para que un lenguaje est realmente orientado a
objetos, ya que restringen o no permiten la herencia. Los idiomas se seleccionaron segn la
disponibilidad del material publicado y los manuales detallados. No hay discusin sobre las
reas de aplicacin para las cuales los idiomas son ms adecuados.
 9

Programacin concurrente en idiomas especficos

Hoy en da, los lenguajes de programacin ms comnmente utilizados que tienen

construcciones especficas para concurrencia son Java y Go. Ambos lenguajes utilizan
fundamentalmente un modelo de concurrencia de memoria compartida, por otro lado de los
lenguajes que usan un modelo de concurrencia de transmisin de mensajes (Modelo actor),
Erlang es probablemente el ms utilizado en la industria en la actualidad, sin embargo el
lenguaje Ada es importante desde el punto de vista histrico en el desarrollo de la programacin
concurrente. Por ello se describir en ms detalle sobre la concurrencia en dichos lenguajes.

Ada

El lenguaje que se convirti en Ada fue elegido en una competencia patrocinada a fines de la
dcada de 1970 por el Departamento de Defensa de los Estados Unidos (DoD); Ada pretendio
convertirse en el lenguaje en el que se escribe el nuevo software relacionado con la defensa.
Las primitivas de programacin concurrente se incluyeron en el lenguaje porque los
diversos documentos de requisitos del DoD ("Steelman" y sus informes predecesores)
enumeraron la programacin simultnea como esencial para la misin del lenguaje. Ada fue el
primer lenguaje destinado a la adopcin y uso generalizado en la industria para incluir un
conjunto completo de primitivas de programacin concurrente.
Un proceso en Ada se llama task cuya traduccin en espaol es tarea, cada tarea (task)
es en realidad un objeto de un tipo de tarea, un tipo de tarea es declarado por el programador;
el programador puede, en el caso lmite, simplemente declarar tareas individuales, un tipo para
cada uno de los cuales es implcitamente declarado por el compilador.
Especificaciones de task y cuerpos de task. Una unidad de tarea consiste en una
especificacin de tarea y un cuerpo de tarea, la cual se muestra en la figura 1.

Una especificacin de tarea que comienza con el tipo de tarea de palabras reservadas
declara un tipo de tarea. El valor de un objeto de un tipo de tarea designa una tarea que
tiene las entradas, si las hay, que se declaran en la especificacin de la tarea; estas
entradas tambin se llaman entradas de este objeto. La ejecucin de la tarea est definida
por el cuerpo de la tarea correspondiente. (hanna, 1983)
 10

Figura 1 Partes de un task

Fases de un task. Burns & Wellings (1997) Afirman que. La ejecucin de un objeto
de tarea tiene tres fases activas principales (pg. 65). Las cuales son:

1) Activacin: la elaboracin de la parte declarativa del cuerpo de la tarea (las

variables locales en el cuerpo de la tarea se crean y se inicializan durante la
activacin). El Activador identifica la tarea que cre y activ la tarea.
2) Ejecucin normal: la ejecucin de las declaraciones visibles dentro del cuerpo
de la tarea.
3) Finalizacin: la ejecucin de cualquier cdigo de finalizacin asociado con
cualquier objeto en su parte declarativa.

Figura 2 Estados de tarea

 11

La figura 2 muestra las transiciones entre estos estados durante la vida de la tarea. Se
dice que la tarea creada est en estado No activado (Unactivated). Luego, el tiempo de
ejecucin asocia un hilo de control a esta tarea. Si la elaboracin de la tarea falla, la tarea va
directamente al estado Terminado (Terminated); de lo contrario, la tarea alcanza el estado
ejecutable (Runnable) y ejecuta el cdigo de usuario de la tarea. Si este cdigo ejecuta alguna
operacin que bloquea la tarea (de acuerdo con la semntica de Ada: cita, operacin protegida
o declaracin de demora), alcanza el estado de Suspensin (Sleep) y luego vuelve al estado
Ejecutable (Runnable). Cuando la tarea ejecuta una alternativa de terminacin de Ada o finaliza
la ejecucin del cdigo de usuario de Ada, pasa al estado Terminado (Terminated).

Erlang

En 1986 Erlang fue diseado con el objetivo de mejorar el desarrollo de las aplicaciones de
telefona, tambin para programar sistemas concurrentes, en tiempo real y con tolerancia a
fallas distribuidas el cual fue desarrollado por Ericsson y de ah el nombre. Erlang es un
lenguaje de programacin funcional utilizado para crear sistemas de software en tiempo real
escalables de forma masiva con requisitos de alta disponibilidad (ARMSTRONG, 2003, pg.
477). El paralelismo se expresa utilizando el modelo Actor, donde los procesos se crean como
hilos de ejecucin independientes y luego se comunican a travs de mensajes (sin memoria
compartida). El lenguaje tiene un fuerte uso industrial en aplicaciones del mundo real.
Procesos. En Erlang, cada hilo de ejecucin se llama proceso. (Aparte: el trmino
"proceso" se usa generalmente cuando los hilos de ejecucin no comparten datos entre s y el
trmino "hilo" cuando comparten datos de alguna manera. Los hilos de ejecucin en Erlang no
comparten datos, por eso son llamados procesos).
El BIF (built in function - funcin incorporada) spawn (generar) de Erlang se usa para
crear un nuevo proceso, del siguiente modo: spawn(Module, Exported_Function, List of
Arguments).
En la figura 3 se muestra, la funcin say_something escribe su primer argumento el
nmero de veces especificado por el segundo argumento. La funcin start inicia dos procesos
de Erlang, uno que escribe "hello" tres veces y otro que escribe " goodbye" tres veces. Ambos
procesos usan la funcin say_something. Tener en cuenta que una funcin utilizada de esta
manera por spawn, para iniciar un proceso, debe exportarse desde el mdulo (es decir, en el -
export al inicio del mdulo).
 12

Figura 3 Ejemplo de mdulo Erlang

Procesos concurrentes y paso de mensajes. La concurrencia en Erlang es

fundamental para su xito. En lugar de proporcionar hilos que comparten memoria, cada
proceso de Erlang se ejecuta en su propio espacio de memoria y posee su propio heap (montn
estructura de datos) y stack (pila estructura de datos). Los procesos no pueden interferir
entre s inadvertidamente, como es muy fcil en los modelos de subprocesamiento.
Los procesos se comunican entre s a travs del envo de mensajes, donde el mensaje
puede ser cualquier valor de datos de Erlang. El envo de mensajes es asncrono, por lo que una
vez que se enva un mensaje, el proceso puede continuar el proceso. Los mensajes se recuperan
del buzn del proceso de forma selectiva, por lo que no es necesario procesar los mensajes en
el orden en que se reciben. Esto hace que la concurrencia sea ms robusta, particularmente
cuando los procesos se distribuyen a travs de diferentes computadoras y el orden en que se
reciben los mensajes depender de las condiciones del ambiente de red.
La Figura 4 muestra un ejemplo, donde un proceso de "servidor de rea" calcula reas
de formas para un cliente.
 13

Figura 4 Comunicacin entre procesos

Actores en Erlang. En Erlang, que est diseado para concurrencia, distribucin y

escalabilidad, los actores son parte del lenguaje en s. Debido a sus races en la industria de las
telecomunicaciones, donde una gran cantidad de procesos concurrentes son normales, es casi
imposible pensar en Erlang sin actores, que tambin se utilizan para proporcionar distribucin.
Los actores en Erlang se llaman procesos y se inician utilizando la funcin spawn incorporada.
Una aplicacin simple que utiliza un actor se puede ver a continuacin. En esta
aplicacin, se define un actor que acta como contador bsico. Enviamos 100.000 incrementos
de mensajes al actor y luego le pedimos que imprima su valor interno.

Figura 5 actores en Erlang

 14

En la figura 5 las lneas 1 y 2 definen el mdulo y las funciones exportadas. Las lneas
4 a 7 contienen la funcin de ejecucin, que inicia un proceso de contador y comienza a enviar
mensajes de incremento. El envo de estos mensajes ocurre en las lneas 15 a 18, usando el
operador de paso de mensajes (!).

Go (Golang)

El lenguaje fue anunciado en noviembre de 2009. Se utiliza en algunos de los sistemas de

produccin de Google, as como en otras empresas.

Si bien Go es a la vez de propsito general y un lenguaje de sistemas de bajo nivel, una

de sus principales fortalezas es el modelo y las herramientas de concurrencia integrados.
Muchos otros lenguajes tienen bibliotecas (o extensiones) de terceros, pero la
concurrencia inherente es algo unico de los lenguajes modernos, y es una caracterstica
central del diseo de Go. (Kozyra, 2014)

El estilo de concurrencia Go es mediante La comunicacin de procesos secuenciales

(CSP - Communicating sequential processes) la cual utiliza la comunicacin como primitiva
de sincronizacin.

CSP: goroutines. goroutines (rutinas go) es una de las unidades de organizacin ms

bsicas en un programa Go, un goroutine tiene un modelo simple: es una funcin que se ejecuta
simultneamente con otros goroutines en el mismo espacio de direcciones. En pocas palabras,
un goroutine es una funcin que se ejecuta simultneamente (no necesariamente en paralelo)
Junto con otro cdigo. Podemos iniciar uno simplemente colocando la palabra clave go antes
de una funcin:

Figura 6 creacion de un goroutine

 15

Go sigue un modelo de concurrencia llamado modelo fork-join. La palabra fork se

refiere al hecho de que en cualquier punto del programa, puede dividir una rama secundaria de
ejecucin que se ejecutar simultneamente con su padre (parent). La palabra unin se refiere
al hecho de que en algn punto en el futuro, estas ramas concurrentes de ejecucin se volvern
a unir. Cuando el hijo (child) vuelve a unirse, el padre se llama punto de unin. La Figura 7
muestra una representacin grfica para de dicho modelo:

Figura 7 modelo fork-join de Go

CSP: channels. Los channels (canales) son una de las primitivas de sincronizacin en
Go, Si bien se pueden usar para sincronizar el acceso de la memoria, se utilizan mejor para
comunicar informacin entre goroutines. Un channel (canal), sirve como un conducto para
una corriente de informacin; los valores pueden pasarse a lo largo del canal, y luego leer hacia
abajo (Cox-Buday, 2017, pg. 64).
Un channel se crea con make (chan val-type). Los canales se tipan por los valores que
transmiten. Enva un valor a un canal usando la sintaxis del canal <-. Aqu enviamos "ping" al
canal de mensajes que hicimos anteriormente, desde un nuevo goroutine.
La sintaxis <-channel recibe un valor del canal. Aqu recibiremos el mensaje "ping" que
enviamos anteriormente e imprimirlo. Cuando ejecutamos el programa, el mensaje "ping" se
pasa con xito de una rutina a otra a travs de nuestro canal.
Por defecto, enva y recibe el bloqueo hasta que tanto el emisor como el receptor estn
listos. Esta propiedad nos permiti esperar al final de nuestro programa para el mensaje "ping"
sin tener que utilizar ninguna otra sincronizacin.
 16

Figura 8 ejemplo de channel en Go

Java

Desde JDK 1.2 (8 de diciembre de 1998), Java ha incluido un conjunto estndar de clases de
coleccin, el marco de colecciones de Java.

Doug Lea (profesor de ciencias de la computacin y actual jefe del departamento de

ciencias de la computacin de la Universidad Estatal de Nueva York en Oswego)
desarroll un paquete de concurrencia, que comprende varias primitivas de
concurrencia y una gran variedad de clases relacionadas con la coleccin. (Sun, 1995).

El lenguaje de programacin Java y la mquina virtual Java (JVM) se han diseado para
admitir la programacin concurrente, y toda la ejecucin tiene lugar en el contexto de hilos
(threads). Se puede acceder a los objetos y recursos por muchos hilos separados; cada hilo tiene
su propia ruta de ejecucin, pero puede acceder potencialmente a cualquier objeto en el
programa. El programador debe garantizar que el acceso de lectura y escritura a los objetos
est coordinado (o "sincronizado") adecuadamente entre los hilos. La sincronizacin de
subprocesos garantiza que los objetos se modifiquen solo por un subproceso a la vez y que los
subprocesos no puedan acceder a los objetos parcialmente actualizados durante la modificacin
 17

por otro subproceso. El lenguaje Java tiene construcciones integradas para soportar esta
coordinacin.

Figura 9 Modelo de hilos en Java

Estados de un hilo. Un hilo tiene su propio ciclo de vida, durante el cual puede
encontrarse en diferentes estados. Java controla el estado de los hilos mediante el llamado
planificador de hilos, que se encargar de gestionar qu hilo debe ejecutarse en cada momento
y en qu estado deben encontrarse el resto de hilos.

Figura 10 Estados de un hilo

En la Figura 10 se aprecian los diferentes estados en los que puede encontrarse un hilo
(representados en un recuadro) y qu mtodos pueden llevar ese estado al hilo (representados
por flechas), dichos estados se describen a continuacin:

1) Nuevo. Se ha creado un objeto hilo, pero todava no se le ha asignado ninguna

tarea. Para ello, se ha de llamar a su mtodo start() y el hilo pasar al estado
preparado.
 18

2) Preparado. El hilo est preparado para ejecutarse, pero el planificador de hilos

es quin debe decidir si puede hacerlo o debe esperar (por ejemplo, a que acabe
la ejecucin otro hilo).
3) En ejecucin. Una vez el hilo puede acceder a tiempo de CPU, se ejecutar. Si
el hilo finaliza su trabajo completamente, pasar al estado muerto. Si el
planificador de hilos decide que ha cumplido su periodo de tiempo y el hilo no
ha finalizado su trabajo, pasar al estado preparado y esperar a que el
planificador de hilos vuelva a darle permiso para ejecutarse.
4) Bloqueado. El hilo no puede ejecutarse porque espera que ocurra algo. En
cuanto ocurra lo que le est dejando bloqueado, pasar al estado preparado.
5) Muerto. El hilo ha finalizado su tarea y deja de existir.
 19

Conclusin

La programacin concurrente es necesaria y difcil, pero no es necesariamente complicada. Es

necesario porque las restricciones fsicas impiden la escala de frecuencia de los procesadores
nicos, lo que obliga a la transicin a los de ncleo mltiple. Es difcil debido a todos los tipos
de errores no determinsticos que permite. Y, sin embargo, no es necesariamente difcil debido
a una serie de idiomas de alto nivel y herramientas que se han propuesto para facilitarlo.
 20

Bibliografa

Burns, A., & Wellings, A. (1997). Concurrency in Ada (2nd edition). Cambridge University Press.

AGHA, G. (1986). Actors: a model of concurrent computation in distributed systems. Cambridge, MA,
USA: MIT Press.

ARMSTRONG, J. (2003). Making reliable distributed systems in the presence of software errors.
Swedish Institute of Compuster Science.

Cox-Buday, K. (2017). Concurrency in Go. Gravenstein Highway North, Sebastopol, CA: OReilly
Media, Inc.

hanna, g. (1983). Ada '83 Language Reference Manual. The Pentagon, Washington, DC 20301-2081,
U.S.A.: Secretary of Defense, Research and Engineering.

HOARE, C. (1978). Communicating sequential processes. New York, NY, USA: ACM.

Kozyra, N. (2014). Mastering Concurrency in Go. Birmingham, UK: Packt Publishing.

Lewis, B. (2003). Threads Primer: A Guide to Multithreaded Programming. Addison-Wesley.

MORANDI, B. (2010). SCOOP A contract-based concurrent objectoriented.

NANZ, S. (2011). Design of an Empirical Study for Comparing the Usability of Concurrent.
INTERNATIONAL SYMPOSIUM ON EMPIRICAL SOFTWARE ENGINEERING AND
MEASUREMENT.

PHILIPPSEN, M. (2000). A survey of concurrent object-oriented languages. Concurrency: Practice and

Experience.

SCAIFE, N. (1996). A Survey of Concurrent Object-Oriented Programming.

Sun, D. N. (1995). The History of Java Technology. Retrieved 04 30, 2010, from
http://www.oracle.com:
http://www.oracle.com/technetwork/java/javase/overview/javahistory-index-198355.html

William, W., & Edward, A. (2013). Lucid, the Dataflow Programming Language. Academia Press.

Wyatt, Kavi, & Hufnagel. (1992). Parallelism in Object-Oriented Languages: a survey. Los Alamitos,
CA, USA: IEEE Softw.

YELICK, K. (2007). Productivity and performance using partitioned global address space. New York,
NY, USA: ACM.