El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

MailboxProcessor i Agents

Següent ►
►

En aquest tema, explorarem el MailboxProcessor i els agents en F#. Aquestes eines són fonamentals per a la programació concurrent i asíncrona, permetent la comunicació segura entre diferents parts d'un programa.

Què és un MailboxProcessor?

Un MailboxProcessor és una abstracció que permet gestionar missatges de manera segura i eficient. És una implementació del patró actor, on cada actor té una bústia (mailbox) per rebre missatges i processar-los de manera seqüencial.

Característiques Clau:

  • Seguretat en la concurrència: Els missatges es processen un a un, evitant condicions de carrera.
  • Simplicitat: Simplifica la gestió de l'estat compartit.
  • Escalabilitat: Facilita la creació de sistemes escalables i reactius.

Creació d'un MailboxProcessor

Exemple Bàsic

A continuació, es mostra un exemple bàsic de com crear i utilitzar un MailboxProcessor en F#:

open System

// Definim un tipus de missatge
type Message =
    | Increment
    | Decrement
    | Print

// Creem un MailboxProcessor
let agent = MailboxProcessor.Start(fun inbox ->
    // Estat inicial
    let rec loop count =
        async {
            // Esperem un missatge
            let! msg = inbox.Receive()
            match msg with
            | Increment ->
                printfn "Incrementant"
                return! loop (count + 1)
            | Decrement ->
                printfn "Decrementant"
                return! loop (count - 1)
            | Print ->
                printfn "Count: %d" count
                return! loop count
        }
    // Iniciem el bucle amb l'estat inicial
    loop 0
)

// Enviem missatges a l'agent
agent.Post Increment
agent.Post Increment
agent.Post Decrement
agent.Post Print

Explicació del Codi

  1. Definició del tipus de missatge: Definim un tipus de missatge Message amb tres variants: Increment, Decrement i Print.
  2. Creació del MailboxProcessor: Utilitzem MailboxProcessor.Start per crear un agent. El bucle loop és una funció recursiva que processa els missatges.
  3. Processament de missatges: Utilitzem inbox.Receive() per esperar un missatge i processar-lo segons el seu tipus.
  4. Enviament de missatges: Utilitzem agent.Post per enviar missatges a l'agent.

Agents en F#

Els agents són una manera de gestionar la concurrència utilitzant el patró actor. En F#, els agents es poden implementar fàcilment amb MailboxProcessor.

Exemple d'Agent amb Estat Compartit

A continuació, es mostra un exemple d'un agent que gestiona un estat compartit:

type StateMessage =
    | Add of int
    | Subtract of int
    | GetState of AsyncReplyChannel<int>

let stateAgent = MailboxProcessor.Start(fun inbox ->
    let rec loop state =
        async {
            let! msg = inbox.Receive()
            match msg with
            | Add x ->
                return! loop (state + x)
            | Subtract x ->
                return! loop (state - x)
            | GetState replyChannel ->
                replyChannel.Reply(state)
                return! loop state
        }
    loop 0
)

// Utilització de l'agent
stateAgent.Post (Add 10)
stateAgent.Post (Subtract 5)
let currentState = stateAgent.PostAndReply(fun replyChannel -> GetState replyChannel)
printfn "Current State: %d" currentState

Explicació del Codi

  1. Definició del tipus de missatge: Definim un tipus de missatge StateMessage amb tres variants: Add, Subtract i GetState.
  2. Creació del MailboxProcessor: Utilitzem MailboxProcessor.Start per crear un agent que gestiona un estat compartit.
  3. Processament de missatges: Utilitzem inbox.Receive() per esperar un missatge i processar-lo segons el seu tipus. Per a GetState, utilitzem AsyncReplyChannel per retornar l'estat actual.
  4. Enviament de missatges: Utilitzem stateAgent.Post per enviar missatges a l'agent i stateAgent.PostAndReply per enviar un missatge i esperar una resposta.

Exercicis Pràctics

Exercici 1: Agent de Comptador

Crea un agent que gestioni un comptador. L'agent ha de poder incrementar, decrementar i restablir el comptador a zero. A més, ha de poder retornar el valor actual del comptador.

Solució

type CounterMessage =
    | Increment
    | Decrement
    | Reset
    | GetCount of AsyncReplyChannel<int>

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

// Utilització de l'agent
counterAgent.Post Increment
counterAgent.Post Increment
counterAgent.Post Decrement
counterAgent.Post Reset
let currentCount = counterAgent.PostAndReply(fun replyChannel -> GetCount replyChannel)
printfn "Current Count: %d" currentCount

Exercici 2: Agent de Cua

Crea un agent que gestioni una cua de missatges. L'agent ha de poder afegir missatges a la cua, extreure el primer missatge de la cua i retornar la longitud actual de la cua.

Solució

type QueueMessage<'T> =
    | Enqueue of 'T
    | Dequeue of AsyncReplyChannel<'T option>
    | GetLength of AsyncReplyChannel<int>

let queueAgent = MailboxProcessor.Start(fun inbox ->
    let rec loop queue =
        async {
            let! msg = inbox.Receive()
            match msg with
            | Enqueue item ->
                return! loop (queue @ [item])
            | Dequeue replyChannel ->
                match queue with
                | [] -> replyChannel.Reply(None)
                | head :: tail ->
                    replyChannel.Reply(Some head)
                    return! loop tail
            | GetLength replyChannel ->
                replyChannel.Reply(List.length queue)
                return! loop queue
        }
    loop []
)

// Utilització de l'agent
queueAgent.Post (Enqueue "Missatge 1")
queueAgent.Post (Enqueue "Missatge 2")
let firstMessage = queueAgent.PostAndReply(fun replyChannel -> Dequeue replyChannel)
printfn "First Message: %A" firstMessage
let queueLength = queueAgent.PostAndReply(fun replyChannel -> GetLength replyChannel)
printfn "Queue Length: %d" queueLength

Conclusió

En aquest tema, hem après què és un MailboxProcessor i com utilitzar-lo per crear agents en F#. Hem vist exemples pràctics de com gestionar missatges i estat compartit de manera segura i eficient. Els exercicis pràctics proporcionats ajuden a consolidar els conceptes apresos i a aplicar-los en situacions reals. Amb aquests coneixements, estàs preparat per abordar la programació concurrent i asíncrona en F# amb confiança.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats