El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este tema, exploraremos los patrones de concurrencia en F#. La concurrencia es una técnica que permite que múltiples tareas se ejecuten de manera superpuesta, mejorando la eficiencia y el rendimiento de las aplicaciones. F# proporciona varias herramientas y patrones para manejar la concurrencia de manera efectiva.

Contenido

Introducción a la Concurrencia
Patrón de Productor-Consumidor
Patrón de Futuro/Promesa
Patrón de Agente
Ejercicios Prácticos

Introducción a la Concurrencia

La concurrencia en F# se puede manejar utilizando varias técnicas y bibliotecas. Algunas de las más comunes incluyen:

Async Workflows: Permiten escribir código asíncrono de manera secuencial.
Task Parallel Library (TPL): Proporciona una forma de manejar tareas paralelas.
MailboxProcessor: Implementa el patrón de actor para manejar la concurrencia.

Ejemplo Básico de Async Workflows

open System
open System.Threading.Tasks

let asyncTask = async {
    printfn "Task started"
    do! Async.Sleep 1000
    printfn "Task completed"
}

Async.Start asyncTask

En este ejemplo, Async.Sleep simula una tarea que toma tiempo, y Async.Start inicia la tarea asíncrona.

Patrón de Productor-Consumidor

El patrón de Productor-Consumidor es útil cuando tienes una o más tareas que producen datos y una o más tareas que consumen esos datos.

Ejemplo de Productor-Consumidor

open System.Collections.Concurrent
open System.Threading

let queue = new BlockingCollection<int>()

let producer = async {
    for i in 1 .. 10 do
        printfn "Producing %d" i
        queue.Add(i)
        do! Async.Sleep 500
    queue.CompleteAdding()
}

let consumer = async {
    while not queue.IsCompleted do
        match queue.TryTake() with
        | true, item -> printfn "Consuming %d" item
        | _ -> ()
}

Async.Start producer
Async.Start consumer

En este ejemplo, el productor agrega elementos a una cola bloqueante, y el consumidor los toma y procesa.

Patrón de Futuro/Promesa

El patrón de Futuro/Promesa se utiliza para representar un valor que estará disponible en el futuro.

Ejemplo de Futuro/Promesa

open System.Threading.Tasks

let promise = TaskCompletionSource<int>()

let future = async {
    let! result = promise.Task |> Async.AwaitTask
    printfn "Result: %d" result
}

Async.Start future

// Simulate some work
Task.Delay(1000).ContinueWith(fun _ -> promise.SetResult(42)) |> ignore

En este ejemplo, TaskCompletionSource se utiliza para crear una promesa, y Async.AwaitTask espera a que la promesa se complete.

Patrón de Agente

El patrón de Agente (o Actor) es útil para manejar la concurrencia mediante el envío de mensajes entre agentes.

Ejemplo de Agente

type Message =
    | Increment
    | GetCount of AsyncReplyChannel<int>

let agent = MailboxProcessor.Start(fun inbox ->
    let rec loop count = async {
        let! msg = inbox.Receive()
        match msg with
        | Increment -> return! loop (count + 1)
        | GetCount replyChannel ->
            replyChannel.Reply(count)
            return! loop count
    }
    loop 0
)

agent.Post Increment
agent.Post Increment

let count = agent.PostAndReply(fun replyChannel -> GetCount replyChannel)
printfn "Count: %d" count

En este ejemplo, un agente maneja mensajes para incrementar un contador y obtener su valor actual.

Ejercicios Prácticos

Ejercicio 1: Implementar un Productor-Consumidor con múltiples consumidores

Descripción: Modifica el ejemplo del patrón de Productor-Consumidor para tener múltiples consumidores.

Solución:

open System.Collections.Concurrent
open System.Threading

let queue = new BlockingCollection<int>()

let producer = async {
    for i in 1 .. 10 do
        printfn "Producing %d" i
        queue.Add(i)
        do! Async.Sleep 500
    queue.CompleteAdding()
}

let consumer id = async {
    while not queue.IsCompleted do
        match queue.TryTake() with
        | true, item -> printfn "Consumer %d consuming %d" id item
        | _ -> ()
}

Async.Start producer
for i in 1 .. 3 do
    Async.Start (consumer i)

Ejercicio 2: Crear un Agente que maneje una lista de tareas

Descripción: Implementa un agente que reciba tareas (funciones) y las ejecute en orden.

Solución:

type TaskMessage =
    | AddTask of (unit -> unit)
    | ExecuteTasks

let taskAgent = MailboxProcessor.Start(fun inbox ->
    let rec loop tasks = async {
        let! msg = inbox.Receive()
        match msg with
        | AddTask task -> return! loop (task :: tasks)
        | ExecuteTasks ->
            tasks |> List.iter (fun task -> task())
            return! loop []
    }
    loop []
)

taskAgent.Post (AddTask (fun () -> printfn "Task 1 executed"))
taskAgent.Post (AddTask (fun () -> printfn "Task 2 executed"))
taskAgent.Post ExecuteTasks

Conclusión

En esta sección, hemos explorado varios patrones de concurrencia en F#, incluyendo el patrón de Productor-Consumidor, Futuro/Promesa y Agente. Estos patrones son herramientas poderosas para manejar la concurrencia y pueden mejorar significativamente el rendimiento y la eficiencia de tus aplicaciones. Asegúrate de practicar los ejercicios para consolidar tu comprensión de estos conceptos.

Patrones de Concurrencia

Contenido

Introducción a la Concurrencia

Ejemplo Básico de Async Workflows

Patrón de Productor-Consumidor

Ejemplo de Productor-Consumidor

Patrón de Futuro/Promesa

Ejemplo de Futuro/Promesa

Patrón de Agente

Ejemplo de Agente

Ejercicios Prácticos

Ejercicio 1: Implementar un Productor-Consumidor con múltiples consumidores

Ejercicio 2: Crear un Agente que maneje una lista de tareas

Conclusión

Curso de Programación en F#

Módulo 1: Introducción a F#

Módulo 2: Conceptos Básicos

Módulo 3: Programación Funcional

Módulo 4: Estructuras de Datos Avanzadas

Módulo 5: Programación Orientada a Objetos en F#

Módulo 6: Programación Asíncrona y Paralela

Módulo 7: Acceso y Manipulación de Datos

Módulo 8: Pruebas y Depuración

Módulo 9: Temas Avanzados

Módulo 10: Aplicaciones Prácticas