es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

Goroutines secuenciales de GoLang

19 Jul, 2023 Programación

Soy nuevo en golang y tengo un caso de uso en el que las operaciones en un valor de un tipo deben ejecutarse de manera secuencial, mientras que las operaciones en un valor de otro tipo pueden ejecutarse de forma concurrente.

  1. Imagina que los datos provienen de una conexión de transmisión (en orden)

    key_name_1, value_1
    key_name_2, value_2
    key_name_1, value_1
  2. Ahora, key_name_1 y key_name_2 pueden ser operados por goroutines de forma concurrente.
  3. Pero como el siguiente valor transmitido (3ra fila) es key_name_1 nuevamente, esta operación solo debe procesarse por la goroutine si la operación anterior (1ra fila) ha terminado, de lo contrario, debe esperar a que la 1ra operación termine antes de aplicar la operación.
    Para fines de discusión, podemos suponer que la operación es simplemente agregar el nuevo valor al valor anterior.

¿Cuál sería la manera correcta de lograr esto en golang con el rendimiento más alto posible?

El caso de uso exacto es que los cambios en la base de datos se transmiten en una cola, ahora si se está modificando un valor, es importante que esa operación se aplique en la misma secuencia en otra base de datos, de lo contrario, la consistencia se verá afectada. Los conflictos son raros, pero pueden suceder.

Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para lograr esto en golang con el mejor rendimiento posible, puedes utilizar canales y goroutines.

    1. Crea dos canales, uno para cada key_name. Llamémosles chn1 y chn2.
    2. Crea una goroutine para cada canal que escuche el canal y realice la operación en el valor de ese key_name.
    3. Cuando se transmita un nuevo valor, verifica a qué key_name pertenece y envíalo al canal correspondiente. Por ejemplo, si el valor es para key_name_1, envíalo a chn1.
    4. La goroutine que escucha chn1 debe verificar primero si todavía hay una operación anterior en ejecución para el mismo key_name. Si la hay, debe esperar a que termine antes de procesar la nueva operación. Para hacer esto, puedes utilizar un sync.WaitGroup.
    5. Una vez que la operación anterior en key_name_1 haya terminado, la goroutine debe realizar la nueva operación y actualizar el valor. También debe señalar al grupo de espera (wait group) para que otras goroutines sepan que ha terminado de procesar la operación en este key_name.
    6. El mismo proceso se aplica para key_name_2 en chn2.

    Al utilizar canales y goroutines, puedes lograr concurrencia al tiempo que te aseguras de que las operaciones en cada key_name se procesen secuencialmente. Además, al utilizar un sync.WaitGroup para coordinar las goroutines, puedes asegurarte de que las operaciones se procesen de manera eficiente sin esperas innecesarias.

Comments are closed.