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

Patrons de Concurrència

Següent ►
►

En aquest tema, explorarem diversos patrons de concurrència que es poden utilitzar en F# per gestionar l'execució simultània de tasques. La concurrència és essencial per aprofitar al màxim els recursos del sistema i millorar el rendiment de les aplicacions. Aprendrem sobre patrons com el productor-consumidor, el patró d'actors, i altres tècniques per gestionar la concurrència de manera eficient.

Conceptes Clau

  1. Concurrència vs Paral·lelisme:

    • Concurrència: Gestió de múltiples tasques al mateix temps, però no necessàriament executant-les simultàniament.
    • Paral·lelisme: Execució simultània de múltiples tasques en múltiples nuclis de CPU.

  2. Patrons de Concurrència:

    • Productor-Consumidor: Un patró on un o més productors generen dades i un o més consumidors processen aquestes dades.
    • Patró d'Actors: Un model de concurrència on els actors són entitats que processen missatges de manera asíncrona.
    • Pipeline: Un patró on les dades passen a través d'una sèrie d'etapes de processament.

Productor-Consumidor

El patró productor-consumidor és útil quan tenim una font de dades que es generen contínuament i un procés que les consumeix. En F#, podem implementar aquest patró utilitzant MailboxProcessor.

Exemple de Productor-Consumidor

open System
open System.Threading

// Definim un tipus de missatge
type Message =
    | Produce of int
    | Consume

// Creem un MailboxProcessor per al productor
let producer (mailbox: MailboxProcessor<Message>) =
    async {
        let rnd = Random()
        while true do
            let value = rnd.Next(100)
            mailbox.Post(Produce value)
            do! Async.Sleep(1000) // Simulem temps de producció
    }

// Creem un MailboxProcessor per al consumidor
let consumer (mailbox: MailboxProcessor<Message>) =
    async {
        while true do
            let! msg = mailbox.Receive()
            match msg with
            | Produce value ->
                printfn "Consumed value: %d" value
            | Consume ->
                printfn "Consuming..."
    }

// Inicialitzem el MailboxProcessor
let mailbox = MailboxProcessor.Start(fun inbox ->
    async {
        let producerAgent = MailboxProcessor.Start(producer)
        let consumerAgent = MailboxProcessor.Start(consumer)
        while true do
            let! msg = inbox.Receive()
            match msg with
            | Produce value ->
                consumerAgent.Post(Produce value)
            | Consume ->
                consumerAgent.Post(Consume)
    })

// Enviem missatges al MailboxProcessor
mailbox.Post(Consume)

Explicació del Codi

  1. Definició de Missatges: Definim un tipus de missatge Message amb dos casos: Produce i Consume.
  2. Productor: Un MailboxProcessor que genera valors aleatoris i els envia al mailbox.
  3. Consumidor: Un MailboxProcessor que rep missatges i processa els valors produïts.
  4. Inicialització: Creem un MailboxProcessor principal que coordina els productors i consumidors.

Patró d'Actors

El patró d'actors és un model de concurrència on els actors són entitats que processen missatges de manera asíncrona. Cada actor té el seu propi estat i processa missatges un a un.

Exemple del Patró d'Actors

open System

type ActorMessage =
    | Increment
    | GetState of AsyncReplyChannel<int>

let actor (mailbox: MailboxProcessor<ActorMessage>) =
    let rec loop state =
        async {
            let! msg = mailbox.Receive()
            match msg with
            | Increment ->
                return! loop (state + 1)
            | GetState replyChannel ->
                replyChannel.Reply(state)
                return! loop state
        }
    loop 0

let actorAgent = MailboxProcessor.Start(actor)

// Enviem missatges a l'actor
actorAgent.Post(Increment)
actorAgent.Post(Increment)
actorAgent.PostAndReply(fun replyChannel -> GetState replyChannel)
|> printfn "Current state: %d"

Explicació del Codi

  1. Definició de Missatges: Definim un tipus de missatge ActorMessage amb dos casos: Increment i GetState.
  2. Actor: Un MailboxProcessor que manté un estat intern i processa missatges per modificar aquest estat.
  3. Inicialització: Creem un MailboxProcessor per l'actor i enviem missatges per modificar i obtenir l'estat.

Pipeline

El patró pipeline és útil quan les dades passen a través d'una sèrie d'etapes de processament. Cada etapa pot ser un MailboxProcessor que processa les dades i les envia a la següent etapa.

Exemple de Pipeline

open System

type PipelineMessage =
    | Data of int
    | Stop

let stage1 (next: MailboxProcessor<PipelineMessage>) (mailbox: MailboxProcessor<PipelineMessage>) =
    async {
        while true do
            let! msg = mailbox.Receive()
            match msg with
            | Data value ->
                let processedValue = value + 1
                next.Post(Data processedValue)
            | Stop ->
                next.Post(Stop)
                return ()
    }

let stage2 (next: MailboxProcessor<PipelineMessage>) (mailbox: MailboxProcessor<PipelineMessage>) =
    async {
        while true do
            let! msg = mailbox.Receive()
            match msg with
            | Data value ->
                let processedValue = value * 2
                next.Post(Data processedValue)
            | Stop ->
                next.Post(Stop)
                return ()
    }

let finalStage (mailbox: MailboxProcessor<PipelineMessage>) =
    async {
        while true do
            let! msg = mailbox.Receive()
            match msg with
            | Data value ->
                printfn "Final value: %d" value
            | Stop ->
                return ()
    }

let finalAgent = MailboxProcessor.Start(finalStage)
let stage2Agent = MailboxProcessor.Start(stage2 finalAgent)
let stage1Agent = MailboxProcessor.Start(stage1 stage2Agent)

// Enviem dades al pipeline
stage1Agent.Post(Data 1)
stage1Agent.Post(Data 2)
stage1Agent.Post(Stop)

Explicació del Codi

  1. Definició de Missatges: Definim un tipus de missatge PipelineMessage amb dos casos: Data i Stop.
  2. Etapes del Pipeline: Cada etapa és un MailboxProcessor que processa les dades i les envia a la següent etapa.
  3. Inicialització: Creem els MailboxProcessor per cada etapa i enviem dades al pipeline.

Exercicis Pràctics

  1. Implementar un Productor-Consumidor amb múltiples productors i consumidors.
  2. Crear un sistema d'actors que gestioni un banc de comptes amb operacions de dipòsit i retirada.
  3. Desenvolupar un pipeline amb tres etapes de processament que apliquin diferents transformacions a les dades.

Conclusió

En aquesta secció, hem explorat diversos patrons de concurrència en F#, incloent el productor-consumidor, el patró d'actors i el pipeline. Aquests patrons ens permeten gestionar la concurrència de manera eficient i escriure codi que aprofiti al màxim els recursos del sistema. En el proper mòdul, aprofundirem en l'accés i manipulació de dades en F#.

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