Processos

Página Inicial

4D v16

Autoformação

Processos

Além das manipulações explicadas no vídeo, deve levar em conta que:

Um processo é um entorno que tem:

Seu próprio espaço de memória
Suas seleções atuais (uma por tabela)
Suas próprias variáveis (variáveis processos)Possivelmente sua própria interface
etc.

Os processos podem se comunicar entre si de diferentes maneiras:

Variáveis interprocesso
Leitura ou escritura de variáveis
etc.

Eles podem:

Colocar a dormir (sleep process)
Colocar em modo hibernação (suspended process) até que outro processo o acorde.

Um processo só morre quando termina o método que o executa.
Não se pode obrigar a um processo a morrer por programação, a pesar de que pode programar para que morra em certas condições (ver o comando CALL PROCESS )

Os processos geralmente servem para:

Criar processos particulares (batches, controles “submarine”),
Criar paletas de ferramentas (janelas independentes com funções específicas)
Mostrar diálogos de entrada/visualização para que o usuário possa trabalhar com múltiplas janelas.

4D gera diretamente certos processos.

Um processo é criado utilizando o comando New process:

vProcessNumber:=New process(Method;Stack;Processname;Settings;...)

Esta linha de comando deve estar no método. Recomendamos-lhe que utilize o conceito que é mostrado a continuação, economizará tempo e claridade:

 C_TEXT($1)

 If(Count parameters=0) // Se o método não recebe nenhum parâmetro, você deve criar o processo

    C_LONGINT(<>ProcessNumber)

    <>ProcessNumber:=New process("Display_Stats2";1024*1024;"Statistics";"Fictitious_Parameter") // criamos o processo

 Else // Se o método recebe ao menos um parâmetro, deve executar o método de visualização

    C_LONGINT($Window) //Criar a janela (recipiente) no qual é mostrado o diálogo (conteúdo)

    $Window:=Open form window("STATS";Plain form window;Horizontally centered;Vertically centered)

    DIALOG("STATS") //Mostrar o diálogo

    CLOSE WINDOW($Window) // Uma vez fechado o diálogo, fechar a janela

 End if

Quando é chamado o método (sem parâmetros), 4D cria um processo no qual é executado um método.
O método é chama a si mesmo (é criado uma segunda instância do método no novo processo)
E se passa um parâmetro:
A primeira instância do método termina
Ainda que o método executado pelo processo continue e apresente o array de estatísticas.

Você pode seguir trabalhando enquanto tenha a janela de estatísticas a seu alcance.

Para traçar a execução de um processo (quando executa a linha New Process), utilize o botão “step-by-step new process”. Este botão executa a linha e abre uma segunda janela de depuração na qual pode seguir o progresso do método executado no processo, independentemente do método de chamada.

Por exemplo, pode criar um processo que mostre a hora e o tempo passado desde que o novo processo começou. Este exemplo lhe dará os fundamentos para a criação de um contador de tempo.

Os processos permitem considerar evoluções rápidas em sua programação:

Pode conceituar seus processos,
testar em várias linhas de código,
logo pode configurar para uma execução independente em um processo.

Há inúmeros exemplos do uso de processos. Este é mais um: você tem que fazer atualizações em um banco de dados importante, no entanto, essas atualizações podem ser atrasadas por vários segundos ou minutos, inclusive sem ter um impacto sobre o desempenho da sua empresa. Assim, você pode:

Prever uma tabela na qual aonde guarde uma lista de tarefas a realizar.
Para cada uma destas tarefas, você especifica uma data, uma hora e possivelmente um nível de prioridade e uma descrição da tarefa a realizar (que? em qual tabela? qual registro? etc.)
Logo, iniciou um processo cuja única missão é consultar esta tabela e realizar o conjunto de tarefas nela.
Quando termina, se suspende até que uma nova tarefa se registre e o processo se reativa.

Esta operação é muito factível em modo cliente/servidor onde um processo (procedimento armazenado) "corre" no servidor e leva a cabo as tarefas a realizar:

Importações
Reprocessar
Impressão PDF
Envio de correios eletrônicos
etc.

Video script

Neste vídeo, vamos a aprender sobre o ciclo de vida de um processo: nascimento, vida e morte.

Os processos com frequência se utilizam em trabalhos multi tarefas. Os processos permitem criar vários trabalhos simultaneamente, sem ter que terminar o primeiro processo para começar o segundo.

Vamos supor que você quer acessar ao módulo de estatísticas que executamos nos vídeos anteriores. Você quer seguir estando ativado enquanto faz outra coisa.
Para fazer isso, vamos a iniciar o método em um processo e permitir ao usuário refrescar as estatísticas fazendo clique em um botão que adicionaremos no formulário.

Primeiro, vamos criar a chamada do diálogo Statistics no formulário de navegação. Faremos o seguinte:

Duplicar um botão
E vamos chamá-lo Stats

E em seu método, tal como fizemos para o primeiro diálogo, vamos a:

Criar um recipiente
Mostrar o diálogo Stats
A continuação, fechar a janela novamente.

Vamos provar isto. Temos um botão Stats que mostra a informação que nos interessa e obtemos as estatísticas.

No entanto, já não podemos trabalhar em nosso formulário de navegação, por que está no primeiro plano.

Existe uma maneira para trabalhar com várias janelas, neste caso, é preferível utilizar diferentes tipos de processos, que é o que vamos fazer agora.

Um processo é criado utilizando o comando New process, que deve ser chamado desde um método.
A continuação lhe indicamos:

Qual método deve ser executado no processo
A pilha
O nome do processo
E os possíveis parâmetros.

Neste caso, vamos criar um método para a visualização de Stats (note que o nome é colocado entre aspas) e este método conterá a criação do formulário.

A pilha em realidade não importa
O nome do processo será Statistics
E não necessitamos parâmetros específicos.

Em 4D existe um parâmetro estrela que você pode passar como último parâmetro e que pode ser usado com muitos comandos. Isto evita criar o mesmo processo várias vezes. Não vamos usa-lo por enquanto, mas pode consultar a documentação para mais detalhes sobre seu uso.

Agora veremos como funciona isto. Se fizermos clique no botão Stats:

Ainda temos o formulário Stats que é mostrado
Mas esta vez, temos a possibilidade de trabalhar em uma janela ou na outra.
De fechar o processo
De outra vez mostrar
E neste nível, é possível inclusive mostrar vários deles como não utilizamos o parâmetro estrela.

Seria inclusive possível, assumindo que configuramos o ano no formulário, ter as estatísticas de um ano e as estatísticas de outro ano em duas telas diferentes.

É importante entender que quando usamos os processos, cada um tem seu próprio ambiente, em outras palavras, se é realizado um cálculo daqui, se obtém alguns elementos de informação, independentemente de quantos são os registros encontrados aqui.
Podemos decidir tomar só alguns deles e nossas estatísticas sempre se calcularão em função de toda a informação contida na tabela.

Portanto, é necessário entender que um processo terá:

Suas próprias seleções
Suas próprias variáveis

Se temos 2 processos que executam o mesmo método, cada uma pode ter informação diferente.

Quando vários processos são criados e pedimos um seguimento, 4D mostra todos os processos que são criados:

Os processos estandarte criados por 4D
Mas os que criamos, como o processo Statistics.

Portanto, é possível fazer seguimento e quando vamos a "calcular", é o método do botão no qual se faz clique ao que se lhe faz seguimento.

Se fizermos seguimento a outro processo, podemos ver o modo seguimento deste processo aqui.

Ao princípio deste vídeo, mencionamos a criação, vida e morte de um processo.

Demos uma olhada a estas três etapas:
Primeira, a criação do processo: New process será criado.

Para realizar um seguimento ao que se está executando em um New process, deve usar este botão: aparece uma segunda janela de seguimento para o seguimento do método "Statistics" que se está executando.
Podemos completar o processo criador.

A continuação, um método é executado e durante este período, o processo está vivo.

Podemos fazer uma série de coisas tais como:
Intercâmbios entre processos
ou arrastar e soltar.

O processo se mata quando termina o método que se executou durante sua criação:

Aqui, voltamos ao método inicial que se executou quando o processo foi criado.
A janela é fechada
O método termina
O processo irá morrer

Se fazemos um seguimento, já não veremos o processo "Statistics".