Programação Concorrente em Scala - DCC - UFRJ

Sumário 

Introdução 

Conceitos básicos sobre Scala 

Concorrência em Scala 

Comparação e avaliação 

Minicurso II – WSCAD 2012 (Petrópolis, RJ) 

Programação Concorrente em Scala 

Carlos Bazilio e Silvana Rossetto 

17 de outubro de 2012 

Carlos Bazilio e Silvana Rossetto Programação Concorrente em Scala

Sumário 

Introdução 




1 Introdução 

Motivação e dificuldades programação concorrente 

Programação concorrente em Scala 

2 Conceitos básicos sobre Scala 

Valores e tipos 

Funções e passagem de parâmetros 

Classes e casamento de padrões 

3 Concorrência em Scala 

Actors 

Interoperabilidade com Java 

Futures 

4 Comparação e avaliação 

Java X Scala 

Scala sequencial X concorrente 

Considerações finais 


Sumário 

Introdução 




Motivação programação concorrente 

Com os avanços recentes das arquiteturas 

multiprocessadores o 

interesse pela programação concorrente 

ganha nova motivação como 

modelo fundamental para explorar 

o paralelismo do hardware em diversos 

cenários de aplicações 

1 Fonte: http://freshbooks.com 




Sumário 

Introdução 




Caracterização programação concorrente 



A programação concorrente está relacionada com a 

implementação de programas de computador que incluem linhas de 

controle distintas que podem executar simultaneamente na mesma 

máquina ou em máquinas separadas 

2 Fonte: http://programmingforfuture.com 

Carlos Bazilio e Silvana Rossetto Programação Concorrente em Scala 

2

Sumário 

Introdução 




Dificuldades da programação concorrente 



Necessidade de definir as linhas de controle explicitamente 

Nos casos mais gerais, as linhas de controle precisam interagir 

e sincronizar suas ações ao longo da execução da aplicação 

Os mecanismos de interação incluem: escrita/leitura de 

dados em memória compartilhada e troca de mensagens 

A necessidade de sincronização aparece por duas razões: 

1 controle de acesso a recursos compartilhados 

2 dependência lógica entre os fluxos de execução definida pela 

própria aplicação 


Sumário 

Introdução 







Apresentamos uma visão geral das abstrações de programação 

concorrente da linguagem Scala 

A linguagem Scala 

Criada por Martin Odersky (2003) 

Seu nome é um acrônimo para SCAlable LAnguage (projetada 

para ser estendida) 

Executa sobre a JVM (Java Virtual Machine) e é 

interoperável com Java 

Fusão de conceitos dos paradigmas funcional e orientado 

a objetos 


Uso comercial 

Sumário 

Introdução 






Twitter: alternativa a Ruby por questões de desempenho 

Typesafe: empresa criada por Odersky para suporte à 

linguagem 

Outros usuários: LinkedIn, EDFT, Novell, The Guardian, 

Xebia, Xerox, FourSquare, Sony, Siemens, Thatcham, 

OPower, GridGain, AppJet, Reaktor, ... 


Sumário 

Introdução 




Conceitos básicos de Scala 




Valores mutáveis e imutáveis 

scala> var v = 10 

v: Int = 10 

scala> v = v + 1 

v: Int = 11 

scala> val c = 10 

c: Int = 10 

scala> c = c + 1 

:6: error: reassignment to val 


Sumário 

Introdução 





Sistema de tipos 




Modelo de tipagem estática com mecanismo de inferência de 

tipos: 

scala> val b = 20 

b: Int = 20 

scala> var c = 30 

c: Int = 30 

scala> c = "abc" 

:6: error: type mismatch; 


Sumário 

Introdução 





Funções: forma básica 




def nomeFunc (par1: Tipo1, par2: Tipo2) : 

TipoRet = { Corpo da Funç~ao } 

O valor retornado pela função é o valor da última expressão 

avaliada dentro do corpo da função 

Funções: atribuição de função anônima 

def nomeFunc = (par1: Tipo1, par2: Tipo2) => 

{ Corpo da Funç~ao } 


Sumário 

Introdução 





Passagem de parâmetros 




Scala possui duas formas de passagem de parâmetros para funções: 

passagem por valor: o argumento na chamada de uma 

função é avaliado e seu valor é copiado para o parâmetro 

dentro da função chamada 

passagem por nome: a expressão passada como argumento 

é copiada sem avaliação para o parâmetro dentro da função 

chamada (a expressão só será avaliada quando for 

referenciada na execução da função chamada) 


Sumário 

Introdução 








Exemplo de passagem de parâmetro por nome 

def fwhile (cond: => Boolean) 

(corpo: => Unit) : Unit = { 

if (cond) { 

corpo 

fwhile(cond)(corpo) 

} } 

[...] 

var i = 5 

fwhile (i > 0) { 

println("Hello: " + i + "!") 

i = i - 1 } 


Sumário 

Introdução 





Funções de alta ordem 




Funções são valores de primeira classe (podem ser passadas 

como parâmetros ou retornadas por funções, atribuídas a variáveis 

e aninhadas a outras funções) 

scala>List(1,2,3) map { x => x + 1 } 

res0: List[Int] = List(2,3,4) 

scala>List("a", "abc", "abcd") 

filter { x => x.length() List(1,2,3) reduceLeft { 

(x,y) => x+y } 

res2: Int = 6 


Sumário 

Introdução 





Classes e objetos 




class Empregado(val nome : String, 

private var salario : Double) 

[...] 

val emp = new Empregado("Jo~ao", 1500) 

println(emp.nome + ", " + emp.salario) 


Sumário 

Introdução 





Casamento de padrões 




Scala não possui o comando de seleção case/switch comum 

em linguagens de programação 

Como alternativa, possui um mecanismo mais poderoso de 

“casamento de padrões” (pattern matching) 

match { } 


Sumário 

Introdução 





Exemplo de casamento de padrões 




def process(msg : Any) = { 

msg match { 

case "hello" => println("hello") 

case x : String => println(x) 

case (a, b) => println("Tupla") 

case 22 => println("22 recebido") 

case x : Int if x < 0 => println(x) 

_ => println("Padrao desconhecido") 

} 

} 


Sumário 

Introdução 








Case classes 

Classes especiais usadas frequentemente nas expressões case 

(permitem o uso de objetos no casamento de padrões sem exigir a 

implementação de uma classe inteira para tal fim) 

abstract class Expr 

case class Var(name: String) 

extends Expr 

case class Number(num: Double) 

extends Expr 


Actors 

Sumário 

Introdução 




Actors 


Futures 

Um actor (ator) é uma entidade de execução distinta (uma 

thread) associada a um mailbox para o recebimento de 

mensagens (mecanismo de comunicação entre dois ou mais 

actors) 

Mecanismo principal para a programação concorrente em 

Scala: permite tornar a programação concorrente mais 

abstrata (se comparada à programação clássica baseada em 

threads) 


Sumário 

Introdução 




Exemplo de criação de Actor 

Actors 


Futures 

import scala.actors._ 

object AtorSimples extends Actor { 

def act() { 

for (i

Sumário 

Introdução 




Outra forma de criar um Actor 

import scala.actors.Actor._ 

val AtorSimples1 = actor { 

for (i

Sumário 

Introdução 




Comunicação entre actors 

Actors 


Futures 

Scala provê primitivas de troca de mensagens para 

comunicação entre actors 

A semântica padrão é envio não-bloqueante e recebimento 

bloqueante (caso não exista mensagem na caixa postal) 

Variante: o método receiveWithin(miliseconds) define um 

tempo limite de espera por uma mensagem 

Exemplo de envio de mensagens 

AtorSimples ! "Ola" 


Sumário 

Introdução 




Comunicação entre actors 

Exemplo de recebimento de mensagens 

Actors 


Futures 

import scala.actors._ 

object AtorSimples2 extends Actor { 

def act() { 

receive { 

case msg => println(msg) 

} } } 

A referência ao objeto enviado em uma mensagem passa a ser 

compartilhada (i.e, o actor que recebe o objeto pode invocar os 

métodos do objeto e alterar seus atributos). Desse modo, para 

evitar os problemas de acesso concorrente, o objeto enviado em 

uma mensagem deve ser thread-safe, ou o programador deve fazer 

uma cópia do objeto antes de enviá-lo. 


Sumário 

Introdução 




Actors 


Futures 

Interoperabilidade com Java e Threads 

Em função da “interoperabilidade com Java”, recursos de 

concorrência da JVM também podem ser usados em Scala 

Exemplo: podemos usar threads ao invés de actors: 

new Thread { 

println("Este bloco eh uma thread!") 

} 

Qualquer classe do pacote java.util.concurrent pode ser 

diretamente usada nos programas Scala 


Sumário 

Introdução 




Actors 


Futures 

Interoperabilidade com Java e Threads 

Outra forma de disparar nova linha de execução 

import scala.concurrent.ops._ 

println("linha de execuç~ao principal") 

spawn { 

println("nova linha de execuç~ao") 

} 

Possível forma de implementação 

def spawn(p: => Unit) { 

val t = new Thread() { 

override def run() = p } 

t.start() 

} 


Futures 

Sumário 

Introdução 




Actors 


Futures 

Future é um mecanismo que permite execução assíncrona de uma 

função, método ou bloco de comandos 

Exemplo de uso de future 

import scala.actors.Futures._ 

val a = future(comput_intensa1()) 

val b = future(comput_intensa2()) 

continuacao_da_computacao(...) 

combinacao_resultados(a(), b()) 

Uma execução que chama um future só é interrompida quando 

tenta utilizar o valor retornado pela future 


Sumário 

Introdução 




Multiplicação de matrizes 





Comparações 

Sumário 

Introdução 







Identificador do Modelo: MacBookPro5,5 

Nome do Processador: Intel Core 2 Duo 

Velocidade do Processador: 2,53 GHz 

Número de Processadores: 1 

Número Total de Núcleos: 2 

Cache de L2: 3 MB 

Memória: 4 GB 


Sumário 

Introdução 







Comparação Java X Scala (concorrente) 


Sumário 

Introdução 







Comparação Java X Scala (concorrente) 


Sumário 

Introdução 







Comparação Scala sequencial X concorrente 



Sumário 

Introdução 







Mistura programação OO e funcional de maneira natural 

Vantagem de interoperação com Java 

Ser flexível e sucinta não necessariamente implica ser simples 

de programar 

Prompt de linha de comando facilita a depuração 

Comunidade ativa 


Contatos 

Sumário 

Introdução 




carlosbazilio@puro.uff.br 

silvana@dcc.ufrj.br 





Sumário 

Introdução 




Referências bibliográficas 




1 Concurrent Programming — Principles and Practice, 

Andrews, Addison-Wesley, 1991 

2 Programming Language Pragmatics, M. L. Scott, 

Morgan-Kaufmann, ed. 2, 2006 

3 Programming in Scala, M. Odersky, L. Spoon and B. Venners, 

Artima, 2008 

4 Scala By Example, M. Odersky, Programming Methods 

Laboratory, EPFL, Switzerland, 2011 

5 http://www.scala-lang.org (site oficial da linguagem Scala)

Programação Concorrente em Scala - DCC - UFRJ

Create successful ePaper yourself

Delete template?

Save as template?