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

Biblioteca de Tasques Paral·leles

Següent ►
►

La Biblioteca de Tasques Paral·leles (TPL) és una part fonamental de la programació asíncrona i paral·lela en F#. La TPL proporciona un conjunt d'eines i classes que faciliten la creació i gestió de tasques paral·leles, permetent als desenvolupadors escriure codi que s'executi de manera eficient en múltiples fils.

Conceptes Clau

Abans de començar a treballar amb la TPL, és important comprendre alguns conceptes clau:

  • Tasques (Tasks): Representen operacions que es poden executar de manera asíncrona.
  • Async: Una paraula clau en F# que facilita la creació de fluxos de treball asíncrons.
  • Await: Utilitzat per esperar el resultat d'una tasca asíncrona.

Creació de Tasques

En F#, les tasques es poden crear utilitzant la classe Task de la biblioteca System.Threading.Tasks. Aquí teniu un exemple bàsic de com crear i executar una tasca:

open System.Threading.Tasks

let simpleTask = Task.Run(fun () ->
    printfn "Tasques en execució"
    System.Threading.Thread.Sleep(1000)
    printfn "Tasques completades"
)

simpleTask.Wait() // Espera que la tasca es completi

Explicació del Codi

  1. Importació de la Biblioteca: open System.Threading.Tasks importa la biblioteca necessària per treballar amb tasques.
  2. Creació de la Tasca: Task.Run crea una nova tasca que executa el codi proporcionat.
  3. Execució de la Tasca: simpleTask.Wait() espera que la tasca es completi abans de continuar.

Tasques Asíncrones

Les tasques asíncrones permeten que el codi continuï executant-se sense esperar que la tasca es completi. Això és útil per a operacions que poden trigar molt de temps, com ara accedir a una base de dades o fer una crida a una API.

open System.Threading.Tasks

let asyncTask = async {
    printfn "Tasques asíncrones en execució"
    do! Task.Delay(1000) |> Async.AwaitTask
    printfn "Tasques asíncrones completades"
}

Async.Start(asyncTask)

Explicació del Codi

  1. Creació de la Tasca Asíncrona: async { ... } crea una tasca asíncrona.
  2. Retard Asíncron: Task.Delay(1000) |> Async.AwaitTask espera de manera asíncrona durant 1 segon.
  3. Inici de la Tasca: Async.Start(asyncTask) inicia la tasca asíncrona.

Combinació de Tasques

La TPL permet combinar múltiples tasques per executar-les en paral·lel i esperar que totes es completin. Això es pot fer utilitzant Task.WhenAll.

open System.Threading.Tasks

let task1 = Task.Run(fun () ->
    printfn "Tasques 1 en execució"
    System.Threading.Thread.Sleep(1000)
    printfn "Tasques 1 completades"
)

let task2 = Task.Run(fun () ->
    printfn "Tasques 2 en execució"
    System.Threading.Thread.Sleep(2000)
    printfn "Tasques 2 completades"
)

Task.WhenAll([| task1; task2 |]).Wait()

Explicació del Codi

  1. Creació de Tasques: task1 i task2 són dues tasques que s'executen en paral·lel.
  2. Combinació de Tasques: Task.WhenAll([| task1; task2 |]) espera que ambdues tasques es completin abans de continuar.

Exercicis Pràctics

Exercici 1: Creació i Execució de Tasques

Creeu una tasca que imprimeixi un missatge, esperi 2 segons i després imprimeixi un altre missatge.

open System.Threading.Tasks

let myTask = Task.Run(fun () ->
    printfn "Inici de la tasca"
    System.Threading.Thread.Sleep(2000)
    printfn "Final de la tasca"
)

myTask.Wait()

Exercici 2: Tasques Asíncrones

Creeu una tasca asíncrona que esperi 3 segons i després imprimeixi un missatge.

open System.Threading.Tasks

let myAsyncTask = async {
    printfn "Inici de la tasca asíncrona"
    do! Task.Delay(3000) |> Async.AwaitTask
    printfn "Final de la tasca asíncrona"
}

Async.Start(myAsyncTask)

Exercici 3: Combinació de Tasques

Creeu dues tasques que s'executin en paral·lel, una que esperi 1 segon i una altra que esperi 2 segons. Espereu que ambdues tasques es completin abans de continuar.

open System.Threading.Tasks

let taskA = Task.Run(fun () ->
    printfn "Tasques A en execució"
    System.Threading.Thread.Sleep(1000)
    printfn "Tasques A completades"
)

let taskB = Task.Run(fun () ->
    printfn "Tasques B en execució"
    System.Threading.Thread.Sleep(2000)
    printfn "Tasques B completades"
)

Task.WhenAll([| taskA; taskB |]).Wait()

Resum

En aquesta secció, hem après a treballar amb la Biblioteca de Tasques Paral·leles (TPL) en F#. Hem vist com crear i executar tasques, com treballar amb tasques asíncrones i com combinar múltiples tasques per executar-les en paral·lel. Aquests conceptes són fonamentals per escriure codi eficient i escalable en aplicacions que requereixen operacions asíncrones i paral·leles.

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