S12L12 - Esperar e Notificar em multithreading Java

html

Dominando Wait e Notify em Java Multithreading: Um Guia Abrangente para Iniciantes
Tabela de Conteúdos

Introdução
Compreendendo Wait e Notify em Java
Configuração do Projeto
Implementando o Mecanismo Wait e Notify
Executando a Aplicação
Problemas Comuns e Solução de Problemas
Conclusão

Introdução
No âmbito da programação Java, multithreading é um recurso poderoso que permite aos desenvolvedores realizar múltiplas operações simultaneamente, aumentando a eficiência e o desempenho das aplicações. Entre os vários mecanismos de sincronização em Java, wait e notify são fundamentais na gestão da comunicação entre threads e garantindo operações seguras para threads.
Este guia aprofunda-se nos conceitos de wait e notify dentro do multithreading em Java, proporcionando uma demonstração passo a passo através de um cenário bancário simples. Seja você um iniciante ou um desenvolvedor com conhecimentos básicos, este artigo abrangente o equipará com os insights necessários para implementar a sincronização de threads de forma eficaz.
Importância de Compreender Wait e Notify

Coordenação de Threads: Garante que as threads se comuniquem de forma eficiente sem causar conflitos.
Gerenciamento de Recursos: Evita que as threads acessem recursos compartilhados simultaneamente, prevenindo inconsistências.
Otimização de Desempenho: Melhora o desempenho da aplicação gerenciando a execução das threads de forma eficaz.

Prós e Contras


Prós
Contras


Comunicação eficiente entre threads
Pode levar a código complexo se não for gerenciado adequadamente


Previne contenção de recursos
Potencial para deadlocks se não implementado corretamente


Melhora o desempenho da aplicação
Requer um entendimento sólido da sincronização de threads


Quando e Onde Usar Wait e Notify

Quando: Utilize wait e notify quando as threads precisam comunicar sobre a disponibilidade de recursos ou a conclusão de tarefas.
Onde: Comumente usados em cenários como problemas produtor-consumidor, transações bancárias e qualquer situação que exija a execução coordenada de threads.

Compreendendo Wait e Notify em Java
Conceitos e Terminologia Chave

Thread: A menor unidade de processamento que pode ser gerenciada pela Java Virtual Machine (JVM).
Sincronização: Mecanismo para controlar o acesso de múltiplas threads a recursos compartilhados.
wait(): Faz com que a thread atual espere até que outra thread invoque notify() ou notifyAll() no mesmo objeto.
notify(): Desperta uma única thread que está esperando no monitor do objeto.

Como Wait e Notify Funcionam

wait():

Quando uma thread chama wait(), ela libera o monitor (lock) e entra no estado de espera.
A thread permanece nesse estado até que outra thread invoque notify() ou notifyAll() no mesmo objeto.


notify():

Quando uma thread chama notify(), ela desperta uma única thread que está esperando no monitor do objeto.
A thread despertada não pode prosseguir até que a thread atual libere o monitor.



Diagrama Ilustrativo

Figura 1: Interação entre os mecanismos Wait e Notify na sincronização de threads.
Configuração do Projeto
Para demonstrar o mecanismo wait e notify, criaremos uma aplicação Java simples que simula um cenário bancário onde uma thread espera por um depósito antes de permitir um saque.
Estrutura do Projeto




		
		
			
			
Java
			
			S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						S12L12 - Wait and Notify in Java Multithreading/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/studyeasy/
│   │           └── Main.java
│   └── test/
│       └── java/
└── target/
					
				
			
		


Pré-requisitos

Java Development Kit (JDK) instalado.
Maven para gestão de projetos.
Um Ambiente de Desenvolvimento Integrado (IDE) como IntelliJ IDEA ou Eclipse.

Implementando o Mecanismo Wait e Notify
Vamos nos aprofundar no núcleo da nossa aplicação implementando os métodos wait e notify dentro de um cenário bancário.
Implementação Passo a Passo
1. Criando a Classe Principal




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
					
				
			
		


Explicação:

Account: Representa a conta bancária com gerenciamento de saldo.
WithdrawTask & DepositTask: Tarefas Runnable para operações de saque e depósito.
Threads: Duas threads são criadas para lidar com saque e depósito simultaneamente.

2. Definindo a Classe Account




		
		
			
			
Java
			
			
package org.studyeasy;

public class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
				
						 
package org.studyeasy;
 
public class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
					
				
			
		


Explicação:

balance: Recurso compartilhado representando o saldo da conta do usuário.
withdraw(int amount):

Verifica se o saldo é suficiente.
Se não for, a thread espera por um depósito.
Uma vez notificada, prossegue com o saque.


deposit(int amount):

Adiciona o valor depositado ao saldo.
Notifica threads que estão esperando sobre a atualização do saldo.



3. Criando Tarefas Runnable




		
		
			
			
Java
			
			
package org.studyeasy;

public class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

public class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
				
						 
package org.studyeasy;
 
public class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
public class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Explicação:

WithdrawTask: Tenta sacar um valor específico.
DepositTask:

Introduz um atraso para simular cenários reais de depósito.
Realiza a operação de depósito após o atraso.



Código Completo do Programa




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}

class Account {
    public static int balance = 0;

    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }

    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}

class WithdrawTask implements Runnable {
    private final Account account;

    public WithdrawTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        account.withdraw(1000);
    }
}

class DepositTask implements Runnable {
    private final Account account;

    public DepositTask(Account account) {
        this.account = account;
    }

    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Account account = new Account();
        Thread threadOne = new Thread(new WithdrawTask(account), "Thread-Withdraw");
        Thread threadTwo = new Thread(new DepositTask(account), "Thread-Deposit");
        
        threadOne.start();
        threadTwo.start();
    }
}
 
class Account {
    public static int balance = 0;
 
    public synchronized void withdraw(int amount) {
        while (balance <= 0) {
            try {
                System.out.println(Thread.currentThread().getName() + ": Waiting for deposit...");
                wait();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println("Thread interrupted.");
            }
        }
        balance -= amount;
        System.out.println(Thread.currentThread().getName() + ": Withdrawal successful. Current Balance: " + balance);
    }
 
    public synchronized void deposit(int amount) {
        System.out.println(Thread.currentThread().getName() + ": Depositing amount...");
        balance += amount;
        System.out.println(Thread.currentThread().getName() + ": Deposit successful. Current Balance: " + balance);
        notify();
    }
}
 
class WithdrawTask implements Runnable {
    private final Account account;
 
    public WithdrawTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        account.withdraw(1000);
    }
}
 
class DepositTask implements Runnable {
    private final Account account;
 
    public DepositTask(Account account) {
        this.account = account;
    }
 
    @Override
    public void run() {
        try {
            // Simulando atraso no depósito
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        account.deposit(2000);
    }
}
 
					
				
			
		


Executando a Aplicação
Saída Esperada




		
		
			
			
Java
			
			Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
			
				
					
				
					1
2
3
4
				
						Thread-Withdraw: Waiting for deposit...
Thread-Deposit: Depositing amount...
Thread-Deposit: Deposit successful. Current Balance: 2000
Thread-Withdraw: Withdrawal successful. Current Balance: 1000
					
				
			
		


Explicação da Saída

Thread-Withdraw inicia e tenta sacar $1000.
Como o saldo inicial é $0, ela espera por um depósito.
Thread-Deposit inicia, simula um atraso de 2 segundos e então deposita $2000.
Após o depósito, ela nota a thread que está esperando.
Thread-Withdraw retoma, saca com sucesso $1000 e atualiza o saldo para $1000.

Execução Passo a Passo

Thread Principal:

Criar um objeto Account.
Inicializar duas threads: uma para saque e outra para depósito.
Iniciar ambas as threads.


Thread-Withdraw:

Chama withdraw(1000).
Verifica se o saldo ≤ 0; como está, imprime a mensagem de espera e chama wait().
Entra no estado de espera.


Thread-Deposit:

Dorme por 2 segundos para simular atraso.
Chama deposit(2000).
Atualiza o saldo para 2000.
Imprime mensagem de sucesso no depósito.
Chama notify() para despertar a thread de saque que está esperando.


Thread-Withdraw:

Desperta do wait().
Prossegue para sacar $1000.
Atualiza o saldo para $1000.
Imprime mensagem de sucesso no saque.



Problemas Comuns e Solução de Problemas
1. Deadlocks
Problema: Threads esperando indefinidamente devido ao uso inadequado de wait e notify.
Solução:

Assegure-se de que todo wait() tenha um correspondente notify() ou notifyAll().
Evite blocos de sincronização aninhados que podem levar a espera circular.

2. Notificações Perdidas
Problema: Uma thread perde uma chamada de notify(), fazendo com que espere indefinidamente.
Solução:

Sempre execute wait() dentro de um loop que verifica a condição.
Isso garante que a thread reavalie a condição ao acordar.

3. InterruptedException
Problema: Threads podem lançar InterruptedException ao esperar.
Solução:

Trate as interrupções de forma adequada capturando a exceção.
Opcionalmente, reinterrompa a thread usando Thread.currentThread().interrupt().

4. Sincronização Inadequada
Problema: Falha em sincronizar recursos compartilhados pode levar a estados inconsistentes.
Solução:

Use métodos ou blocos sincronizados para controlar o acesso a recursos compartilhados.
Assegure-se de que tanto wait() quanto notify() sejam chamados dentro de um contexto sincronizado.

Conclusão
Dominar os mecanismos wait e notify no multithreading em Java é essencial para desenvolver aplicações robustas e eficientes. Ao entender como as threads se comunicam e sincronizam, os desenvolvedores podem garantir que suas aplicações lidem com operações concorrentes de forma fluida.
Neste guia, exploramos um cenário bancário prático para demonstrar a implementação de wait e notify. Abordamos a configuração do projeto, a escrita de métodos sincronizados, o gerenciamento da comunicação entre threads e a solução de problemas comuns. Com esses conceitos fundamentais, você está bem equipado para enfrentar desafios mais complexos de multithreading em Java.
Nota: Este artigo foi gerado por IA.
Prós	Contras
Comunicação eficiente entre threads	Pode levar a código complexo se não for gerenciado adequadamente
Previne contenção de recursos	Potencial para deadlocks se não implementado corretamente
Melhora o desempenho da aplicação	Requer um entendimento sólido da sincronização de threads