Duvida:
Alguém tem um idéia de como implementar um algoritmo do avestruz?
Com Algoritmo do Avestruz suponho q vc esteja se referindo em ignorar certos problemas que podem ocorrer no sistema, eu tento deixar meu sistema o mais funcional possível e para aqueles locais que sei que poderá haver problema eu implemento o seguinte código:
try{
// aqui vc coloca o código com potencial problema
}catch(Exception a){
// Coloque um log se preferir do tipo System.out.print(a.getMessage())
}
O Exception é genérico, funciona com qualquer exceção que poderá ocorrer.
Espero ter ajudado.
Olá 4mega, recebi um trabalho na faculdade que o assunto é Deadlock, e nesse trabalho o professor lançou um desafio, que era implementar o Algoritmo do Avestruz, justamente se referindo em ignorar problemas. Dei uma estudada parar ver o que era o Try/catch e consegui entender como ignorar o problema, mas agora estou com uma outra dúvida, e eu ficaria realmente muito agradecido se tu pudesse me dar umas dicas… Para gerar esse problema e então ignorar ele, primeiro eu preciso executar alguns processos, para ocorrer o Deadlock e ai sim ignorar esse problema, será que tu conseguirar me dar umas dicas de como executar tais processos, recursos em java? Quero lembrar que eu não manjo muito na programação ainda, não tenho muito conhecimento.
Agradeço por informar esse bloco Try/Catch para mim.
Tente por exemplo, em um calculo fazer a divisão por zero, dentro desse calculo coloque o try catch
Opa, seguinte. O processo sempre será interrompido caso exista algum problema, porém ao tratar os processos com o try catch, é possível q vc coloque outros processos e não só o Log como informei na resposta anterior (perdão), exemplo:
double resultado;
try{
// aqui ocorreu o processo com Erro
resultado = 0/54;
}catch(Exception a){
// Aqui vc coloca um tratamento caso ocorra a exceção
resultado = 0;
}
O try/catch pode ser utilizado para executar um unico processo tambem, os tais processos críticos, o restante do código pode ficar fora. Outra coisa que esqueci de comentar é do comando finally, ele executa independente se ocorreu erro ou não depois do try, exemplo:
public boolean finalizaTarefa(Tarefa tarefa) {
try {
Transaction tr = session.beginTransaction();
session.update(tarefa);
tr.commit();
return true;
} catch (Exception a) {
return false;
} finally {
if (session != null) {
session.close();
}
}
}
O método acima possui valor de retorno do tipo boolean, e caso ele de algum erro no update, ele interromperá o código e irá para o catch, e depois disso tudo ele irá para o finally, que verifica se a conexão esta aberta, e caso ela esteja ele à fecha. Perceba que caso o “return true” está no final do try, isso significa que só irá executa-lo caso n ocorra erro.
Recomendo vc pesquisar sobre throws Exception.
Espero ter ajudado
Ola 4mega, muito obrigado por me da essas dicas e informações, consegui esclarecer todas as dúvidas que eu tinha. Já pensei em como vou implementar o meu trabalho, e depois que eu implementar eu venho aqui te mostrar como ficou !!
Muito obrigado mesmo por me da essa força. Se eu tiver mais alguma dúvida eu retorno aqui a pedir ajuda kkkkkkkk.
1 curtida
Estou a disposição, abraços.
4Mega, Tudo bem por ai?
É o seguinte, depois da última vez que conversamos aqui, estudei, estudei e estudei muito rsrs, e conseguir realizar um Deadlock com 2 thread, tentei de tudo que é jeito, fazer ele ignorar esse Deadlock com o try/catch e mostrar uma mensagem no final, dizendo que o programa entro em deadlock e parar ele, mas não estou conseguindo.
Se puder me dar uma ajuda no que fazer, eu iria ficar agradecido. Aguardo retorno.
O código que eu desenvolvi segue logo abaixo, o primeiro TRY é aonde eu estou deixando o código principal onde eu sei que vai ocorrer o deadlock e o CATCH lá no final é onde eu estou deixando a mensagem dizendo que o programa entrou em DEADLOCK e finalizo ele.
[code]package deadlock;
import javax.swing.JOptionPane;
public class Deadlock {
public static void main(String[] args) {
try{
final String RECURSO1 = "Recurso 1";
final String RECURSO2 = "Recurso 2";
// primeira thread
Thread t1 = new Thread() {
public void run() {
synchronized(RECURSO1) {
try {
System.out.println("Thread #1: Bloqueou o recurso 1");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread #1: Tentando acesso ao recurso 2");
// Aguarda até obter o recurso 2.
synchronized(RECURSO2) {
System.out.println("Thread #1: Bloqueou o recurso 2");
}
}
}
};
// segunda thread
Thread t2 = new Thread() {
public void run() {.
synchronized(RECURSO2) {
try {
System.out.println("Thread 2: Bloqueou o recurso 2");
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Theread #2: Tentando o acesso ao recurso 1");
// O recurso 1 está em block e agora ocorre o deadlock
// porque o recurso 2 está preso por essa thread.
synchronized(RECURSO1) {
System.out.println("Thread 2: Bloqueou o recurso 1");
}
}
}
};
// da o go nas thread
t1.start();
t2.start();
}catch(Throwable e){
JOptionPane.showMessageDialog(null, "Programa entrou em DEADLOCK" +e.getMessage());
System.exit(0);
}
}
} [/code]
Você realmente precisa chegar no DeadLock neste exercício? A solução que encontro para seu código é essa:
import javax.swing.JOptionPane;
public class Deadlock {
final static String RECURSO1 = "Recurso 1";
final static String RECURSO2 = "Recurso 2";
public static void main(String[] args) {
try {
Thread1 T1 = new Thread1();
Thread2 T2 = new Thread2();
T1.start();
T2.start();
} catch (Throwable e) {
JOptionPane.showMessageDialog(null, "Programa entrou em DEADLOCK" + e.getMessage());
}
}
private static class Thread1 extends Thread {
@Override
public void run() {
synchronized (RECURSO1) {
try {
System.out.println("Thread #1: Bloqueou o recurso 1");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread #1: Tentando acesso ao recurso 2");
// Aguarda até obter o recurso 2.
synchronized (RECURSO2) {
System.out.println("Thread #1: Bloqueou o recurso 2");
}
}
}
}
private static class Thread2 extends Thread {
@Override
public void run() {
synchronized (RECURSO1) {
try {
System.out.println("Thread 2: Bloqueou o recurso 2");
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Theread #2: Tentando o acesso ao recurso 1");
synchronized (RECURSO2) {
System.out.println("Thread 2: Bloqueou o recurso 1");
}
}
}
}
}
Ela não gera nenhuma exceção. O que acontece é que inverti a ordem de sincronização, assim n interfere uma na outra. E eu também organizei por classes este exercício, para ficar melhor de entende-lo.
Outra solução, While… Se o sistema trava quando tenta acesso a algo em uso, então tente acessa-lo ate conseguir;
import javax.swing.JOptionPane;
public class Deadlock {
final static String RECURSO1 = "Recurso 1";
final static String RECURSO2 = "Recurso 2";
public static void main(String[] args) {
try {
Thread1 T1 = new Thread1();
Thread2 T2 = new Thread2();
T1.start();
T2.start();
} catch (Throwable e) {
JOptionPane.showMessageDialog(null, "Programa entrou em DEADLOCK" + e.getMessage());
}
}
private static class Thread1 extends Thread {
@Override
public void run() {
synchronized (RECURSO1) {
try {
System.out.println("Thread #1: Bloqueou o recurso 1");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread #1: Tentando acesso ao recurso 2");
boolean acesso = true;
// Aguarda até obter o recurso 2.
while (!acesso) {
System.out.println("s");
synchronized (RECURSO2) {
acesso = false;
System.out.println("Thread #1: Bloqueou o recurso 2");
}
}
}
}
}
private static class Thread2 extends Thread {
@Override
public void run() {
synchronized (RECURSO2) {
try {
System.out.println("Thread 2: Bloqueou o recurso 2");
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Theread #2: Tentando o acesso ao recurso 1");
boolean acesso = true;
while (!acesso) {
System.out.println("s");
synchronized (RECURSO1) {
acesso = false;
System.out.println("Thread #1: Bloqueou o recurso 2");
}
}
}
}
}
}Sim, preciso chegar no DeadLock.
Interessante essa solução com o While, conseguir realizar uma questão que eu estava quebrando a cabeça utilizando esse método seu com o While.
Mas agora voltando ao trabalho, eu realmente preciso chegar no DeadLock, e andei conversando com o professor hoje à noite e consegui finalizar o trabalho (É o que eu acho). O conceito do Algoritmo do Avestruz, é ignorar o erro e continuar executando o programa, certo né ?
Então, neste caso eu ocasionei o DeadLock e o programa deveria continuar rodando e não dar bola para o impasse ocorrido e continuar executando as linhas de código que tivesse a seguir, mas para demonstrar que o programa ia executa as linha de código depois de ocasinado o DeadLock, minha solução foi criar uma terceira Thread e colocar algumas saídas la, como “Iniciou thread 3”, “Algoritmo do avestruz implementado com sucesso”, “finalizou a thread3” e encerrar o programa, como a seguir irá ver no código.
[code]import javax.swing.JOptionPane;
public class DeadLock2 {
final static String RECURSO1 = "Recurso 1";
final static String RECURSO2 = "Recurso 2";
public static void main(String[] args) {
try {
Thread t1 = new Thread1();
Thread t2 = new Thread2();
t1.start();
//t1.join();
t2.start();
//t2.join();
} catch (Throwable e) {
e.printStackTrace();
}
JOptionPane.showMessageDialog(null, "Programa entrou em DEADLOCK");
Thread t3 = new Thread3();
t3.start();
}
private static class Thread1 extends Thread {
@Override
public void run() {
synchronized (RECURSO1) {
try {
System.out.println("Thread #1: Bloqueou o recurso 1");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Thread #1: Tentando acesso ao recurso 2");
// Aguarda ate obter o recurso 2.
synchronized (RECURSO2) {
System.out.println("Thread #1: Bloqueou o recurso 2");
}
}
}
}
private static class Thread2 extends Thread {
@Override
public void run() {
synchronized (RECURSO2) {
try {
System.out.println("Thread #2: Bloqueou o recurso 2");
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Theread #2: Tentando o acesso ao recurso 1");
synchronized (RECURSO1) {
System.out.println("Thread #2: Bloqueou o recurso 1");
}
}
}
}
private static class Thread3 extends Thread {
public void run() {
System.out.println("Iniciou Thread 3");
System.out.println("Thread #3: Entrando em ação");
JOptionPane.showMessageDialog(null, "Thread #3 no comando");
JOptionPane.showMessageDialog(null, "Algoritmo do Avestruz implementado com sucesso");
System.out.println("Finalizou a Thread 3");
System.exit(0);
}
}
} [/code]
Eu utilizei a sua organização do código em classe, pois eu achei melhor de entender como você comentou, como sou iniciante não peguei o bom costume de criar classes, mas com o tempo vou acostumando rsrs.
Como você pode ver, no método “main”, é criada 2 Thread e iniciada elas, ocasionando o DeadLock, e depois do try/catch eu mostro a mensagem com o JOptionPane dizendo que o programa entrou no DeadLock e em seguida em crio uma terceira Thread e inicio ela, mostrando umas mensagens dizendo que a Thread 3 foi inicia e finalizo o programa.
Pelo jeito, o trabalho era isso, amanhã mostro para o professor e ele me diz se está certo ou não, mas acredito que esteja tudo correto. Fico muito agradecido por você me ajudar, me dar essas dicas e tudo.
Talvez ficou meio confuso o texto a cima, peço desculpa, mas foi a maneira que consegui explicar rsrsrs.
Mais uma vez, muito obrigado. E se precisar de algo, estamos ai, cada dia mais evoluindo.
1 curtida
Feliz em ter ajudado