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

Concurrència en Scala

Següent ►
►

La concurrència és un concepte clau en la programació moderna, especialment en aplicacions que necessiten gestionar múltiples tasques simultàniament. Scala ofereix diverses eines i biblioteques per treballar amb concurrència de manera eficient i segura. En aquest tema, explorarem els conceptes bàsics de la concurrència en Scala, incloent futures, promeses, actors i altres mecanismes.

Continguts

  1. Introducció a la Concurrència
  2. Futures i Promeses
  3. Actors amb Akka
  4. Paral·lelisme i Col·leccions Paral·leles
  5. Exercicis Pràctics

  1. Introducció a la Concurrència

La concurrència permet que múltiples tasques es realitzin al mateix temps, millorant l'eficiència i el rendiment de les aplicacions. En Scala, la concurrència es pot gestionar de diverses maneres:

  • Futures i Promeses: Permeten treballar amb resultats asíncrons.
  • Actors: Un model de concurrència basat en missatges.
  • Col·leccions Paral·leles: Permeten operacions paral·leles sobre col·leccions.

  1. Futures i Promeses

Futures

Un Future representa un valor que pot estar disponible en algun moment en el futur. És una eina poderosa per treballar amb operacions asíncrones.

Exemple de Future

import scala.concurrent._
import ExecutionContext.Implicits.global
import scala.util.{Success, Failure}

val future = Future {
  // Simulació d'una tasca que triga temps
  Thread.sleep(1000)
  42
}

future.onComplete {
  case Success(value) => println(s"El resultat és $value")
  case Failure(e) => println(s"Error: ${e.getMessage}")
}

Promeses

Una Promise és un contenidor que es pot completar amb un valor o un error. Un Future es pot derivar d'una Promise.

Exemple de Promise

import scala.concurrent.Promise

val promise = Promise[Int]()
val future = promise.future

future.onComplete {
  case Success(value) => println(s"El resultat és $value")
  case Failure(e) => println(s"Error: ${e.getMessage}")
}

// Completar la promesa
promise.success(42)

  1. Actors amb Akka

Akka és una biblioteca per a la programació concurrent i distribuïda basada en el model d'actors. Els actors són unitats de computació que processen missatges de manera asíncrona.

Exemple d'Actor

import akka.actor.{Actor, ActorSystem, Props}

class HelloActor extends Actor {
  def receive = {
    case "hello" => println("Hola, món!")
    case _ => println("Missatge desconegut")
  }
}

val system = ActorSystem("HelloSystem")
val helloActor = system.actorOf(Props[HelloActor], name = "helloactor")

helloActor ! "hello"
helloActor ! "adeu"

  1. Paral·lelisme i Col·leccions Paral·leles

Scala proporciona col·leccions paral·leles que permeten realitzar operacions en paral·lel de manera senzilla.

Exemple de Col·leccions Paral·leles

val list = List(1, 2, 3, 4, 5)
val parList = list.par

val result = parList.map(_ * 2)
println(result)

  1. Exercicis Pràctics

Exercici 1: Utilitzar Futures

Crea un Future que calculi la suma de dos nombres després d'un retard de 2 segons.

Solució

import scala.concurrent._
import ExecutionContext.Implicits.global

val futureSum = Future {
  Thread.sleep(2000)
  3 + 4
}

futureSum.onComplete {
  case Success(value) => println(s"La suma és $value")
  case Failure(e) => println(s"Error: ${e.getMessage}")
}

Exercici 2: Crear un Actor

Crea un actor que rebi un missatge amb un nombre i respongui amb el doble d'aquest nombre.

Solució

import akka.actor.{Actor, ActorSystem, Props}

class DoubleActor extends Actor {
  def receive = {
    case num: Int => println(s"El doble de $num és ${num * 2}")
    case _ => println("Missatge desconegut")
  }
}

val system = ActorSystem("DoubleSystem")
val doubleActor = system.actorOf(Props[DoubleActor], name = "doubleactor")

doubleActor ! 5
doubleActor ! "hola"

Conclusió

En aquesta secció, hem explorat els conceptes bàsics de la concurrència en Scala, incloent futures, promeses, actors i col·leccions paral·leles. Aquests mecanismes permeten escriure aplicacions més eficients i responsives. En el proper tema, aprofundirem en l'ecosistema i les eines de Scala, incloent SBT i Play Framework.

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