Signal
Sinais são ferramentas fornecidas pela linguagem 4D para gerenciar interações e evitar conflitos entre processos em uma aplicação multiprocesso. Sinais permitem assegurar que um ou mais processos vão esperar por uma tarefa específica a ser completada antes de continuar a execução. Qualquer processo pode esperar ou liberar um sinal.
Os semáforos podem ser usados para gerenciar interações. Semáforos permitem ter certeza que dois ou mais processos não modificam o mesmo recurso (arquivo, registro..) ao mesmo tempo. Só o processo que estabelece o semáforo pode removê-lo.
Objeto sinal
Um sinal é um objeto partilhado que deve ser passado como parâmetro a comandos que chamam ou criam trabalhadores ou processo.
A 4D. Signal object contains the following built-in methods and properties:
Qualquer worker/processo que chame ao método .wait() suspenderá sua execução até que a propriedade .signaled seja verdaidera. Enquanto espera um sinal, o processo que chamar não usa nenhuma CPU. Isso pode ser muito interessante para o rendimento nas aplicações multiprocesso. A propriedade .signaled se converte em true quando qualquer worker/processo chamar ao método .trigger().
Lembre que para evitar situações de bloqueio, .wait() também pode regrassar depois de que tenha alcançado um tempo de espera definido.
Os objetos sinal se criam com o comando New signal.
Trabalhar com sinais
Em 4D, se cria um novo objeto sinal chamando ao comando New signal. Quando tiver criado o sinal, deve ser passado como parâmetro a New process ou CALL WORKER para que a modifiquem quando terminem a tarefa que queira esperar.
signal.wait()deve ser chamado do worker/processo que precisa de outro worker/processo para terminar uma tarefa para poder continuar.signal.trigger()deve ser chamado desde worker/processo que terminou sua execução para liberar a todos os outros.
Quando um sinal tiver sido lançado usando uma chamada signal.trigger(), não pode ser reutilizado. Se quiser estabelecer outro sinal, precisa chamar o comando New signal novamente.
Since a signal object is a shared object, you can use it to return results from called workers/processes, provided that you do not forget to write values within a Use... End use structure (see example).
Exemplo
#DECLARE ($signal : 4D.
Signal)
var $form : Object
$form:=New object("value";0)
// Open the form
$win:=Open form window("Information";Movable form dialog box)
DIALOG("Information";$form)
CLOSE WINDOW($win)
// Add a new attribute to your $signal shared object to pass your result to the other process:
Use($signal)
$signal.result:=$form.value
End use
// Trigger the signal to the waiting process
$signal.trigger()
Método OpenForm:
var $signal : 4D. Signal
// Creation of a signal
$signal:=New signal
// call main process and execute OpenForm method
CALL WORKER(1;"OpenForm";$signal)
// do another calculation
... // Waiting for the end of the process
$signaled:=$signal.wait()
// Processing of the results
$calc:=$signal.result+...
Resumo
.description : Text makes the current process wait until the .signaled property of the signal object to become true or the optional timeout to expire |
.signaled : Boolean contém o estado actual do objecto Sinal |
.trigger( ) coloca o sinalizado propriedade do objecto de sinal em verdadeiro |
.wait( { timeout : Real } ) : Boolean faz com que o processo atual espere até a propriedade .signaled do objeto sinal se tornar true ou expirar o opcional timeout |
New signal
Histórico
| Release | Mudanças |
|---|---|
| 17 R4 | Adicionado |
|
| Parâmetro | Tipo | Descrição | |
|---|---|---|---|
| description | Text | -> | Descrição para o sinal |
| Resultados | 4D. Signal | <- | Objeto nativo encapsulando o sinal |
|
Descrição
The .description property contains a custom description for the Signal object..
Um sinal é um objeto partilhado que pode ser passado como parâmetro de um worker ou processo para outro worker ou processo, de forma que:
- o worker/processo chamado pode atualizar o objeto sinal depois de um processamento especifico ter terminado
- o worker/processo chamado pode parar sua execução e esperar até que o sinal seja atualizado, sem consumir qualquer recurso de CPU.
Opcionalmente, no parâmetro description pode passar um texto personalizado descrevendo o sinal. Esse texto pode também ser definido depois da criação do sinal.
Since the signal object is a shared object, it can also be used to maintain user properties, including the .description property, by calling the Use... End use structure.
Valor retornado
A new 4D. Signal object.
Exemplo
Este é um exemplo típico de um worker que fixa um sinal:
var $signal : 4D. Signal
$signal:=New signal("This is my first signal")
CALL WORKER("myworker";"doSomething";$signal)
$signaled:=$signal.wait(1) //wait for 1 second max
If($signaled)
ALERT("myworker finished the work. Result: "+$signal.myresult)
Else
ALERT("myworker no ha terminado en menos de 1s")
End if
O método doSomething poderia ser algo como:
#DECLARE ($signal : 4D. Signal)
//any processing
//...
Use($signal)
$signal.myresult:=$processingResult //retorna o resultado
End use
$signal.trigger() // O trabalho terminou
.description
Histórico
| Release | Mudanças |
|---|---|
| 17 R4 | Adicionado |
.description : Text
Descrição
The .wait( ) function makes the current process wait until the .signaled property of the signal object to become true or the optional timeout to expire.
.description pode ser definida ao criar o objeto signal ou a qualquer momento. Note that since the Signal object is a shared object, any write-mode access to the .description property must be surrounded by a Use... End use structure.
Essa propriedade éapenas escrita.
.signaled
Histórico
| Release | Mudanças |
|---|---|
| 17 R4 | Adicionado |
.signaled : Boolean
Descrição
A propriedade .signaled contém o estado actual do objecto Sinal. . Quando se cria um sinal, .signaled é False.
Essa propriedade é apenas leitura.
.trigger()
Histórico
| Release | Mudanças |
|---|---|
| 17 R4 | Adicionado |
.trigger( )
| Parâmetro | Tipo | | Descrição | | --------- | ---- |::| ----------------------------------------------------- | | | | | Não exige nenhum parâmetro|
|
Descrição
A função .trigger() coloca o sinalizado propriedade do objecto de sinal em verdadeiro e desperta todos os trabalhadores ou processos que esperam por este sinal.
Se o sinal já estiver no estado de sinalização (ou seja, a propriedade signaled já for true), a função não faz nada.
.wait()
Histórico
| Release | Mudanças |
|---|---|
| 17 R4 | Adicionado |
.wait( { timeout : Real } ) : Boolean
| Parâmetro | Tipo | Descrição | |
|---|---|---|---|
| timeout | Real | -> | Tempo máximo de espera do sinal em segundos |
| Resultados | Parâmetros | <- | Estado da propriedade .signaled |
|
Descrição
A função .wait() faz com que o processo atual espere até a propriedade .signaled do objeto sinal se tornar true ou expirar o opcional timeout.
Para evitar que o código se bloqueie, pode passar um tempo máximo de espera em segundos no parâmetro timeout (se aceitam decimais).
Atención: A chamada a
.wait( )sem um timeout no processo principal de 4D não é recomendável porque poderia congelar toda a aplicação 4D.
Se o sinal já estiver no estado de sinalização (ou seja, a propriedade.signaled já é true), a função devolve imediatamente, sem esperar.
A função devolve o valor da propriedade .signaled. Avaliar esse valor permite saber se a função retornou porque .trigger( ) foi chamado (.signaled é true) ou se o timeout expirou (.signaled é false).
O estado de um processo que espera um signal é
Waiting for internal flag.