Dúvida de conceitual (eu acho)

1 de outubro de 2008 5 respostas

raschefelipe 1 de outubro de 2008

Galera,

Tenho a classe abaixo:

package com.tcc;

import java.io.IOException;


public class Executa {
	
	public Executa() throws IOException, InterruptedException {
		super();
	}		
	public int executa(String caminhoPrograma) throws IOException, InterruptedException{
		
		// Acrescenta aspas duplas caso o caminho tenha espaço
		caminhoPrograma = '\"' + caminhoPrograma + '\"'; 
		
		// Realiza chamada do programa externo
		Process p = Runtime.getRuntime().exec(caminhoPrograma);
		
	return p.waitFor();
	}
}

Bom, ocorre que chamo ela sempre passando o programa que desejo executar (word, excel, calculadora, etc). Mas imaginem o seguinte, se no mesmo horário (vou acessar um banco de dados para verificar) eu tive que executar 2-3 programas…não devo trabalhar com threads ? Ou deixo pro SO se virar ? (mesmo q o hardware tenha mais de um processador).

Bom na real não sei como tratar desse problema, pois de fato pode ocorrer de mais de uma atividade ter q ser realizada na mesma data/hora.
Q vcs acham ???

Qualquer dica será aceita !!!

valeu.

5 Respostas

volnei 2 de out. de 2008

Você pode trabalhar com Threads uma vez que o waitFor vai travar seu programa até que você feche o aplicativo iniciado, ou criar várias instâncias do programa.

Dá pra melhorar muito, mas seria mais ou menos isso...

package com.tcc;

import java.io.IOException;

public class Executa {
  public Executa() throws IOException, InterruptedException {
    super();
  }		
  public void executa(final String caminhoPrograma) throws IOException, InterruptedException{
    Thread t = new Thread(){
      public void run(){
            Process p = Runtime.getRuntime().exec('\"' + caminhoPrograma + '\"');
            p.waitFor();
      }
    }).start();
  }
}

raschefelipe 2 de out. de 2008

Obrigado,

Mas estou ainda com dificuldade em entender como seria a logica desse esquema, pois tenho os seguintes passos:

1 - consultar no banco quais aplicativos serão executados naquele momento - ok (vou ter um array com o resultado).
2 - qual seria o criterio para executá-los uma vez que deveria ser no mesmo momento ? (acho q nao tem saida né, chamo eles conforme a ordem do array).
3 - cada chamada seria entao uma thread.

Seria isso ?

mas fico a pensar, o cada um dos programas leva o mesmo tempo para ser executado não ficaria sequencial ?

Obrigado, sei q sao conceitos básicos mas queria saber da opiniao da galera…valeu + uma vez.

volnei 2 de out. de 2008

1 - Grava no banco no momento da execução e após a mesma o status da execução
2 - Vai ser "praticamente" no mesmo momento, uma vez que cada chamada é tratada num processo separado
3 - Sim, cada chamada uma thread

package com.tcc;

import java.io.IOException;

public class Executa {
  public Executa() throws IOException, InterruptedException {
    super();
  }		
  public void executa(final String caminhoPrograma) throws IOException, InterruptedException{
    Thread t = new Thread(){
      public void run(){
            // atualiza o status no banco de dados para EXECUTANDO
            Process p = Runtime.getRuntime().exec('\"' + caminhoPrograma + '\"');
            p.waitFor();
            // atualiza o status no banco de dados para PARADO
      }
    }).start();
  }
}

raschefelipe 7 de out. de 2008

Pessoal,

Obrigado pelas dicas até o momento mas ainda não resolvi meu problema.

Estou tentando fazer com que as chamadas para a minha classe que executa um programa externo funcione assim:

1 - após executar os comandos abaixo

Executa exec = new Executa();

int n = exec.executa (“c:/notepad.exec”);

int c = exec.executa (“c:/calc.exec”);

int w = exec.executa (“c:/winword.exe”);

2 - aguarda a execução de cada aplicação externa e grava no banco de dados, porém a execução das 3 linhas acima podem ser no mesmo momento, pois quero agendar e execução dos sistemas externos, como se fosse um scheduler para execução de tarefas (que podem ser na mesma data e hora).
Mas da forma q está ele aguarda o término de cada programa, dessa maneira o segundo programa não estaria sendo executado no horário indicado pois o notepad pode rodar o dia inteiro, entenderam ?

Como faço para resolver esse detalhe ? Seria tirando a opção waitFor() ? Mas nesse caso eu perco o controle não ?

Obrigado !

raschefelipe 14 de out. de 2008

Aí galera,

Obrigado pelas dicas, segue como ficou e que me atendeu na boa:

package com.tcc;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Executa {
	
	public Executa () throws IOException, InterruptedException {
		super();
	}	
	
	public int executa(final String caminhoPrograma) throws IOException, InterruptedException{
		
		final Process p = Runtime.getRuntime().exec(caminhoPrograma);
		
		new Thread(){
			public void run(){
				try{
					BufferedReader in = new BufferedReader(new InputStreamReader (p.getInputStream()));
					  String str = null;
					  while ( (str = in.readLine()) != null )
					    System.out.println(str);
					  in.close();					
					System.out.println("saida");
				}catch (IOException e){
					e.printStackTrace();
				}
		    }
		}.start();    
		
		new Thread(){
			public void run(){
				try{
					BufferedReader in = new BufferedReader(new InputStreamReader (p.getErrorStream()));
					  String str = null;
					  while ( (str = in.readLine()) != null )
					    System.out.println(str);
					  in.close();					
					System.out.println("erro");
				}catch (IOException e){
					e.printStackTrace();
				}
		    }
			
		}.start();    				
		
	return 0;
	} 	
}

Criado 1 de outubro de 2008

Ultima resposta 14 de out. de 2008

Respostas 5

Participantes 2

5 Respostas

Topicos relacionados