• Inicialização: Processo criado, espera recursos.
• Pronto: Aguarda atribuição do processador.
• Execução: Em posse da máquina física.
• Espera: Aguarda evento ou comunicação.
• Terminado: Execução concluída, deve notificar o processo pai.

Um exemplo completo de uma classe Java chamada "lancarEEsperarProcessoWin32" para lançar processos está descrito na figura 3.1.1.1.

public class lancarEsperarProcessoWin32 {
    ProcessBuilder pb; // Instância de ProcessBuilder para construir e iniciar processos
    Process p; // Instância de Process para representar o processo em execução

    // Método para lançar um processo Win32 com base no nome do executável (String s)
    public void lancarProcessoWin32(String s) {
        pb = new ProcessBuilder(s); // Cria um ProcessBuilder com o nome do processo
        try {
            p = pb.start(); // Inicia o processo
            System.out.println("Processo executando."); // Exibe mensagem de sucesso
        } catch (IOException e) {
            p = null; // Em caso de erro, define 'p' como nulo (sem processo em execução)
        }
    }

    // Método para esperar o término do processo lançado
    public void esperarFimProcessoWin32() {
        if (p != null) { // Verifica se há um processo em execução
            try {
                p.waitFor(); // Aguarda até que o processo termine
                System.out.println("Processo terminou."); // Exibe mensagem de término
            } catch (InterruptedException e) {
                p = null; // Em caso de interrupção, define 'p' como nulo
            }
        }
    }

    // Método principal (entry point) para testar a classe
    public static void main(String[] args) {
        lancarEsperarProcessoWin32 lep = new lancarEsperarProcessoWin32(); // Cria uma instância da classe
        lep.lancarProcessoWin32("c:\\Windows\\system32\\mspaint.exe"); // Lança o processo do MS Paint
        lep.esperarFimProcessoWin32(); // Espera o término do processo do MS Paint
    }
}
Copy

• Um programa Java pode ser executado a partir do sistema operativo quando convertido em um arquivo executável .JAR.
• Isso requer um programa Java com um método main() que serve como ponto de entrada.
• No Eclipse, você pode criar um arquivo .JAR executável com os seguintes passos:
  1. Selecionar File -> Export -> Runnable JAR file.
  2. Clicar em NEXT.
  3. Definir a configuração de inicialização e o nome do arquivo .JAR.
  4. Clicar em Finish.

• A classe Java completa chamada "lancarEEsperarProcessoJAVA" que executa um ou mais processos

public class lancarEEsperarProcessoJAVA {
    public static void main(String[] args) {
        // Forma de executar a partir de Java um processo Java
        Process p = null; // Declaração de uma variável de processo
        
        try {
            // Executa um processo Java a partir do comando "java -jar" com o arquivo T1.jar
            p = Runtime.getRuntime().exec("java -jar C:\\Users\\jpais\\Desktop\\T1.jar");
            System.out.println("T1 executando."); // Exibe que o processo T1 está em execução
        } catch (IOException e) {
            e.printStackTrace(); // Em caso de erro, imprime a exceção
        }
        
        if (p != null) { // Verifica se o processo foi lançado com sucesso
            try {
                // Espera pelo término do processo T1
                p.waitFor();
                System.out.println("T1 terminou."); // Exibe que o processo T1 terminou
            } catch (InterruptedException e) {
                System.err.println(e.getMessage()); // Em caso de interrupção, imprime a mensagem de erro
            }
        }
    }
}
Copy

A memória partilhada em JAVA é uma memória mapeada de um ficheiro que tem de ser conhecido dos vários processos através do path e nome do ficheiro. A classe para implementar a comunicação entre processos tem o nome “canalComunicacao”

public class canalComunicacao {
    // Ficheiro
    private File ficheiro;
    // Canal que liga o conteúdo do ficheiro ao Buffer
    private FileChannel canal;
    // Buffer
    private MappedByteBuffer buffer;
    // Dimensão máxima em bytes do buffer
    final int BUFFER_MAX = 30;

    // Construtor vazio
    public canalComunicacao() {
        ficheiro = null;
        canal = null;
        buffer = null;
    }

    // Abre o canal de comunicação
    public boolean abrirCanal() {
        // Cria um ficheiro com o nome "comunicacao.dat"
        ficheiro = new File("comunicacao.dat");
        // Cria um canal de comunicação de leitura e escrita
        try {
            canal = new RandomAccessFile(ficheiro, "rw").getChannel();
        } catch (FileNotFoundException e) {
            return false;
        }
        // Mapeia para memória o conteúdo do ficheiro
        try {
            buffer = canal.map(FileChannel.MapMode.READ_WRITE, 0, BUFFER_MAX);
        } catch (IOException e) {
            return false;
        }
        return true;
    }

    // Recebe uma mensagem convertendo-a numa String
    String receberMensagem() {
        String msg = new String();
        char c;
        buffer.position(0);
        while ((c = buffer.getChar()) != '\0')
            msg += c;
        return msg;
    }

    // Envia uma String como mensagem
    void enviarMensagem(String msg) {
        char c;
        buffer.position(0);
        for (int i = 0; i < msg.length(); ++i) {
            c = msg.charAt(i);
            buffer.putChar(c);
        }
        buffer.putChar('\0');
    }

    // Fecha o canal entre o buffer e o ficheiro
    void fecharCanal() {
        if (canal != null)
            try {
                canal.close();
            } catch (IOException e) {
                canal = null;
            }
    }
}

Copy