UNIVERSIDAD POLITÉCNICA DE TECÁMAC

ALUMNA: Mujica Zarate Karen Ali

MATRICULA: 1319104657

CARRERA: Ingeniería En Software

CUATRIMESTRE: Séptimo

GRUPO: 2722IS

ASIGNATURA: Programación Concurrente

FECHA: 16-Nov-22

DOCENTE: Ramírez Fuentes Benito

Unidad 2: Investigación patrones de diseño

1
Contenido
INTRODUCCIÓN .............................................................................................................................. 4
CARACTERÍSTICAS DE GO..................................................................................................... 5
CONCURRENCIA NO ES PARALELISMO. ............................................................................... 5
CORRUTINAS EN GO ................................................................................................................ 6
WAITGROUPS EN GO ............................................................................................................... 7
EL MÉTODO ADD ....................................................................................................................... 7
EL MÉTODO DONE. ................................................................................................................... 8
FUNCIONES ANÓNIMAS EN GOROUTINES. ....................................................................... 9
COMUNICANDO GOROUTINES CON CHANNELS ............................................................. 9
CHANNELS O CANALES CON BUFFER ............................................................................. 10
CANALES DE ENTRADA Y SALIDA .................................................................................... 10
CONCLUSION ................................................................................................................................ 11
BIBLIOGRAFÍA .............................................................................................................................. 12

2
FIGURA 1. Logo de GO ......................................................................................... 4
FIGURA 2. Función MAIN...................................................................................... 6
FIGURA 3. Goroutines .......................................................................................... 6
FIGURA 4. WaitGroups ......................................................................................... 7
FIGURA 5. Método ADD ........................................................................................ 7
FIGURA 6. Método DONE...................................................................................... 8
FIGURA 7. Gorotuines Waigroup ......................................................................... 8
FIGURA 8. Esquema básico del funcionamiento de los channels o canales en
Go ........................................................................................................................... 9
FIGURA 9. Canal de entrada ............................................................................... 10
FIGURA 10. Canal de salida................................................................................ 10

3
INTRODUCCIÓN

Golang, también conocido como go, es un lenguaje de programación compilado,

concurrente, imperativo, estructurado y orientado a objetos. Es un lenguaje que fue
diseñado para manejar múltiples tareas de manera asíncrona

Go es un lenguaje de programación compilado y tipado estáticamente diseñado en

Google por Robert GriesemeR Rob Pike y Ken Thompson. Go es sintácticamente
similar a C, pero con seguridad de memoria, recolección de basura, tipificación
estructural, Y concurrencia al estilo CSP .El idioma a menudo se conoce como
Golang debido a su nombre de dominio, golang.org, pero el nombre correcto es Go.

Go fue diseñado en Google en 2007 para mejorar la productividad de la

programación en una era de máquinas multinúcleo, en red y grandes bases de
código. Los diseñadores querían abordar las críticas de otros lenguajes en uso en
Google, pero mantienen sus características útiles:

• tipado estático y eficiencia en tiempo de ejecución (como C)

• legibilidad y usabilidad (como Python o JavaScript)
• multiprocesamiento y redes de alto rendimiento.

Los diseñadores estaban motivados principalmente por su aversión compartida por

C ++. Go se anunció públicamente en noviembre de 2009, y la versión 1.0 se lanzó
en marzo de 2012.Go se usa ampliamente en la producción en Google y en muchas
otras organizaciones y proyectos de código abierto.

En abril de 2018, el logotipo original fue reemplazado por un GO estilizado inclinado

hacia la derecha con líneas de corriente al final. Sin embargo, la mascota Gopher
siguió siendo la misma

FIGURA 1. Logo de GO

4
CARACTERÍSTICAS DE GO.

• El lenguaje es bastante simple Es un lenguaje con muy pocas palabras

clave y pocas funcionalidades. Puedes aprenderlo en muy poco tiempo.
• El compilador de Go es super rápido Dado que tiene pocas palabras claves
y el lenguaje es bastante simple, go compila rapidísimo comparado con
otros lenguajes de programación.
• El manejo de concurrencia es sencillo Go fue diseñado como un lenguaje
concurrente, crear concurrencia con las goroutines es bastante sencillo.
• Crear aplicaciones web es bastante sencillo Go incorpora en su librería
estándar muchísimas utilidades para crear servidores web, por lo que
incluso puedes usarlo sin usar ningún framework, para aplicaciones
sencillas, y no tendrás ningún problema.

CONCURRENCIA NO ES PARALELISMO.

Paralelismo y concurrencia son diferentes.

Un programa es concurrente si puede soportar dos o más acciones en progreso.

Un programa es paralelo si puede soportar dos o más acciones ejecutándose

simultáneamente.

Go soporta dos modelos de concurrencia:

• Comunicación de procesos secuenciales (Communicating Sequential

Processes - CSP), en la que cada proceso tiene sus propias variables, y se
transfieren información entre ellos mediante mensajes. En el caso de Go es
a través de canales.
• Multi-hilo con memoria compartida. En este tipo de concurrencia todos los
procesos escriben sobre el mismo espacio de memoria, es decir, comparten
variables, pero debe haber alguna forma de coordinación entre ellos para que
no choquen ni se bloqueen mutuamente al tomar un recurso.

5
CORRUTINAS EN GO

Una corrutina, en go, es una función o método que se ejecuta concurrentemente

junto con otras funciones o métodos. En go, a las corrutinas se les conoce como
goroutines o gorutinas. Incluso, la función principal, main, se ejecuta dentro de una.

Para generar una goroutine agregamos el keyword go antes de una función. Lo

anterior programará la función para su ejecución asíncrona.

FIGURA 2. Función MAIN

En el caso anterior, debido a su naturaleza asíncrona, la goroutine no detiene la

ejecución del código. Lo anterior implica que el cuerpo de la función main continua
su ejecución y nuestra goroutine nunca llega a ejecutarse.

FIGURA 3. Goroutines

6
¿Pero entonces? ¿cómo le hacemos para que nuestra goroutine se ejecute? La
aproximación ingenua sería usar un sleep para pausar la ejecución del código.
Esto, como ya sabes, es un sinsentido.

Una mejor aproximación sería crear un Waigroup o grupo de espera.

WAITGROUPS EN GO

Un WaitGroup sirve para esperar a que se ejecuten un conjunto de goroutines.

Un WaitGroup funciona internamente con un contador, cuando el contador esté en

cero la ejecución del código continuará, mientras el contador sea mayor a cero,
esperará a que se terminen de ejecutar las demás goroutines.

FIGURA 4. WaitGroups

Para incrementar y decrementar el contador del WaitGroup usaremos los métodos

Add y Done, respectivamente.

EL MÉTODO ADD
El método Add incrementa el contador del WaitGroup en n unidades, donde n es el
argumento que le pasamos. Lo llamaremos cada vez que ejecutemos una goroutine.

FIGURA 5. Método ADD

7
EL MÉTODO DONE.
El método Done se encarga de disminuir una unidad del contador del Waigroup. Lo
llamaremos para avisarle al WaitGroup que la goroutine ha finalizado y decremente
el contador en uno.

FIGURA 6. Método DONE

Recuerda que la instancia del Waigroup (wg *) necesita pasarse por referencia o de
otra manera no accederemos al Waigroup original.

Un tip bastante útil es usar defer sobre el método Done para garantizar que sea lo
último que se ejecute.

FIGURA 7. Gorotuines Waigroup

8
Una vez que el contador de wg.Wait se vuelve cero, se continua la ejecución del
programa.

FUNCIONES ANÓNIMAS EN GOROUTINES.

Las funciones anónimas se usan frecuentemente en conjunto con las goroutines.
Recuerda que los paréntesis que aparecen tras el cuerpo de la función ejecutan la
función anónima que declaramos y también reciben sus argumentos.

Hasta ahora he explicado como ejecutar una goroutine, ejecutar código de manera
concurrente con las goroutines y a esperar a que terminen de ejecutarse, pero
nuestras goroutines no pueden hacer nada más, no pueden cooperar entre ellas
para acelerar los procesos.

COMUNICANDO GOROUTINES CON CHANNELS

Los channels o canales son “conductos”, que aceptan un único tipo de dato. A través
de estos canales “introducimos” información que, posteriormente, podremos
“sacar”.

Las goroutines pueden enviar datos a los canales y también leer datos de ellos,
logrando comunicarse entre sí.

FIGURA 8. Esquema básico del funcionamiento de los channels o canales en Go

9
Un channel o canal en go se declara con make y la palabra chan, que hace
referencia a la palabra channel.

CHANNELS O CANALES CON BUFFER

La función make permite pasarle como un argumento extra la cantidad límite de
datos simultaneos que manejará ese canal. A esto se le conoce como un canal con
buffer o buffered channel.

Cuando querramos hacer referencia al canal como argumento de una función, es

necesario indicar el tipo de dato del canal.

El tipo de dato de un canal también puede ser uno definido usando un struct.

CANALES DE ENTRADA Y SALIDA

Hay canales que reciben información y canales que sacan información, de manera
predeterminada un canal es bidireccional, pero podemos declarar canales de
entrada y de salida.

Para identificarlos, observa el flujo de la flecha alrededor de la palabra chan; una

entra (o se dirige) a chan y la otra sale de chan.

Este es un canal de entrada.

FIGURA 9. Canal de entrada

Este es un canal de salida.

FIGURA 10. Canal de salida

Es importante definir el tipo de canal pues, con los canales bidireccionales corremos
el riesgo de ocasionar un bloqueo en nuestro programa.

10
CONCLUSION

Go no corre sobre ninguna máquina virtual. Crea ejecutables para los sistemas
operativos a los que apunta, que contienen todo lo necesario para poder ejecutarse
sin necesidad de tener algo instalado allí. Al ser compilado, Go es mucho más
eficiente para correr que otros lenguajes interpretados, como JS, Python o Ruby.
Consume menos memoria y su velocidad se acerca a la de C.

Fue pensado para ser simple. Sus estructuras, su sintaxis y su filosofía lo hacen
fácil de leer y de aprender. Es cierto que no es tan legible como Python, por ejemplo,
pero es mucho más legible que otros lenguajes con características similares como
C++ o Java.

Una de las promesas de Go desde el principio era poder hacer mucho con poco. Y
es algo que cumple completamente. Su librería estándar está diseñada y construida
por verdaderos titanes de la ingeniería del software.

11
BIBLIOGRAFÍA
https://coffeebytes.dev/go-goroutines-channels-o-canales-introduccion/
https://blog.thedojo.mx/2019/09/01/por-que-deberias-aprender-
go.html#:~:text=Crea%20ejecutables%20para%20los%20sistemas,como%20JS%
2C%20Python%20o%20Ruby.

12
13