Capítulo 2

Processos & Threads

 processos concorrentes

Conceito de processo
Estruturamos os sistemas complexos como sequência de
como conjuntos de actividades mais acções.
simples, cada actividade é
representada como um processo
sequencial. Modelar processos
como máquinas de
Desenhar software concorrente pode estados finitos.
ser complexo e permeável a erros.
Uma abordagem rigorosa é essencial.

Processos implementados
como threads em Java.
processos e threads

Conceitos: processos - Unidades de execução

sequencial.

Modelos: processos de estados finitos (FSP)

Modelar processos como sequências de
acções.
sistemas de transições etiquetadas (LTS)
Analisar, exibir e animar comportamento.

Implementação: Threads Java

2.1 Modelar Processos

Os modelos são descritos usando máquinas de

estados, designadas por Sistemas de Transições
Etiquetdas LTS. Estes são descritos textualmente
por processos de estados finitos (FSP) e exibidos e
analisados pelo programa LTSA.

♦ LTS - forma gráfica

♦ FSP - forma algébrica
modelar processos

Um processo é uma execução de um programa sequencial,

que é modelado como uma máquina de estados finitos, a
qual transita de estado para estado pela execução de uma
sequência de acções atómicas.
on

um comutador
0 1 de luz LTS

off
Uma sequência de
onoffonoffonoff ………. acções ou traço

Podem os modelos de estados finitos produzir traços infinitos?

FSP - prefixação de acções

Se x é uma acção e P um processo então (x-> P)

descreve um processo que, inicialmente, executa x e
então se comporta exactamente como descrito por P.

ONESHOT = (once -> STOP). Máquina de estados

once ONESHOT.
(terminating process)
0 1

Convenção: As ACÇÕES são iniciadas por letras minúsculas

As PROCESSOS são iniciados por letras
maiúsculas.
FSP - prefixação de acções & recursão

Comportamento repetitivo utiliza a recursão:

on
SWITCH = OFF,
OFF = (on -> ON),
ON = (off-> OFF). 0 1

Substituindo ... off

SWITCH = OFF,
OFF = (on ->(off->OFF)).
Novamente ...
SWITCH = (on->off->SWITCH).
Animação usando o LTSA

O programa LTSA pode ser

usado para produzir um traço.

As acções com o “tick” são

elígiveis para a selecção.
No LTS, a última acção é
evidenciada a vermelho.
on

0 1

off
FSP - prefixação de acções

FSP modela um semáforo :

TRAFFICLIGHT = (red->orange->green->orange
-> TRAFFICLIGHT).

LTS gerado usando o LTSA:

red orange green

0 1 2 3

Traço: orange

redorangegreenorangeredorangegreen …
FSP - selecção

Se x e y são acções então (x-> P | y-> Q) descreve um

processo o qual, inicialmente, executa x ou y. Após a
primeira acção ter ocorrido, o comportamento
subsequente é descrito por P se a primeira acção
executada foi x e Q se a primeira acção executada foi y.

Quem ou o que faz a selecção?

Existe diferença entre as acções de input e
output?
FSP - selecção (exemplo)

FSP modela uma máquina de servir bebidas :

DRINKS = (red->coffee->DRINKS
|blue->tea->DRINKS).
blue

LTS é gerado usando o LTSA:

red

0 1 2

Traços possíveis? coffee

tea
Selecção não determinista

(x-> P | x -> Q) descreve um processo que executa x e

então comporta-se como P ou Q.

COIN = (toss->HEADS|toss->TAILS),
HEADS= (heads->COIN), toss

TAILS= (tails->COIN).
toss

Lançamento da moeda.
0 1 2

Traços possíveis?
heads

tails
Modelar a falha

Como modelar um canal de comunicação unreliable o qual

aceita acções in e se uma falha ocorre, não produz um
output; caso contrário, executa uma acção out?

Usando não determinismo ... in

0 1
in

CHAN = (in->CHAN
|in->out->CHAN out
).
FSP - processos indexados e acções

Um buffer com um slot que recebe um valor entre 0 e 3

e então retorna esse mesmo valor:
BUFF = (in[i:0..3]->out[i]-> BUFF).
equivalente a
BUFF = (in[0]->out[0]->BUFF Acções indexadas
|in[1]->out[1]->BUFF geram etiquetas
da forma
|in[2]->out[2]->BUFF
action.index
|in[3]->out[3]->BUFF
).
ou usando um processo parametrizado com um valor
default:
BUFF(N=3) = (in[i:0..N]->out[i]-> BUFF).
 FSP - processos indexados e acções
in.1.1
Definições de processos in.1.0
locais indexados são in.0.1
equivalentes a definições
de processos para cada in.0.0

valor indexado.
Expressões indexadas para 0 1 2 3
modelar cálculo:

const N = 1 out.0

range T = 0..N out.1

range R = 0..2*N
out.2

SUM = (in[a:T][b:T]->TOTAL[a+b]),
TOTAL[s:R] = (out[s]->SUM).
FSP - acções guardadas

O processo (when B x -> P | y -> Q) significa que

quando a guarda B é verdadeira então as acções x e y
são elígiveis para a escolha; caso contrário, se B é
falso então a acção x não pode ser escolhida.

COUNT (N=3) = COUNT[0],

COUNT[i:0..N] = (when(i<N) inc->COUNT[i+1]
|when(i>0) dec->COUNT[i-1]
).
inc inc inc

0 1 2 3
dec dec dec
FSP - acções guardadas
Um temporizador decrescente o qual emite um som após
N ticks, ou pode ser parado.
COUNTDOWN (N=3) = (start->COUNTDOWN[N]),
COUNTDOWN[i:0..N] =
(when(i>0) tick->COUNTDOWN[i-1]
|when(i==0)beep->STOP
stop
|stop->STOP
). stop

stop
stop
start tick tick tick beep

0 1 2 3 4 5
FSP - acções guardadas

A que é que o seguinte processo FSP é equivalente?

const False = 0
P = (when (False) doanything->P).

Resposta:
STOP
FSP - alfabetos de processos

O alfabeto de um processo é um conjunto de acções no

qual se pode envolver.

Os alfabetos de processo Process:

são implicitamente COUNTDOWN
definidos por acções na Alphabet:
definição do processo. { beep,
start,
O alfabeto de um processo stop,
pode ser exibido usando tick
uma janela de alfabeto no }
LTSA.
FSP - extensão de um alfabeto de processo

A extensão de um alfabeto pode ser usada para estender

implicitamente o alfabeto de um processo:

WRITER = (write[1]->write[3]->WRITER)
+{write[0..3]}.
O alfabeto de WRITER é o conjunto {write[0..3]}
2.2 Implementar processos

Modelar processos como

máquinas de estados
finitos usando FSP/LTS.

Implementar threads
em Java.

Nota: para evitar confusão, usamos o termo processo quando nos

referimos a modelos, e thread quando nos referimos à implementação
em Java.