1. Criação do processo Java
O Java fornece dois métodos para iniciar um processo ou outro programa:
(1) Use o método EXEC () do tempo de execução (2) Use o método START () do ProcessBuilder's Start (2) do ProcessBuilder (2)
1.1 ProcessBuilder
A classe ProcessBuilder é uma nova classe adicionada no Java.Lang pelo J2SE 1.5. Antes do J2SE 1.5, o controle e o gerenciamento do processo foram implementados pela classe de processo.
Cada instância do ProcessBuilder gerencia um conjunto de propriedades do processo. O método start () usa essas propriedades para criar uma nova instância de processo. O método start () pode ser chamado repetidamente da mesma instância para criar um novo processo filho com as mesmas propriedades ou propriedades relacionadas.
Cada gerador de processo gerencia estas propriedades do processo:
Um comando é uma lista de strings que representam o arquivo de programa externo a ser chamado e seus parâmetros (se houver). Aqui, a lista de strings que representam comandos de sistema operacional válido depende do sistema. Por exemplo, toda variável geral geralmente se torna um elemento nesta lista, mas existem sistemas operacionais que desejam que o programa marque as próprias seqüências de caracteres da linha de comando - em tais sistemas, as implementações de Java podem exigir que os comandos incluam exatamente esses dois elementos.
Os ambientes são mapeamentos dependentes do sistema de variáveis para valores. O valor inicial é uma cópia do ambiente de processo atual (consulte System.getEnv ()).
Diretório de trabalho. O valor padrão é o diretório de trabalho atual do processo atual, geralmente nomeado de acordo com o System Property User.dir.
Propriedade RedirecterRorStream. Inicialmente, essa propriedade é falsa, o que significa que a saída padrão e a saída de erro do processo filho são enviados para dois fluxos independentes que podem ser acessados através dos métodos Process.getInputStream () e Process.getErrorStream (). Se o valor for definido como true, o erro padrão será mesclado com a saída padrão. Isso facilita a associação de mensagens de erro e a saída correspondente. Nesse caso, os dados mesclados podem ser lidos no fluxo retornado pelo process.getInputStream (), enquanto o fluxo lido do process.getErrorStream () chegará ao final do arquivo diretamente.
A modificação das propriedades do construtor de processos afetará os processos subsequentes iniciados pelo método START () do objeto, mas nunca afetará os processos iniciados anteriormente ou o próprio Java. A maioria das verificações de erros é executada pelo método START (). O estado do objeto pode ser modificado, mas o start () falhará dessa maneira. Por exemplo, definir a propriedade de comando em uma lista vazia não lançará uma exceção, a menos que o start () esteja incluído.
Observe que esta classe não é síncrona. Se vários threads acessarem um processador de processos ao mesmo tempo e pelo menos um dos threads modificar estruturalmente uma das propriedades, ele deverá manter a sincronização externa.
Resumo dos métodos de construção
ProcessBuilder (Lista <String> Comando)
Construa um gerador de processo usando programas e parâmetros do sistema operacional especificado.
ProcessBuilder (String ... comando)
Construa um gerador de processo usando programas e parâmetros do sistema operacional especificado.
Resumo do método
Lista <String> Command ()
Retorna os programas do sistema operacional e os parâmetros deste gerador de processos.
Comando ProcessBuilder (Lista <String> Command)
Define os programas e parâmetros do sistema operacional deste gerador de processos.
Comando ProcessBuilder (comando ... String ...)
Define os programas e parâmetros do sistema operacional deste gerador de processos.
Diretório de arquivos ()
Retorna o diretório de trabalho deste gerador de processo.
Diretório do ProcessBuilder (diretório de arquivos)
Define o diretório de trabalho para este gerador de processo.
Mapa <string, string> ambiente ()
Retorna uma visualização de mapeamento de string desse ambiente de gerador de processos.
RedirecterRorStream booleanos ()
Notifique o gerador do processo se deve mesclar erros padrão e saída padrão.
ProcessBuilder RedirecterRorStream (Boolean RedirecterRorStream)
Define a propriedade RedirecterRorStream deste gerador de processos.
Processo inicial ()
Inicie um novo processo usando as propriedades deste gerador de processo.
1.2 Tempo de execução
Cada aplicativo Java possui uma instância da classe de tempo de execução, permitindo que o aplicativo se conecte ao ambiente que ele é executado. O tempo de execução atual pode ser obtido através do método getRuntime.
Os aplicativos não podem criar suas próprias instâncias de classe de tempo de execução. No entanto, você pode obter a referência ao objeto de tempo de execução atual através do método GetRuntime. Depois de obter uma referência ao objeto de tempo de execução atual, você pode chamar o método do objeto de tempo de execução para controlar o estado e o comportamento da máquina virtual Java.
Código de coleta de código java
Void AddshutdownHook (gancho de thread)
Registre uma nova máquina virtual para desligar o gancho.
int disponívelProcessors ()
Retorna o número de processadores disponíveis para a máquina virtual Java.
Processo executivo (comando string)
Execute o comando string especificado em um processo separado.
Process Exec (String [] CMDARRAY)
Execute comandos e variáveis especificados em um processo separado.
Process Exec (string [] cmDarray, string [] Envp)
Execute comandos e variáveis especificados em um processo separado do ambiente especificado.
Process Exec (String [] CMDARRAY, String [] Envp, Arquivo Dir)
Execute comandos e variáveis especificados em processos separados no ambiente especificado e no diretório de trabalho.
Process Exec (comando string, string [] Envp)
Execute o comando string especificado em um processo separado do ambiente especificado.
Process Exec (Comando String, String [] Envp, Arquivo Dir)
Execute o comando string especificado em um processo separado com um ambiente especificado e diretório de trabalho.
saída vazia (status int)
Encerrar a máquina virtual Java no momento, iniciando a sequência de desligamento da máquina virtual.
Long Freemory ()
Retorna a quantidade de memória livre na máquina virtual Java.
Void GC ()
Execute o coletor de lixo.
InputStream getLocalizedInputStream (InputStream in)
Obsoleto. Começando com o JDK 1.1, o método preferido para converter um fluxo de bytes codificado localmente em um fluxo de caracteres Unicode é usar as classes InputStreamReader e BufferredReader.
O outputStream GetLocalizedOutputStream (OutputStream Out)
Obsoleto. Começando com o JDK 1.1, o método preferido para converter um fluxo de caracteres Unicode em um fluxo de bytes codificado localmente é usar as classes O outputStreamWriter, BufferWriter e PrintWriter.
Tempo de execução estático getRuntime ()
Retorna o objeto de tempo de execução associado ao aplicativo Java atual.
Void param (status int)
Forçado encerrar a máquina virtual Java no momento.
Carga vazia (nome do arquivo de string)
Carrega o nome do arquivo especificado como a biblioteca dinâmica.
Void Loadlibrary (String libname)
Carrega uma biblioteca dinâmica com o nome da biblioteca especificada.
MaxMemory longo ()
Retorna a quantidade máxima de memória que a máquina virtual Java tenta usar.
RemoveShutdownhook booleano (gancho de thread)
Não registre uma máquina virtual registrada anteriormente para desligar o gancho.
Void Runfinalization ()
Executa o método de rescisão de todos os objetos que suspendem a finalização.
estático void runfinizerSonexit (valor booleano)
Obsoleto. Este método em si é inseguro. Pode chamar um método final no objeto que está sendo usado, enquanto outros threads estão operando nesses objetos, resultando em comportamento incorreto ou impasse.
TotalMemory Long ()
Retorna a quantidade total de memória na máquina virtual Java.
Void TraceInstructions (booleano)
Ativar/desativar o rastreamento de comando.
Void tracemethodCalls (booleano)
Ativar/desativar o rastreamento de chamadas do método.
1.3 Processo
Independentemente do método usado para iniciar o processo, uma instância da classe de processo representa o processo iniciado será retornado, que pode ser usado para controlar o processo e obter informações relevantes. A classe de processo fornece métodos para executar a partir da entrada do processo, saída de execução para processar, aguardar a conclusão do processo, verificar o status de saída do processo e destruir (matar) o processo:
Void Destroy ()
Mate o processo infantil.
De um modo geral, esse método não pode matar o processo que foi iniciado, por isso é melhor não usá -lo.
int exitValue ()
Retorna o valor de saída do processo filho.
O método ExitValue () terá um valor de retorno normal somente após o processo de inicialização concluir sua execução ou sair devido a uma exceção, caso contrário, uma exceção será lançada.
InputStream getErrorRStream ()
Obtém o fluxo de erros do processo filho.
Se a saída de erro for redirecionada, a saída de erro não poderá ser lida no fluxo.
InputStream getInputStream ()
Obtém o fluxo de entrada do processo filho.
A saída padrão do processo pode ser lida a partir deste fluxo.
OutputStream getOutputStream ()
Obtém o fluxo de saída do processo filho.
Os dados gravados no fluxo são usados como entrada padrão para o processo.
int waitfor ()
Faz com que o encadeamento atual aguarde, se necessário, até que o processo representado pelo objeto de processo tenha terminado.
2. Exemplos de programação com vários processos
Geralmente, quando executamos métodos em outras classes em Java, sejam chamadas estáticas ou dinâmicas, são executadas no processo atual, ou seja, existe apenas uma instância de máquina virtual Java em execução. Às vezes, precisamos iniciar vários subprocessos Java através do código Java. Embora isso faça alguns recursos do sistema, isso tornará o programa mais estável porque o programa recém -iniciado é executado em diferentes processos da máquina virtual.
Em Java, podemos usar dois métodos para atingir esse requisito. A maneira mais fácil é executar o Java ClassName através do método EXEC no tempo de execução. Se a execução for bem -sucedida, esse método retornará um objeto de processo. Vamos dar uma olhada em um exemplo simples abaixo.
// Test1.java Arquivo Importar java.io. System.Println ("Chamado com sucesso!"); EXEC ("Java Test1");Depois de executar o programa através do Java Test_Exec, descobri que havia um arquivo Test1.txt adicional na unidade C, mas as informações de saída "chamadas com sucesso!" Portanto, pode -se concluir que o teste foi executado com sucesso, mas, por algum motivo, as informações de saída do teste não são emitidas no console de test_exec. Esse motivo também é muito simples, porque o processo filho de Test_exec é criado usando o EXEC.
Se você deseja gerar as informações de saída do processo filho, poderá obter o fluxo de saída do processo filho através do getInputStream em processo (saída no processo filho, entrada no processo pai) e depois transferir o fluxo de saída da criança processo da saída do console do processo pai. O código de implementação específico é o seguinte:
// test_exec_out.javaimport java.io = new BufferInputStream (P.GetInputStream ()); ;
Como pode ser visto no código acima, em test_exec_out.java, as informações de saída do processo filho são lidas por linha e, em seguida, a saída é executada em cada linha em test_exec_out. A discussão acima é como obter as informações de saída do processo filho. Então, além das informações de saída, também existem informações de entrada. Como o processo filho não possui seu próprio console, as informações de entrada também devem ser fornecidas pelo processo pai. Podemos fornecer informações de entrada para o processo filho através do método de processo GetOutstream (ou seja, informações de entrada do processo pai para o processo filho, em vez de informações de entrada do console). Podemos olhar para o seguinte código:
// Test2.Java Import java.io. "Informações inseridas pelo processo pai:" + B.ReadLine ()); .getRuntime (); Flush ();
A partir do código acima, podemos ver que o teste1 recebe as informações enviadas por test_exec_in e a produzir. Quando você não adiciona bw.flash () e bw.close (), as informações não atingirão o processo filho, o que significa que o processo infantil entra em um estado de bloqueio, mas como o processo pai saiu, o processo infantil também sai . Se você quiser provar isso, pode adicionar System.in.read () no final e, em seguida, visualizar o processo Java através do gerenciador de tarefas (no Windows), e você descobrirá que se adicionar BW.flush () e BW .Close (), existe apenas um processo Java, se forem removidos, existem dois processos Java. Isso ocorre porque se as informações forem passadas para o TEST2, o Test2 sairá após a obtenção das informações. Aqui está uma coisa a ser explicada que a execução do EXEC é assíncrona e não parará de executar o código a seguir, porque um determinado programa executado está bloqueado. Portanto, após a execução do TEST2, o código a seguir ainda pode ser executado.
O método EXEC foi recarregado muitas vezes. O que é usado acima é apenas uma sobrecarga. Ele também pode separar comandos e parâmetros, como EXEC ("java.test2") pode ser escrito como EXEC ("java", "test2"). O EXEC também pode executar máquinas virtuais Java com diferentes configurações através de variáveis de ambiente especificadas.
Além de usar o método EXEC do Runtime para criar um processo infantil, você também pode criar um processo filho através do ProcessBuilder. O uso do ProcessBuilder é o seguinte:
// test_exec_out.javaimport java.io. ;
Ao estabelecer processos filhos, o ProcessBuilder é semelhante ao tempo de execução. Depois de obter o processo, suas operações são exatamente as mesmas.
Como o tempo de execução, o ProcessBuilder também pode definir as informações do ambiente, o diretório de trabalho etc. do arquivo executável. O exemplo a seguir descreve como definir essas informações usando o ProcessBuilder.
ProcessBuilder PB = new ProcessBuilder ("Command", "Arg2", "Arg2", '' '); // Definir mapa variável de ambiente <string, string> Env = pb.environment (); Env.put ("key1", : ::::::::::::::::::::::Here :::::::::::::::::::hee :::::::::::::::::heo the : ::::::::::::::::::::::Here :::::::::::::::::::hee :::::::::::::::::heo the : :::::::::::::::::::::::here ::::::::: "value1"); Env.Remove ("Key2"); Env.put ("Key2", Env .get ("Key1") + "_test");