05 - Sincronização de Threads - I

UNIVERSIDADE ESTADUAL DO SUDOESTE DA BAHIA
CURSO DE CIÊNCIA DA COMPUTAÇÃO
PROGRAMAÇÃO CONCORRENTE – 2015.1
Fábio M. Pereira
(fabio.mpereira@uesb.edu.br)

Roteiro
• Sincronizando um Método
• Atributos Independentes em Classes Sincronizadas
• Usando Condições em Código Sincronizado
• Sincronizando um Bloco de Código com um Bloqueio
• Sincronizando Acesso a Dados com Bloqueios de
Leitura/Escrita
• Modificando o Equilíbrio entre Bloqueios
• Usando Múltiplas Condições em um Bloqueio

Introdução
• Uma das situações mais comuns em programação
concorrente ocorre quando mais de uma thread de execução
compartilha um recurso
• Em um aplicativo concorrente, é normal que várias threads
leiam ou escrevam os mesmos dados ou tenham acesso ao
mesmo arquivo ou conexão com o banco de dados
• Esses recursos compartilhados podem provocar situações de
erro ou inconsistência de dados e temos que implementar
mecanismos para evitar esses erros
• A solução para estes problemas é fornecida com o conceito
de seção crítica
• A seção crítica é um bloco de código que acessa um recurso
compartilhado e não pode ser executado por mais de uma
thread, ao mesmo tempo.

Introdução
• Para ajudar os programadores a implementar seções
críticas, Java (e quase todas as linguagens de
programação) oferece mecanismos de sincronização
• Quando uma thread quer acesso a uma seção crítica, ela
usa um desses mecanismos de sincronização para saber
se há alguma outra thread em execução na seção crítica
• Se não há, a thread entra na seção crítica, caso contrário,
a thread é suspensa pelo mecanismo de sincronização
até que a thread que está executando a seção crítica
termine
• Quando mais de uma thread está aguardando uma outra
thread terminar a execução de uma seção crítica, a JVM
escolhe uma delas, e o restante esperar pela sua vez

Introdução
• Esta aula apresenta uma série de exemplos que mostram
como usar os dois mecanismos de sincronização básicos
oferecidos pela linguagem Java:
– A palavra-chave synchronized
– A interface Lock e suas implementações

Sincronizando um Método
• Veremos como usar um dos métodos mais básicos para a
sincronização em Java, isto é, o uso da palavra-chave
synchronized para controlar o acesso simultâneo a um
método
• Apenas uma thread de execução irá acessar um dos métodos
de um objeto declarado com a palavra-chave synchronized
• Se outra thread tenta acessar qualquer método declarado
com a palavra-chave synchronized do mesmo objeto, ele
será suspenso até que a primeira thread termine a execução
do método
• Em outras palavras, cada método declarado com a palavra-
chave synchronized é uma seção crítica e Java só permite a
execução de uma das seções críticas de um objeto

• Os métodos estáticos possuem um comportamento
diferente: apenas uma thread de execução irá acessar um
dos métodos estáticos declarados com a palavra-chave
synchronized, mas outra thread pode acessar outros
métodos não-estáticos de um objeto dessa classe
• Temos que ter muito cuidado com este ponto, porque
duas threads podem acessar dois métodos
synchronized diferentes se um é estático e o outro não
é
• Se ambos os métodos alterar os mesmos dados,
podemos ter erros de inconsistência de dados

• Para aprender este conceito, vamos implementar um
exemplo com duas threads acessando um objeto comum
• Vamos ter uma conta bancária e duas threads: uma que
transfere dinheiro para a conta e outra que retira
dinheiro da conta
– Sem métodos de sincronização, poderíamos ter resultados
incorretos
– Mecanismos de sincronização garantem que o saldo final da
conta esteja correto

Programa Exemplo
1. Crie uma classe chamada Account que irá modelar nossa
conta bancária. Ela possui um único atributo double,
chamado balance (saldo).
public class Account {
private double balance;
2. Implemente os métodos setBalance() e getBalance()
para escrever e ler o valor do atributo.
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}

Programa Exemplo
3. Implementar um método chamado addAmount() que aumenta
o valor do saldo em uma certa quantidade que é passada para o
método. Apenas uma thread deve alterar o valor do saldo,
portanto, use a palavra-chave synchronized para converter
este método em uma seção crítica.
public synchronized void addAmount(double
amount) {
double tmp=balance;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
tmp+=amount;
balance=tmp;
}

Programa Exemplo
4. Implementar um método chamado subtractAmount() que
diminui o valor do saldo em uma certa quantidade que é passada
para o método. Apenas uma thread deve alterar o valor do saldo,
portanto, use a palavra-chave synchronized para converter
este método em uma seção crítica.
public synchronized void subtractAmount(double
amount) {
double tmp=balance;
try {
Thread.sleep(10);
}
tmp-=amount;
balance=tmp;
}

Programa Exemplo
5. Implemente uma classe que simula um caixa eletrônico
(ATM). Ele vai usar o método subtractAmount() para
diminuir o saldo de uma conta. Esta classe deve
implementar a interface Runnable a ser executada
como uma thread.
public class Bank implements Runnable {
6. Adicione um objeto Account a esta classe. Implemente
o construtor da classe que inicializa o objeto Account.
private Account account;
public Bank(Account account) {
this.account=account;
}

Programa Exemplo
7. Implemente o método run(). Ele faz 100 chamadas ao
método subtractAmount() de uma conta para reduzir o
saldo.
@Override
public void run() {
for (int i=0; i<100; i++){
account.subtractAmount(1000);
}
}
8. Implementar uma classe que simula uma empresa e utiliza o
método addAmount() da classe Account para incrementar
o saldo da conta. Esta classe deve implementar a interface
Runnable a ser executada como uma thread.
public class Company implements Runnable {

Programa Exemplo
9. Adicione um objeto Account a esta classe. Implemente o
construtor da classe que inicializa o objeto account.
private Account account;
public Company(Account account) {
this.account=account;
}
10. Implemente o método run(). Ele faz 100 chamadas ao
método addAmount() de uma conta para incrementar o
saldo.
@Override
public void run() {
for (int i=0; i<100; i++){
account.addAmount(1000);
}
}

Programa Exemplo
11. Implementar a classe principal do aplicativo criando
uma classe principal que contém o método main().
public class Main {
public static void main(String[] args) {
12. Crie um objeto Account e inicialize o seu saldo com
1000.
Account account=new Account();
account.setBalance(1000);
13. Crie um objeto Company e uma Thread para executá-lo.
Company company=new Company(account);
Thread companyThread=new Thread(company);

Programa Exemplo
14. Crie um objeto Bank e uma Thread para executá-lo.
Bank bank=new Bank(account);
Thread bankThread=new Thread(bank);
15. Escreva o saldo inicial no console. Inicie as threads.
System.out.printf("Conta : Saldo Inicial:
%fn",account.getBalance());
companyThread.start();
bankThread.start();

Programa Exemplo
16. Aguarde a finalização das duas threads usando o
método join() e imprima no console o saldo final da
conta.
try {
companyThread.join();
bankThread.join();
System.out.printf("Conta : Saldo Final:
%fn",account.getBalance());
}

Funcionamento
• Neste exemplo, desenvolvemos um aplicativo que
incrementa e diminui o saldo de uma classe que simula
uma conta bancária
• O programa faz 100 chamadas ao método addAmount()
que incrementa o saldo em 1.000 em cada chamada e
100 chamadas ao método subtractAmount() que
diminui o saldo em 1.000 em cada chamada
• Devemos esperar que os saldos inicial e final sejam iguais

Funcionamento
• Tentamos forçar uma situação de erro usando uma
variável chamada tmp para armazenar o valor do saldo da
conta, de modo que lemos o saldo da conta,
incrementamos o valor da variável temporária e então
estabelecemos o valor do saldo da conta novamente
• Além disso, introduzimos um pouco de atraso, utilizando
o método sleep() da classe Thread para colocar a
thread que está executando o método para dormir por 10
milissegundos, portanto, se outra thread executar esse
método, ela pode modificar o equilíbrio da conta,
provocando um erro
• É o mecanismo da palavra-chave synchronized que
evita esses erros

Funcionamento
• Se quisermos ver os problemas de acesso concorrente
aos dados compartilhados, basta apagarmos a palavra-
chave synchronized dos métodos addAmount() e
subtractAmount() e executarmos o programa
• Sem a palavra-chave synchronized, enquanto uma
thread está dormindo após a leitura do valor do saldo da
conta, outro método irá ler o saldo da conta, então
ambos os métodos irão modificar o mesmo saldo e uma
das operações não será refletida no resultado final

Funcionamento
• Como podemos ver na captura de tela seguinte, podemos
obter resultados inconsistentes:

Funcionamento
• Se executarmos o programa várias vezes, obteremos
resultados diferentes
• A ordem de execução das threads não é garantida pela
JVM, então, toda vez que executarmos o programa, as
threads vão ler e modificar o saldo da conta em uma
ordem diferente, de modo que o resultado final será
diferente
• Agora, adicione a palavra-chave synchronized como
vimos antes e execute o programa novamente

Funcionamento
• Como podemos ver na imagem seguinte, agora obtemos
o resultado esperado
• Se você executar o programa várias vezes, iremos obter o
mesmo resultado
• Veja a imagem a seguir:

Funcionamento
• Usando a palavra-chave synchronized, nós garantimos
o acesso correto para os dados compartilhados em
aplicações concorrentes
• Como mencionado na introdução, apenas uma thread
pode acessar os métodos de um objeto que use a
palavra-chave synchronized na sua declaração
• Se uma thread (A) está executando um método
synchronized e outra thread (B), quer executar outro
métodos synchronized do mesmo objeto, ela vai ser
bloqueada até que a thread (A) termine
• Mas se threadB tem acesso a diferentes objetos da
mesma classe, nenhum deles será bloqueado

• A palavra-chave synchronized penaliza o desempenho da
aplicação, portanto, devemos usá-la apenas sobre os métodos
que modificam os dados compartilhados em um ambiente
concorrente
• Se temos várias threads que chamam um método
synchronized, apenas um irá executá-los em um momento
enquanto os outros vão estar à espera
• Se essa operação não utilizar a palavra-chave synchronized,
todos as threads podem executar a operação, ao mesmo
tempo, reduzindo o tempo total de execução
• Se sabemos que um método não será chamado por mais de
uma thread, não devemos usar a palavra-chave
synchronized

• Podemos usar chamadas recursivas com métodos
synchronized
• À medida que a thread tem acesso aos métodos
synchronized de um objeto, podemos chamar outros
métodos synchronized desse objeto, incluindo o
método que está sendo executado, ela não terá que
conseguir acesso aos métodos synchronized
novamente

• Podemos usar a palavra-chave synchronized para
proteger o acesso a um bloco de código em vez de um
método inteiro
• Devemos utilizar a palavra-chave synchronized desta
forma para proteger o acesso aos dados compartilhados,
deixando o restante das operações de fora do bloco,
obtendo-se um melhor desempenho da aplicação
synchronized (this) {
// Java code
}

• O objetivo é fazer com que a seção crítica (o bloco de código
que só pode ser acessado por uma thread por vez) seja tão
curta quanto possível
• Temos usado a palavra-chave synchronized para proteger o
acesso à instrução que atualiza o número de pessoas no
prédio, deixando de fora as longas operações deste bloco que
não usam os dados compartilhados
• Quando usamos a palavra-chave synchronized dessa
maneira, devemos passar uma referência de objeto como um
parâmetro
• Apenas uma thread pode acessar o código synchronized
(blocos ou métodos) desse objeto
• Normalmente, vamos usar a palavra-chave this para
referenciar o objeto que está executando o método

Atributos Independentes em Classes
Sincronizadas
• Quando usamos a palavra-chave synchronized para
proteger um bloco de código, devemos passar uma referência
de objeto como um parâmetro
• Normalmente, iremos usar a palavra-chave this para
referenciar o objeto que executa o método, mas podemos
usar outras referências de objeto
• Normalmente, esses objetos serão criados exclusivamente
com esta finalidade
• Por exemplo, se temos dois atributos independentes em uma
classe compartilhada por várias threads, devemos sincronizar
o acesso a cada variável, mas não há nenhum problema se
houver uma thread acessando um dos atributos e outra
thread acessando o outro, ao mesmo tempo

Atributos Independentes em Classes
Sincronizadas
• Neste exemplo, iremos aprender como resolver esta
situação com um programa que simula um cinema com
duas telas e duas bilheterias
• Quando uma bilheteria vende bilhetes, eles são para um
dos dois filmes, mas não para ambos, então o número de
assentos livres em cada sala são atributos independentes

Programa Exemplo
1. Crie uma classe chamada Cinema e adicione dois
atributos long chamados vacanciesCinema1 e
vacanciesCinema2.
public class Cinema {
private long vacanciesCinema1;
private long vacanciesCinema2;
2. Adicione à classe Cinema dois atributos Object
adicionais chamados controlCinema1 e
controlCinema2.
private final Object controlCinema1,
controlCinema2;

Programa Exemplo
3. Implemente o construtor da classe Cinema que inicializa
todos os atributos da classe.
public Cinema(){
controlCinema1=new Object();
controlCinema2=new Object();
vacanciesCinema1=20;
vacanciesCinema2=20;
}

Programa Exemplo
4. Implemente o método sellTickets1() que é chamado
quando alguns bilhetes para o primeiro cinema são
vendidos. Ele utiliza o objeto controlCinema1 para
controlar o acesso ao bloco de código synchronized.
public boolean sellTickets1 (int number) {
synchronized (controlCinema1) {
if (number<vacanciesCinema1) {
vacanciesCinema1-=number;
return true;
} else {
return false;
}
}
}

Programa Exemplo
5. Implemente o método sellTickets2() que é chamado
quando alguns bilhetes para o segundo cinema são
vendidos. Ele utiliza o objeto controlCinema2 para
controlar o acesso ao bloco de código synchronized.
public boolean sellTickets2 (int number) {
if (number<vacanciesCinema2) {
vacanciesCinema2-=number;
return true;
} else {
return false;
}
}
}

Programa Exemplo
6. Implemente o método returnTickets1() que é
chamado quando alguns bilhetes para o primeiro
cinema são devolvidos. Ele utiliza o objeto
controlCinema1 para controlar o acesso ao bloco de
código synchronized.
public boolean returnTickets1 (int number) {
vacanciesCinema1+=number;
return true;
}
}

Programa Exemplo
7. Implemente o método returnTickets2() que é
chamado quando alguns bilhetes para o segundo
cinema são devolvidos. Ele utiliza o objeto
controlCinema2 para controlar o acesso ao bloco de
código synchronized.
public boolean returnTickets2 (int number) {
vacanciesCinema2+=number;
return true;
}
}

Programa Exemplo
8. Implemente outros dois métodos que retornam o
número de vagas em cada cinema.
public long getVacanciesCinema1() {
return vacanciesCinema1;
}
public long getVacanciesCinema2() {
return vacanciesCinema2;
}
9. Implemente a classe TicketOffice1 e especifique que
ela implementa a interface Runnable.
public class TicketOffice1
implements Runnable {

Programa Exemplo
10. Declare um objeto Cinema e implemente o construtor
da classe que inicializa este objeto.
private Cinema cinema;
public TicketOffice1 (Cinema cinema) {
this.cinema=cinema;
}

Programa Exemplo
11. Implemente o método run() que simula algumas
operações sobre os dois cinemas.
@Override
public void run() {
cinema.sellTickets1(3);
cinema.returnTickets1(3);
}

Programa Exemplo
12. Implemente a classe TicketOffice2 e especifique que
ela implementa a interface Runnable.
public class TicketOffice2
implements Runnable {
13. Declare um objeto Cinema e implemente o construtor
da classe que inicializa este objeto.
private Cinema cinema;
public TicketOffice2 (Cinema cinema) {
this.cinema=cinema;
}

Programa Exemplo
14. Implemente o método run() que simula algumas
operações sobre os dois cinemas.
@Override
public void run() {
cinema.returnTickets2(2);
}

Programa Exemplo
15. Implemente a classe principal do exemplo através da criação
de uma classe principal e adicionando-lhe o método main().
public class Main {
16. Declare e crie um objeto Cinema.
Cinema cinema=new Cinema();
17. Crie um objeto TicketOffice1 e a Thread para executá-lo.
TicketOffice1 ticketOffice1=new
TicketOffice1(cinema);
Thread thread1=new
Thread(ticketOffice1,
"TicketOffice1");

Programa Exemplo
18. Crie um objeto TicketOffice2 e a Thread para executá-lo.
TicketOffice2 ticketOffice2=new
TicketOffice2(cinema);
Thread thread2=new
Thread(ticketOffice2,
"TicketOffice2");
19. Inicie ambas as threads.
thread1.start();
thread2.start();

Programa Exemplo
20. Aguarde até que as threads sejam finalizadas.
try {
thread1.join();
thread2.join();
}
21. Escreva no console as vagas disponíveis nos dois
cinemas.
System.out.printf("Sala 1 Vagas: %dn",
cinema.getVacanciesCinema1());
System.out.printf("Sala 2 Vagas: %dn",
cinema.getVacanciesCinema2());

Funcionamento
• Quando usamos a palavra-chave synchronized para
proteger um bloco de código, podemos usar um objeto
como um parâmetro
• A JVM garante que apenas uma thread pode ter acesso a
todos os blocos de código protegidas com esse objeto
(note que sempre falamos sobre objetos, e não sobre
classes)

Funcionamento
• Neste exemplo, temos um objeto que controla o acesso
ao atributo vacanciesCinema1, portanto, apenas uma
thread pode modificar este atributo de cada vez, e outro
objeto que controla o acesso ao atributo
vacanciesCinema2, portanto, apenas uma thread pode
modificar este atributo de cada vez
• Mas podem haver duas threads em execução
concorrente, uma modificando o atributo
vacancesCinema1 e a outra modificando o atributo
vacanciesCinema2

Funcionamento
• Quando executarmos esse exemplo, podemos ver como o
resultado final é sempre o número esperado de vagas
para cada cinema
• Na captura de tela seguinte, podemos ver os resultados
de uma execução da aplicação:

Usando Condições em Código
Sincronizado
• Um problema clássico na programação concorrente é o
problema do produtor-consumidor
• Temos um buffer de dados, um ou mais produtores de
dados que os salvam no buffer e um ou mais
consumidores de dados que leem a partir do buffer
• À medida que o buffer é uma estrutura de dados
compartilhada, temos que controlar o acesso a ela
através de um mecanismo de sincronização como o da
palavra-chave synchronized, mas que tenha mais
limitações
• Um produtor não pode salvar dados no buffer se ele está
cheio e que o consumidor não pode retirar dados do
buffer se ele está vazio

Sincronizado
• Para esses tipos de situações, Java fornece os métodos
wait(), notify() e notifyAll() implementado na
classe Object
• Uma thread pode chamar o método wait() dentro de um
bloco de código synchronized
– Se ela chamar o método wait() do lado de fora de um bloco de
código synchronized, a JVM lança uma exceção
IllegalMonitorStateException
• Quando a thread chama o método wait(), a JVM coloca a
thread para dormir e libera o objeto que controla o bloco de
código synchronized que está em execução e permite que
as outras threads executem outros blocos de código
synchronized protegidos por esse objeto
• Para acordar a thread, devemos chamar o método notify()
ou notifyAll() dentro de um bloco de código protegido
pelo mesmo objeto

Sincronizado
• Neste exemplo, vamos aprender como implementar o
problema do produtor-consumidor, utilizando a palavra-
chave synchronized e os métodos wait(), notify(),
e notifyAll()

Programa Exemplo
1. Crie uma classe chamada EventStorage. Ela tem dois
atributos: um atributo int chamado maxSize e um
atributo LinkedList <Date> chamado storage.
public class EventStorage {
private int maxSize;
private LinkedList<Date> storage;
2. Implemente o construtor da classe que inicializa os seus
atributos.
public EventStorage(){
maxSize=10;
storage=new LinkedList<>();
}

Programa Exemplo
3. Implemente o método synchronized set() para armazenar um
evento. Primeiro, verifique se o buffer está cheio ou não. Se ele
estiver cheio, chame o método wait() até que tenha espaço
vazio. No final do método, chamamos o método notifyAll()
para acordar todos as threads que estão dormindo no método
wait().
public synchronized void set(){
while (storage.size()==maxSize){
try {
wait();
}
}
storage.offer(new Date());
System.out.printf("Set: %dn",storage.size());
notifyAll();
}

Programa Exemplo
4. Implementar o método synchronized get() para obter um
evento do armazenamento. Primeiro, verifique se o buffer tem
eventos ou não. Se ele não tem eventos, chame o método wait()
até que tenha algum evento. No final do método, chamamos o
método notifyAll() para acordar todas as threads que estão
dormindo no método wait().
public synchronized void get(){
while (storage.size()==0){
try {
wait();
}
}
System.out.printf("Get: %d: %sn",storage.size(),
((LinkedList<?>)storage).poll());
notifyAll();
}

Programa Exemplo
5. Crie uma classe chamada Producer e especifique que
ela implementa a interface Runnable. Ela irá
implementar o produtor do exemplo.
public class Producer implements Runnable {
6. Declare um objeto EventStorage e implemente o
construtor da classe, que inicializa este objeto.
private EventStorage storage;
public Producer(EventStorage storage){
this.storage=storage;
}

Programa Exemplo
7. Implemente o método run() que chama 100 vezes o
método set() do objeto EventStorage.
@Override
public void run() {
for (int i=0; i<100; i++){
storage.set();
}
}
8. Crie uma classe chamada Consumer e especifique que
ela implementa a interface Runnable. Ela irá
implementar o consumidor para o exemplo.
public class Consumer implements Runnable {

Programa Exemplo
9. Declare um objeto EventStorage e implemente o
construtor da classe que inicializa este objeto.
private EventStorage storage;
public Consumer(EventStorage storage){
this.storage=storage;
}
10. Implemente o método run(). Ele chama 100 vezes o
método get() do objeto EventStorage.
@Override
public void run() {
for (int i=0; i<100; i++){
storage.get();
}
}

Programa Exemplo
11. Crie a classe principal para o exemplo e adicione o
método main().
public class Main {
12. Crie um objeto EventStorage.
EventStorage storage=new EventStorage();
13. Crie um objeto Producer e a Thread para executá-lo.
Producer producer=new Producer(storage);
Thread thread1=new Thread(producer);

Programa Exemplo
14. Crie um objeto Consumer e a Thread para executá-lo.
Consumer consumer=new Consumer(storage);
Thread thread2=new Thread(consumer);
15. Inicie ambas as threads.
thread2.start();
thread1.start();

Funcionamento
• A chave para este exemplo são os métodos set() e
get() da classe EventStorage
• Primeiro, o método set() verifica se há espaço livre no
atributo de armazenamento
– Se ele está cheio, ele chama o método wait() para aguardar
espaço livre
• Quando a outra thread chama o método notifyAll(),
a thread acorda e verifica a condição novamente
– O método notifyAll() não garante que a thread vai acordar
• Este processo é repetido até que haja espaço livre no
armazenamento, então ela pode gerar um novo evento e
armazená-lo

Funcionamento
• O comportamento do método get() é semelhante,
primeiro, ele verifica se há eventos no armazenamento
– Se a classe EventStorage está vazia, ele chama o método
wait() para aguardar eventos
– Quando a outra thread chama o método notifyAll(), a thread
acorda e verifica a condição novamente até que existam alguns
eventos no armazenamento
• Temos que manter a verificação das condições e chamar
o método wait() em um laço while, não podemos
continuar até que a condição seja verdadeira
• Se executarmos esse exemplo, vamos ver como o
produtor e o consumidor estão criando e obtendo os
eventos, mas o armazenamento nunca possui mais do de
10 eventos

Sincronizando um Bloco de Código com
um Bloqueio
• Java fornece um outro mecanismo para a sincronização
de blocos de código
• É um mecanismo mais poderoso e flexível do que a
palavra-chave synchronized
• Ele é baseado na interface Lock e classes que a
implementam (como ReentrantLock)

um Bloqueio
• Este mecanismo apresenta algumas vantagens, que são
as seguintes:
– Ele permite a estruturação de blocos sincronizados de uma
maneira mais flexível. Com a palavra-chave synchronized,
temos que obter e liberar o controle sobre um bloco
sincronizado de código de uma forma estruturada. As interfaces
Lock permitem que obtenhamos estruturas mais complexas
para implementar a seção crítica.

um Bloqueio
• Vantagens (continuação):
– As interfaces Lock fornecem funcionalidades adicionais sobre a
palavra-chave synchronized. Uma das novas funcionalidades é
implementada pelo método tryLock(). Este método tenta
obter o controle do bloqueio e se não pode, porque ele está
sendo usado por outra thread, ele retorna o bloqueio. Com a
palavra-chave synchronized, quando uma thread (A) tenta
executar um bloco de código sincronizado, se houver outra
thread (B) executando-o, a thread (A) é suspensa até que a
thread (B) termine a execução do bloco sincronizado. Com
bloqueios, podemos executar o método tryLock(). Esse
método retorna um valor booleano que indica se há outra
thread executando o código protegido por esse bloqueio.

um Bloqueio
• Vantagens (continuação):
– As interfaces Lock permitem uma separação das operações de
leitura e gravação que possuem vários leitores e apenas um
modificador.
– As interfaces Lock oferecer um melhor desempenho do que a
palavra-chave synchronized.
• Neste exemplo, vamos aprender como usar bloqueios
para sincronizar um bloco de código e criar uma seção
crítica usando a interface Lock e a classe ReentrantLock
que a implementa, implementando um programa que
simula uma fila de impressão

Programa Exemplo
1. Crie uma classe chamada PrintQueue que irá
implementar a fila de impressão.
public class PrintQueue {
2. Declare um objeto Lock e o inicialize com um novo
objeto da classe ReentrantLock.
private final Lock queueLock=new
ReentrantLock();
3. Implemente o método printJob(). Ele irá receber um
Object como parâmetro e não irá retornar nenhum
valor.
public void printJob(Object document){

Programa Exemplo
4. Dentro do método printJob() obtenha o controle do
objeto Lock chamando o método lock().
lock() method.
queueLock.lock();
5. Então, inclua o código a seguir para simular a impressão de
um documento:
try {
Long duration=(long)(Math.random()*10000);
System.out.println(Thread.currentThread()
.getName()+ ":Fila de Impressão:
Imprimindo um trabalho durante "+
(duration/1000)+" segundos");
Thread.sleep(duration);
}

Programa Exemplo
6. Finalmente, libere o controle do objeto Lock com o método
unlock().
finally {
queueLock.unlock();
}
7. Crie uma classe chamada Job e especifique que ela
implementa a interface Runnable.
public class Job implements Runnable {
8. Declare um objeto da classe PrintQueue e implemente o
construtor da classe que inicializa esse objeto.
private PrintQueue printQueue;
public Job(PrintQueue printQueue){
this.printQueue=printQueue;
}

Programa Exemplo
9. Implemente o método run(). Ele usa o objeto
PrintQueue para enviar um trabalho para a impressora.
@Override
public void run() {
System.out.printf("%s: Imprimindo um
documenton", Thread.currentThread()
.getName());
printQueue.printJob(new Object());
System.out.printf("%s: O documento foi
impresson",Thread.currentThread()
.getName());
}
10. Crie a classe principal da aplicação e adicione o método
main() a ela.
public class Main {
public static void main (String args[]){

Programa Exemplo
11. Crie um objeto compartilhado PrintQueue.
PrintQueue printQueue=new PrintQueue();
12. Cria 10 objetos Job e 10 threads pra executá-los.
Thread thread[]=new Thread[10];
for (int i=0; i<10; i++){
thread[i]=new Thread(new Job(printQueue),
"Thread "+ i);
}
13. Inicie as 10 threads.
for (int i=0; i<10; i++){
thread[i].start();
}

Funcionamento
• Na captura de tela seguinte, podemos ver uma parte da
saída de uma execução, deste exemplo:

Funcionamento
• A chave para o exemplo é o método printJob() da classe
PrintQueue
• Quando queremos implementar uma seção crítica usando
bloqueios e garantir que apenas uma thread de execução
execute um bloco de código, temos que criar um objeto
ReentrantLock
• No início da seção crítica, temos de começar o controle do
bloqueio utilizando o método lock()
• Quando uma thread (A) chama este método, se não houver
outra thread com o controle do bloqueio, o método permite
que a thread (A) controle o bloqueio e retorna imediatamente
para permitir a execução da seção crítica por esta thread
• Caso contrário, se há uma outra thread (B) executando a
seção crítica controlada por este bloqueio, o método lock()
coloca a thread (A) para dormir até que a thread (B) termine a
execução da seção crítica

Funcionamento
• No final da seção crítica, temos de usar o método
unlock() para liberar o controle do bloqueio e permitir
que as outras threads executem esta seção crítica
• Se não chamarmos o método unlock() no final da seção
crítica, as outras threads que estão aguardando por esse
bloco ficarão esperando para sempre, causando uma
situação de impasse (deadlock)
• Se usarmos blocos try-catch em uma seção crítica, não
podemos esquecer de colocar o comando que contém o
método unlock() dentro da seção finally

um Bloqueio
• A interface Lock (e a classe ReentrantLock) inclui um
outro método para obter o controle do bloqueio, é o
método tryLock()
• A maior diferença com o método lock() é que neste
método, se a thread que o usa não pode obter o controle
da interface Lock, retorna imediatamente e não coloca a
thread para dormir
• Este método retorna um valor booleano, true se a
thread recebe o controle do bloqueio, e false se não
• Leve em consideração que é responsabilidade do
programador ter em conta o resultado deste método e
agir em conformidade

um Bloqueio
• Se o método retorna o valor false, espera-se que o
programa não execute a seção crítica
• Se isso acontecer, provavelmente teremos resultados
errados na aplicação

um Bloqueio
• A classe ReentrantLock também permite o uso de
chamadas recursivas
• Quando uma thread tem o controle de um bloqueio e faz
uma chamada recursiva, continua com o controle do
bloqueio, de modo que a chamada ao método lock()
retornará imediatamente e a thread vai continuar com a
execução da chamada recursiva
• Além disso, também pode chamar outros métodos

um Bloqueio
• Devemos ter muito cuidado com o uso de bloqueios para
evitar impasses (deadlocks)
• Esta situação ocorre quando duas ou mais threads são
bloqueadas à espera de bloqueios que nunca vão ser
desbloqueados
• Por exemplo, uma thread (A) bloqueia um Lock (X) e uma
thread (B) bloqueia um Lock (Y)
• Se agora, a thread (A) tenta bloquear um Lock (Y) e a thread
(B) simultaneamente tenta bloquear um Lock (X), ambas as
threads serão bloqueadas indefinidamente, porque elas estão
à espera de bloqueios que nunca vão ser liberados
• Note-se que o problema ocorre, porque ambas as threads
tentam obter os bloqueios na ordem oposta

Sincronizando Acesso a Dados com
Bloqueios de Leitura/Escrita
• Uma das melhorias mais significativas oferecidos por
bloqueios é a interface ReadWriteLock e a classe
ReentrantReadWriteLock, a única que a implementa
• Essa classe tem dois bloqueios, um para operações de leitura
e um para operações de gravação
• Pode haver mais de uma thread usando operações de leitura
simultaneamente, mas somente uma thread pode estar
usando operações de gravação
• Quando uma thread está fazendo uma operação de gravação,
não pode haver qualquer outra thread fazendo operações de
leitura
• Neste exemplo, vamos aprender como usar uma interface
ReadWriteLock implementando um programa que a utiliza
para controlar o acesso a um objeto que armazena os preços
de dois produtos

Programa Exemplo
1. Crie uma classe chamada PricesInfo que armazenará
informação sobre os preços de dois produtos.
public class PricesInfo {
2. Declare dois atributos double chamados price1 e
price2.
private double price1;
private double price2;
3. Declare um objeto ReadWriteLock chamado lock.
private ReadWriteLock lock;

Programa Exemplo
4. Implemente o construtor da classe que inicializa estes
três atributos. Para o atributo lock, criaremos um novo
objeto ReentrantReadWriteLock.
public PricesInfo(){
price1=1.0;
price2=2.0;
lock=new ReentrantReadWriteLock();
}

Programa Exemplo
5. Implemente o método getPrice1() que retorna o
valor do atributo price1. Ele utiliza o bloqueio de
leitura para controlar o acesso ao valor deste atributo.
public double getPrice1() {
lock.readLock().lock();
double value=price1;
lock.readLock().unlock();
return value;
}

Programa Exemplo
6. Implemente o método getPrice2() que retorna o
valor do atributo price2. Ele utiliza o bloqueio de
leitura para controlar o acesso ao valor deste atributo.
public double getPrice2() {
lock.readLock().lock();
double value=price2;
lock.readLock().unlock();
return value;
}

Programa Exemplo
7. Implemente o método setPrices() que estabelece os
valores dos dois atributos. Ele utiliza o bloqueio de
escrita para controlar o acesso a eles.
public void setPrices(double price1,
double price2) {
lock.writeLock().lock();
this.price1=price1;
this.price2=price2;
lock.writeLock().unlock();
}

Programa Exemplo
8. Crie uma classe chamada Reader e especifique que ela
implementa a interface Runnable. Esta classe
implementa um leitor de valores dos atributos da classe
PricesInfo.
public class Reader implements Runnable {
9. Declare um objeto PricesInfo e implemente o
private PricesInfo pricesInfo;
public Reader (PricesInfo pricesInfo){
this.pricesInfo=pricesInfo;
}

Programa Exemplo
10. Implemente o método run() desta classe. Ele lê 10
vezes o valor dos dois preços.
@Override
public void run() {
for (int i=0; i<10; i++){
System.out.printf("%s: Price 1: %fn",
Thread.currentThread().getName(),
pricesInfo.getPrice1());
System.out.printf("%s: Price 2: %fn",
pricesInfo.getPrice2());
}
}

Programa Exemplo
11. Crie uma classe chamada Writer e especifique que ela
implementa a interface Runnable. Esta classe
implementa um modificador dos valores dos atributos
da classe PricesInfo.
public class Writer implements Runnable {
12. Declare um objeto PricesInfo e implemente o
private PricesInfo pricesInfo;
public Writer(PricesInfo pricesInfo){
this.pricesInfo=pricesInfo;
}

Programa Exemplo
13. Implemente o método run(). Ele modifica três vezes o valor dos
dois preços e dorme por dois segundos entre as alterações.
@Override
public void run() {
for (int i=0; i<3; i++) {
System.out.printf("Writer: Tentando
modificar os preços.n");
pricesInfo.setPrices(Math.random()*10,
Math.random()*8);
System.out.printf("Writer: Os preços foram
modificados.n");
try {
Thread.sleep(2);
}
}
}

Programa Exemplo
14. Implemente a classe principal do exemplo e crie o método
main().
public class Main {
15. Crie um objeto PricesInfo.
PricesInfo pricesInfo=new PricesInfo();
16. Crie cinco objetos Reader e cinco Threads para executá-
los.
Reader readers[]=new Reader[5];
Thread threadsReader[]=new Thread[5];
for (int i=0; i<5; i++){
readers[i]=new Reader(pricesInfo);
threadsReader[i]=new Thread(readers[i]);
}

Programa Exemplo
17. Crie um objeto Writer e uma Thread para executá-lo.
Writer writer=new Writer(pricesInfo);
Thread threadWriter=new Thread(writer);
18. Inicie as threads.
for (int i=0; i<5; i++){
threadsReader[i].start();
}
threadWriter.start();

Funcionamento
• Na captura de tela seguinte, você pode ver uma parte da
saída de uma execução deste exemplo:

Funcionamento
• Como mencionamos anteriormente, a classe
ReentrantReadWriteLock tem dois bloqueios, um para
operações de leitura e um para operações de gravação
• O bloqueio utilizado em operações de leitura é obtida
com o método readlock() declarado na interface
ReadWriteLock
• Esse bloqueio é um objeto que implementa a interface
Lock, para que possamos usar os métodos lock(),
unlock(), e tryLock()
• O bloqueio utilizado em operações de gravação é obtido
com o método writeLock() declarado na interface
ReadWriteLock

Funcionamento
• Esse bloqueio é um objeto que implementa a interface
Lock, para que possamos usar os métodos lock(),
unlock(), e tryLock()
• É de responsabilidade do programador garantir o uso
correto desses bloqueios, usando-os com os mesmos
propósitos para os quais eles foram projetados
• Quando conseguimos o bloqueio de leitura de uma
interface Lock, não podemos modificar o valor da
variável, caso contrário, provavelmente teríamos erros de
inconsistência de dados

Modificando o Equilíbrio entre
Bloqueios
• O construtor das classes ReentrantLock e
ReentrantReadWriteLock admite um parâmetro
boolean chamado fair que permite controlar o
comportamento de ambas as classes
• O valor false é o valor padrão e é chamado de modo não
justo
– Neste modo, quando existem algumas threads esperando por um
bloqueio (ReentrantLock ou ReentrantReadWriteLock) e o
bloqueio tem que selecionar uma delas para obter o acesso à seção
crítica, ele seleciona uma sem qualquer critério
• O valor true é chamado de modo justo
– Neste modo, quando existem algumas threads esperando por um
bloqueio (ReentrantLock ou ReentrantReadWriteLock) e o
bloqueio tem que selecionar uma delas para obter acesso a uma
seção crítica, ele seleciona a thread que está esperando por mais
tempo

Modificando o Equilíbrio entre
Bloqueios
• Leve em consideração que o comportamento explicado
anteriormente só é usado com os métodos lock() e
unlock()
• Como o método tryLock() não coloca a thread para
dormir, se a interface Lock é usada, o atributo fair não
afeta a sua funcionalidade
• Neste exemplo, vamos modificar o exemplo
implementado em Sincronizando um Bloco de Código
com um Bloqueio para usar esse atributo e ver a
diferença entre os modos justo e não justo

Programa Exemplo
1. Implemente o exemplo explicado em Sincronizando um
Bloco de Código com um Bloqueio.
2. Na classe PrintQueue, modifique a construção do
objeto Lock.
private Lock queueLock=new
ReentrantLock(true);
3. Modifique o método printJob(). Separe o simulador
de impressão em dois blocos de código, liberando o
bloqueio entre eles.

Programa Exemplo
public void printJob(Object document){
queueLock.lock();
try {
System.out.println(Thread.currentThread().
getName()+":Fila de Impressão:
} finally {
queueLock.unlock();
}
...

Programa Exemplo
...
queueLock.lock();
try {
System.out.println(Thread.currentThread().
getName()+":Fila de Impressão:
} finally {
queueLock.unlock();
}
}

Programa Exemplo
4. Modifique a classe principal no bloco que inicia as
threads. O novo bloco deve ser:
for (int i=0; i<10; i++){
thread[i].start();
try {
Thread.sleep(100);
}
}

Funcionamento
• Na captura de tela seguinte você pode ver uma parte da
saída de uma execução deste exemplo:

Funcionamento
• Todas as threads são criadas com uma diferença de 0,1
segundo
• A primeira thread que solicita o controle do bloqueio é a
Thread 0, então a Thread 1, e assim por diante
• Enquanto Thread 0 está executando o primeiro bloco de
código protegido pelo bloqueio, temos nove threads em
espera para executar esse bloco de código
• Quando a Thread 0 libera o bloqueio, imediatamente, ela
solicita o bloqueio novamente, por isso temos 10 threads
que tentam obter o bloqueio
• Como o modo justo está habilitado, a interface Lock vai
escolher Thread 1, uma vez que é a thread que está
esperando por mais tempo pelo bloqueio

Funcionamento
• Em seguida, escolhe Thread 2, então, o Thread 3, e assim
por diante
• Até que todas as threads tenham passado pelo primeiro
bloco protegido pelo bloqueio, nenhuma delas vai
executar o segundo bloco protegido
• Uma vez que todas as threads tenham executado o
primeiro bloco de código protegido pelo bloqueio, é a vez
de Thread 0 novamente, em seguida, é a vez de Thread
1, e assim por diante
• Para ver a diferença com o modo não justo, altere o
parâmetro passado para o construtor de bloqueio e
coloque o valor false

Funcionamento
• Na captura de tela seguinte, você pode ver o resultado de
uma execução do exemplo modificado:

Funcionamento
• Neste caso, as threads são executadas pela ordem em
que foram criadas, mas cada thread executa os dois
blocos de código protegidos
• No entanto, esse comportamento não é garantido
porque, como explicado anteriormente, o bloqueio
poderia escolher qualquer thread para dar-lhe acesso ao
código protegido
• A JVM não garante, neste caso, a ordem de execução das
threads
• Bloqueios Read/Write também têm o parâmetro fair em
seu construtor, o comportamento deste parâmetro neste
tipo de bloqueio é o mesmo que foi explicado na
introdução deste exemplo

Usando Múltiplas Condições em um
Bloqueio
• Um bloqueio pode ser associado a uma ou mais
condições
• Estas condições são declaradas na interface Condition
• O objetivo destas condições é permitir que threads
tenham o controle de um bloqueio e verifiquem se uma
condição é verdadeira ou não e, se for falsa, ser suspensa
até que uma outra thread a acorde
• A interface Condition fornece os mecanismos para
suspender uma thread e para acordar uma thread
suspensa

Bloqueio
• Um problema clássico na programação concorrente é o
problema do produtor-consumidor
• Temos um buffer de dados, um ou mais produtores de
dados que armazenam no buffer, e um ou mais
consumidores de dados que leem a partir do buffer como
explicado anteriormente
• Neste exemplo, veremos como implementar o problema
do produtor-consumidor usando bloqueios e condições

Programa Exemplo
1. Primeiro, vamos implementar uma classe que irá
simular um arquivo de texto. Crie uma classe chamada
FileMock com dois atributos: um array String
denominado content e um int chamado index. Eles
vão armazenar o conteúdo do arquivo e a linha do
arquivo simulado que será recuperada.
public class FileMock {
private String content[];
private int index;

Programa Exemplo
2. Implemente o construtor da classe que inicializa o conteúdo
e o arquivo com caracteres aleatórios.
public FileMock(int size, int length){
content=new String[size];
for (int i=0; i<size; i++){
StringBuilder buffer =
new StringBuilder(length);
for (int j=0; j<length; j++){
int indice=(int)Math.random()*255;
buffer.append((char)indice);
}
content[i]=buffer.toString();
}
index=0;
}

Programa Exemplo
3. Implemente o método hasMoreLines() que retorna true
se o arquivo tem mais linhas para processar ou false se já
atingiu o fim do arquivo simulado.
public boolean hasMoreLines(){
return index < content.length;
}
4. Implemente o método getLine() que retorna a linha
determinada pelo atributo index e aumenta o seu valor.
public String getLine(){
if (this.hasMoreLines()) {
System.out.println("Mock: "+
(content.length-index));
return content[index++];
}
return null;
}

Programa Exemplo
5. Agora implemente uma classe chamada Buffer que irá
implementar o buffer compartilhado por produtores e
consumidores.
public class Buffer {
6. Esta classe possui seis atributos:
– Um atributo LinkedList<String> chamado buffer que irá
armazenar os dados compartilhados
– Um int chamado maxSize que armazena o tamanho do buffer
– Um objeto ReentrantLock chamado lock que controla o
acesso aos blocos de código que modificam o buffer
– Dois atributos Condition chamados lines e space
– Um tipo boolean chamado pendingLines que irá indicar se
existem linhas no buffer

Programa Exemplo
private LinkedList<String> buffer;
private int maxSize;
private ReentrantLock lock;
private Condition lines;
private Condition space;
private boolean pendingLines;

Programa Exemplo
7. Implemente o construtor da classe. Ele inicializa todos
os atributos descritos anteriormente.
public Buffer(int maxSize) {
this.maxSize=maxSize;
buffer=new LinkedList<>();
lock=new ReentrantLock();
lines=lock.newCondition();
space=lock.newCondition();
pendingLines=true;
}

Programa Exemplo
8. Implemente o método insert(). Ele recebe uma
String como parâmetro e tenta armazená-lo no buffer.
Em primeiro lugar, ele obtém o controle do bloqueio.
Quando consegue, então verifica se existe espaço vazio
no buffer. Se o buffer está cheio, ele chama o método
await() na condição space para esperar por espaço
livre. A thread será acordada quando outra thread
chamar o método de signal() ou signalAll() na
Condition space. Quando isso acontece, a thread
armazena a linha no buffer e chama o método
signallAll() sobre a condição lines. Como veremos
em um momento, essa condição vai acordar todas as
threads que estão à espera de linhas no buffer.

Programa Exemplo
public void insert(String line) {
lock.lock();
try {
while (buffer.size() == maxSize) {
space.await();
}
buffer.offer(line);
System.out.printf("%s: Linha inserida: %dn",
buffer.size());
lines.signalAll();
} finally {
lock.unlock();
}
}

Programa Exemplo
9. Implemente o método get(). Ele retorna a primeira
string armazenada no buffer. Em primeiro lugar, ele
obtém o controle do bloqueio. Quando consegue, ele
verifica se há linhas no buffer. Se o buffer está vazio, ele
chama o método await() na condição lines para
esperar por linhas no buffer. Esta thread será acordada
quando uma outra thread chamar o método signal()
ou signalAll() na condição lines. Quando isso
acontece, o método obtém a primeira linha no buffer,
chama o método signalAll() sobre a condição space
e retorna a String.

Programa Exemplo
public String get() {
String line=null;
lock.lock();
try {
while ((buffer.size() == 0) &&(hasPendingLines())) {
lines.await();
}
if (hasPendingLines()) {
line = buffer.poll();
System.out.printf("%s: Linha carregada: %dn",
Thread.currentThread().getName(),buffer.size());
space.signalAll();
}
} finally {
lock.unlock();
}
return line;
}

Programa Exemplo
10. Implemente o método setPendingLines() que
estabelece o valor do atributo pendingLines. Ele será
chamado pelo producer quando não existirem mais
linhas para produzir.
public void setPendingLines(boolean
pendingLines) {
this.pendingLines=pendingLines; }
11. Implemente o método hasPendingLines. Ele retorna
true se existem mais linhas a serem processadas, ou
false caso contrário.
public boolean hasPendingLines() {
return pendingLines || buffer.size()>0;
}

Programa Exemplo
12. Implemente uma classe chamada Producer e especifique
que ela implementa a interface Runnable.
public class Producer implements Runnable {
13. Declare dois atributos: um objeto da classe FileMock e
outro objeto da classe Buffer.
private FileMock mock;
private Buffer buffer;
14. Implemente o construtor da classe que inicializa ambos os
atributos.
public Producer (FileMock mock, Buffer buffer){
this.mock=mock;
this.buffer=buffer;
}

Programa Exemplo
15. Implemente o método run() que lê todas as linhas criadas
no objeto FileMock e usa o método insert() para
armazená-las no buffer. Uma vez terminado, use o método
setPendingLines() para alertar o buffer que ele não
precisa gerar mais linhas.
@Override
public void run() {
buffer.setPendingLines(true);
while (mock.hasMoreLines()){
String line=mock.getLine();
buffer.insert(line);
}
buffer.setPendingLines(false);
}

Programa Exemplo
16. Implemente uma classe chamada Consumer e
especifique que ela implementa a interface Runnable.
public class Consumer implements Runnable {
17. Declare um objeto Buffer e implemente o construtor
da classe que o inicializa.
private Buffer buffer;
public Consumer (Buffer buffer) {
this.buffer=buffer;
}

Programa Exemplo
18. Implemente o método run(). Enquanto o buffer possuir
linhas pendentes, ele tenta recuperar uma e processá-
la.
@Override
public void run() {
while (buffer.hasPendingLines()) {
String line=buffer.get();
processLine(line);
}
}

Programa Exemplo
19. Implemente o método auxiliar processLine(). Ele
apenas espera por até 10 milissegundos para simular
algum tipo de processamento com a linha.
private void processLine(String line) {
try {
Random random=new Random();
Thread.sleep(random.nextInt(100));
}
}

Programa Exemplo
20. Implemente a classe principal do exemplo e adicione o
método main().
public class Main {
21. Crie um objeto FileMock.
FileMock mock=new FileMock(100, 10);
22. Crie um objeto Buffer.
Buffer buffer=new Buffer(20);
23. Crie um objeto Producer e uma Thread para executá-lo.
Producer producer=new Producer(mock,
buffer);
Thread threadProducer=new
Thread(producer,"Producer");

Programa Exemplo
24. Crie três objetos Consumer e três threads para executá-
los.
Consumer consumers[]=new Consumer[3];
Thread threadConsumers[]=new Thread[3];
for (int i=0; i<3; i++){
consumers[i]=new Consumer(buffer);
threadConsumers[i]=new
Thread(consumers[i],"Consumer "+i);
}

Programa Exemplo
25. Inicie o produtor e os três consumidores.
threadProducer.start();
for (int i=0; i<3; i++){
threadConsumers[i].start();
}

Funcionamento
• Todos os objetos Condition estão associados com um
bloqueio e são criados usando o método newCondition()
declarado na interface Lock
• Antes de podermos fazer qualquer operação com uma
condição, temos que ter o controle do bloqueio associado
com a condição, por isso as operações com condições devem
estar em um bloco de código que começa com uma chamada
a um método lock() de um objeto Lock e termina com um
método unlock() do mesmo objeto Lock
• Quando uma thread chama o método await() de uma
condição, ela libera automaticamente o controle do bloqueio,
de modo que alguma outra thread pode obtê-lo e começar a
execução da mesma, ou de outra seção crítica protegida por
esse bloqueio

Funcionamento
• Quando uma thread chama os métodos signal() ou
signallAll() de uma condição, uma ou todas as
threads que estavam esperando por essa condição serão
acordadas, mas isso não garante que a condição que fez
com que elas dormissem seja agora verdadeira, por isso
devemos colocar a chamada await() dentro de um laço
while
• Não podemos deixar esse ciclo até que a condição seja
verdadeira
• Enquanto a condição for falsa, devemos chamar await()
novamente

Funcionamento
• Devemos ter cuidado com o uso de await() e signal():
se chamarmos o método await() em uma condição e
nunca chamarmos o método de signal() nesta
condição, a thread irá dormir para sempre
• Uma thread pode ser interrompida enquanto ele está
dormindo, depois de uma chamada ao método await(),
então temos que processar a exceção
InterruptedException

Bloqueio
• A interface Condition tem outras versões do método
await(), que são os seguintes:
– await(long time, TimeUnit unit): a thread irá dormir até
que:
• Seja interrompida
• Uma outra thread chama os métodos signal() ou signalAll() na
condição
• O tempo especificado passe
• A classe TimeUnit é uma enumeração com as seguintes constantes:
DAYS, HOURS, MICROSECONDS, MILLISECONDS, MINUTES,
NANOSECONDS e SECONDS
– awaitUninterruptibly(): a thread irá dormir até que uma
outra thread chame os métodos signal() ou signalAll(),
que não podem ser interrompidos

Bloqueio
• A interface Condition tem outras versões do método
await(), que são os seguintes (continuação):
– awaitUntil(Date date): a thread ficará dormindo até que:
• Seja interrompida
• Uma outra thread chama os métodos signal() ou signalAll() na
condição
• A data especificada chegue
• Podemos usar condições com os bloqueios ReadLock e
WriteLock de leitura/escrita

05 - Sincronização de Threads - I

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a 05 - Sincronização de Threads - I

Mais de Fabio Moura Pereira

05 - Sincronização de Threads - I