S12L13 - Wait e Notify no multithreading de Java continua

html

Dominando Wait e Notify em Multithreading Java
Índice

Introdução ………………………………………………………… 1
Compreendendo Multithreading em Java ……… 3
A Importância da Sincronização ………… 5
Explorando os Métodos Wait e Notify ………….. 7

Método Wait
Métodos Notify e NotifyAll


Implementação Prática: Simulação de Conta Bancária ………… 11

Visão Geral do Projeto
Detalhamento do Código
Executando o Projeto


Erros Comuns e Melhores Práticas ………. 17
Conclusão ………………………………………………………….. 21


Introdução
Bem-vindo ao Dominando Wait e Notify em Multithreading Java, seu guia abrangente para entender e implementar efetivamente mecanismos de sincronização em Java. No reino da programação concorrente, gerenciar como múltiplas threads interagem é fundamental para construir aplicações robustas e eficientes. Este eBook mergulha nas complexidades dos métodos wait e notify, oferecendo explicações claras, exemplos práticos e melhores práticas para aprimorar suas habilidades de multithreading.
Destaques Principais:

Compreender os fundamentos do multithreading em Java.
Entender a sincronização e sua importância.
Aprofundar-se nos métodos wait, notify e notifyAll.
Explorar um projeto de simulação de Conta Bancária do mundo real.
Aprender a evitar erros comuns de sincronização.


Compreendendo Multithreading em Java
O Que é Multithreading?
Multithreading é um conceito de programação que permite a execução concorrente de duas ou mais threads para a máxima utilização da CPU. Em Java, cada thread opera no contexto de um thread scheduler, que gerencia a execução das threads.
Por Que Multithreading?

Desempenho Melhorado: Permite que múltiplas operações sejam executadas simultaneamente, melhorando a responsividade da aplicação.
Compartilhamento de Recursos: Utilização eficiente dos recursos do sistema compartilhando dados comuns.
Modelagem Simplificada: Representação natural de cenários do mundo real onde múltiplas atividades ocorrem simultaneamente.

Threads em Java
Java fornece a classe Thread e a interface Runnable para criar e gerenciar threads.




		
		
			
			
Java
			
			// Estendendo a classe Thread
class MyThread extends Thread {
    public void run() {
        // Tarefa a ser executada
    }
}

// Implementando a interface Runnable
class MyRunnable implements Runnable {
    public void run() {
        // Tarefa a ser executada
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						// Estendendo a classe Thread
class MyThread extends Thread {
    public void run() {
        // Tarefa a ser executada
    }
}
 
// Implementando a interface Runnable
class MyRunnable implements Runnable {
    public void run() {
        // Tarefa a ser executada
    }
}
					
				
			
		



A Importância da Sincronização
O Que é Sincronização?
Sincronização é o processo de controlar o acesso de múltiplas threads a recursos compartilhados. Sem a sincronização adequada, as threads podem interferir umas nas outras, levando a estados de dados inconsistentes e comportamentos inesperados.
Por Que Sincronizar?

Integridade dos Dados: Garante que os dados compartilhados permaneçam consistentes.
Coordenação de Threads: Gerencia a sequência de execução das threads.
Prevenção de Deadlocks: Evita situações onde threads estão esperando indefinidamente umas pelas outras.

Mecanismos de Sincronização em Java

Métodos Synchronized: Bloqueia o método inteiro.
Blocos Synchronized: Bloqueia um bloco específico de código.
Métodos Wait e Notify: Facilita a comunicação entre threads.


Explorando os Métodos Wait e Notify
Método Wait
O método wait() faz com que a thread atual espere até que outra thread invoque o método notify() ou notifyAll() para o mesmo objeto. Ele efetivamente libera o lock e entra no estado de espera.
Uso:




		
		
			
			
Java
			
			synchronized (object) {
    while (condition) {
        object.wait();
    }
    // Prosseguir quando notificado
}
			
				
					
				
					1
2
3
4
5
6
				
						synchronized (object) {
    while (condition) {
        object.wait();
    }
    // Prosseguir quando notificado
}
					
				
			
		


Versões Sobrecarregadas:

wait(long millis): Aguarda pelos milissegundos especificados.
wait(long millis, int nanos): Aguarda pelos milissegundos e nanosegundos especificados.

Métodos Notify e NotifyAll

Notify (notify()): Desperta uma única thread que está esperando no monitor do objeto.
Notify All (notifyAll()): Desperta todas as threads que estão esperando no monitor do objeto.

Uso:




		
		
			
			
Java
			
			synchronized (object) {
    // Modificar condição/estado
    object.notify(); // ou object.notifyAll();
}
			
				
					
				
					1
2
3
4
				
						synchronized (object) {
    // Modificar condição/estado
    object.notify(); // ou object.notifyAll();
}
					
				
			
		


Diferenças Principais entre Wait e Notify


Característica
wait()
notify()


Propósito
Faz com que a thread atual espere
Desperta uma thread esperando


Liberação de Lock
Sim
Requer bloco sincronizado


Número de Threads Notificadas
Nenhuma (apenas espera)
Uma única thread



Implementação Prática: Simulação de Conta Bancária
Visão Geral do Projeto
Para ilustrar a aplicação prática de wait e notify, vamos simular um sistema simples de Conta Bancária onde múltiplas threads realizam operações de saque e depósito concorrentes. Este exemplo destaca como gerenciar a sincronização de threads para manter a integridade dos dados.
Estrutura do Projeto:




		
		
			
			
Java
			
			BankAccountSimulation.zip
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── org/studyeasy
│   │           └── Main.java
│   └── test
│       └── java
│           └── org/studyeasy
│               └── MainTest.java
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						BankAccountSimulation.zip
├── pom.xml
├── src
│   ├── main
│   │   └── java
│   │       └── org/studyeasy
│   │           └── Main.java
│   └── test
│       └── java
│           └── org/studyeasy
│               └── MainTest.java
					
				
			
		


Detalhamento do Código
Main.java




		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        Thread withdrawalThread = new Thread(new Withdrawal(account, 1000));
        Thread depositThread = new Thread(new Deposit(account, 2000));
        
        withdrawalThread.start();
        depositThread.start();
    }
}

class BankAccount {
    private int balance = 1000;

    // Método de saque sincronizado
    public synchronized void withdraw(int amount) {
        System.out.println("Attempting to withdraw $" + amount);
        if (balance < amount) {
            System.out.println("Insufficient funds. Waiting for deposit...");
            try {
                wait(3000); // Aguarda depósito
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balance -= amount;
        System.out.println("Withdrawal of $" + amount + " completed. Current Balance: $" + balance);
    }

    // Método de depósito sincronizado
    public synchronized void deposit(int amount) {
        System.out.println("Depositing $" + amount);
        balance += amount;
        System.out.println("Deposit of $" + amount + " completed. Current Balance: $" + balance);
        notify(); // Notifica threads esperando
    }
}

class Withdrawal implements Runnable {
    private BankAccount account;
    private int amount;

    public Withdrawal(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        account.withdraw(amount);
    }
}

class Deposit implements Runnable {
    private BankAccount account;
    private int amount;

    public Deposit(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }

    public void run() {
        try {
            Thread.sleep(2000); // Simula tempo de processamento
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.deposit(amount);
    }
}
			
				
					
				
					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
72
73
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        BankAccount account = new BankAccount();
        
        Thread withdrawalThread = new Thread(new Withdrawal(account, 1000));
        Thread depositThread = new Thread(new Deposit(account, 2000));
        
        withdrawalThread.start();
        depositThread.start();
    }
}
 
class BankAccount {
    private int balance = 1000;
 
    // Método de saque sincronizado
    public synchronized void withdraw(int amount) {
        System.out.println("Attempting to withdraw $" + amount);
        if (balance < amount) {
            System.out.println("Insufficient funds. Waiting for deposit...");
            try {
                wait(3000); // Aguarda depósito
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        balance -= amount;
        System.out.println("Withdrawal of $" + amount + " completed. Current Balance: $" + balance);
    }
 
    // Método de depósito sincronizado
    public synchronized void deposit(int amount) {
        System.out.println("Depositing $" + amount);
        balance += amount;
        System.out.println("Deposit of $" + amount + " completed. Current Balance: $" + balance);
        notify(); // Notifica threads esperando
    }
}
 
class Withdrawal implements Runnable {
    private BankAccount account;
    private int amount;
 
    public Withdrawal(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }
 
    public void run() {
        account.withdraw(amount);
    }
}
 
class Deposit implements Runnable {
    private BankAccount account;
    private int amount;
 
    public Deposit(BankAccount account, int amount) {
        this.account = account;
        this.amount = amount;
    }
 
    public void run() {
        try {
            Thread.sleep(2000); // Simula tempo de processamento
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        account.deposit(amount);
    }
}
					
				
			
		


Explicação do Código

Classe BankAccount:

Balance: Representa o saldo atual na conta.
withdraw Method:

Synchronized para prevenir acesso concorrente.
Verifica se o saldo é suficiente. Caso contrário, espera por um depósito.
Usa wait(3000) para esperar 3 segundos antes de prosseguir.


deposit Method:

Synchronized para garantir segurança das threads.
Adiciona o valor do depósito ao saldo.
Chama notify() para despertar quaisquer threads de saque que estejam esperando.




Classe Withdrawal:

Implementa Runnable para realizar saques em uma thread separada.
Invoca o método withdraw de BankAccount.


Classe Deposit:

Implementa Runnable para realizar depósitos em uma thread separada.
Espera por 2 segundos para simular tempo de processamento antes de invocar o método deposit.


Classe Main:

Cria instâncias de Withdrawal e Deposit.
Inicia ambas as threads, iniciando as operações concorrentes.



Executando o Projeto
Ao executar a classe Main, a seguinte sequência de eventos ocorre:

Withdrawal Thread:

Tenta sacar $1000.
Se fundos insuficientes, espera por um depósito.


Deposit Thread:

Espera por 2 segundos para simular atraso no processamento.
Depósito de $2000.
Notifica a thread de saque que está esperando.


Output Final:

O saque é completado após o depósito, atualizando o saldo de acordo.



Output Esperado:




		
		
			
			
Java
			
			Attempting to withdraw $1000
Withdrawal of $1000 completed. Current Balance: $0
Depositing $2000
Deposit of $2000 completed. Current Balance: $2000
			
				
					
				
					1
2
3
4
				
						Attempting to withdraw $1000
Withdrawal of $1000 completed. Current Balance: $0
Depositing $2000
Deposit of $2000 completed. Current Balance: $2000
					
				
			
		



Erros Comuns e Melhores Práticas
Erros Comuns

Não Usar Blocos Synchronized:

Falhar em sincronizar o acesso a recursos compartilhados pode levar a condições de corrida e estados inconsistentes.


Uso Incorreto de Wait e Notify:

Esquecer de chamar wait ou notify dentro de um contexto sincronizado resulta em IllegalMonitorStateException.


Deadlocks:

Quando duas ou mais threads estão esperando indefinidamente umas pelas outras para liberar locks.


Usar notify em vez de notifyAll:

Em cenários onde múltiplas threads podem estar esperando, usar notify pode levar a algumas threads permanecerem bloqueadas.



Melhores Práticas

Sempre Sincronizar Recursos Compartilhados:

Use métodos ou blocos synchronized para controlar o acesso a dados compartilhados.


Use notifyAll Quando Múltiplas Threads Estiverem Esperando:

Garante que todas as threads esperando sejam notificadas, prevenindo bloqueios indefinidos.


Minimize o Escopo dos Blocos Synchronized:

Restrinja a sincronização ao menor segmento de código necessário para melhorar o desempenho.


Trate InterruptedException Adequadamente:

Sempre capture e trate InterruptedException para manter a responsividade das threads.


Evite Usar wait com Timeouts Arbitrários:

Prefira esperas baseadas em condição em vez de timeouts fixos para uma coordenação de threads mais confiável.




Conclusão
Dominar os métodos wait e notify é essencial para construir aplicações multithreaded confiáveis e eficientes em Java. Ao entender os mecanismos de sincronização e implementar as melhores práticas, você pode gerenciar efetivamente as interações de threads, garantindo a integridade dos dados e um desempenho ótimo.
Principais Aprendizados:

Sincronização: Crucial para gerenciar o acesso a recursos compartilhados.
Wait e Notify: Facilita a comunicação entre threads, permitindo uma execução coordenada.
Melhores Práticas: Adotar protocolos de sincronização previne problemas comuns de threading como deadlocks e condições de corrida.

Abrace esses conceitos para aproveitar todo o potencial das capacidades de multithreading do Java, abrindo caminho para a criação de aplicações de alto desempenho e escaláveis.
Este artigo é gerado por IA.
Característica	wait()	notify()
Propósito	Faz com que a thread atual espere	Desperta uma thread esperando
Liberação de Lock	Sim	Requer bloco sincronizado
Número de Threads Notificadas	Nenhuma (apenas espera)	Uma única thread