O recurso está a ser carregado... Carregamento...

Fios

A plataforma de negociação de quantidade FMZ realmente suporta a função multi-threaded doJavaScriptA estratégia linguística é desenvolvida a partir da base do sistema e tem por objectivo:

Objetos Orientações Observações
Filamentos Objeto global multithreaded Funções dos membros:Thread, getThread, mainThread, etc.
Fios Objeto de linha Funções dos membros:peekMessage, postMessage, join, etc.
ThreadLock Objeto de bloqueio de fio Funções dos membros:acquire, release. Eles podem ser passados para o ambiente do thread como parâmetros da função de execução do thread.
ThreadEvent Objeto evento Funções dos membros:set, clear, wait, isSet. Eles podem ser passados para o ambiente do thread como um parâmetro da função de execução do thread.
ThreadCondição Objeto de condição Funções dos membros:notify, notifyAll, wait, acquire, release. Eles podem ser passados para o ambiente do thread como um parâmetro da função de execução do thread.
ThreadDict Objeto do dicionário Funções dos membros:get, set. Eles podem ser passados para o ambiente do thread como parâmetros da função de execução do thread.

Filamentos

Othreadingobject é uma ferramenta global de gerenciamento de multithreading que fornece funções como criar threads concorrentes, bloqueios de thread e objetos de condição.threadingEste objeto só é suportado peloJavaScriptEstratégia linguística.

Fios

OThread()função é usada para criar tópicos simultâneos.

OThread()função retorna aThreadobjeto, que é utilizado para gerir threads criados em simultâneo, comunicação de threads, etc.

ThreadObjeto

Thread ((func,...args) Apresentação (s)

O parâmetrofuncé uma função para execução simultânea (passada por referência), e suporta a passagem de funções anônimas.funcpode aceitar múltiplos parâmetros, que serão transmitidos através de...argsPortanto, a lista de parâmetros defuncdeve ser coerente com...args.

Função verdade função O parâmetroargé o parâmetro real passado parafunc(ou seja, a função de execução de thread simultânea) quando a chamada de retorno é executada; pode haver vários parâmetrosarg, e a lista de parâmetros defuncdeve ser coerente com...args.

arg Falso cadeia, número, bool, objeto, matriz, função, valor nulo e outros tipos suportados pelo sistema O parâmetroitemé uma matriz contendo as referências de função e seus parâmetros a serem executados simultaneamente.itemOs parâmetros podem ser transmitidos ao chamar oThread function.

item verdade matriz

function test1(a, b, c) {
    Log("test1:", a, b, c)
}

function main() {
    var t1 = threading.Thread(test1, 1, 2, 3)
    var t2 = threading.Thread(function (msg) {
        Log("msg:", msg)
    }, "Hello thread2")

    t1.join()
    t2.join()
}

Crie tópicos simultâneos para uma função personalizada e uma função anônima.

function test1(msg) {
    Log("msg:", msg)
    test2("Hello test2")
}

function main() {
    var t1 = threading.Thread(
        [function(a, b, c) {Log(a, b, c)}, 1, 2, 3], 
        [test1, "Hello test1"], 
        [`function test2(msg) {Log("msg:", msg)}`])

    t1.join()
}

Utilize oThread(...items)forma para criar threads simultâneos e executar múltiplas funções sequencialmente.

function testFunc1(p) {
    Log("testFunc1 p:", p)
}

function main() {
    threading.Thread(function(pfn) {
        var threadName = threading.currentThread().name()
        var threadId = threading.currentThread().id()
        pfn(`in thread threadName: ${threadName}, threadId: ${threadId}`)
    }, testFunc1).join()
}

Suporta a passagem de parâmetros para funções executadas simultaneamente.

function ml(input) {
    const net = new brain.NeuralNetwork()
    net.train([
        { input: [0, 0], output: [0] },
        { input: [0, 1], output: [1] },
        { input: [1, 0], output: [1] },
        { input: [1, 1], output: [0] },
    ])
    return net.run(input)
}

function main() {
    var ret = threading.Thread([ml, [1, 0]], [HttpQuery("https://unpkg.com/brain.js")]).join()

    // ret: {"id":1,"terminated":false,"elapsed":337636000,"ret":{"0":0.9339330196380615}}
    Log(ret)
}

Ele suporta a passagem de cadeias de funções e pode importar bibliotecas externas dinamicamente para computação simultânea.

A função do fiofuncpassaram para oThread()A função para execução simultânea é executada em um ambiente isolado, de modo que as variáveis fora do thread não podem ser diretamente referenciadas, e a compilação falhará quando referenciada. Ao mesmo tempo, as referências a outras funções de fechamento não são suportadas dentro do thread. Todas as APIs fornecidas pela plataforma podem ser chamadas dentro do thread, mas outras funções definidas pelo usuário não podem ser chamadas.

Ele suporta sistema de backtesting e ambiente de negociação ao vivo. Todas as funções relacionadas ao thread simultâneo são apenas suportadas como compatibilidade de código no sistema de backtesting e não serão executadas por threads simultâneos, por isso não serão repetidas neste capítulo.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop event}

getThread

OgetThread()função é usada para obter o objeto de thread com base no ID de thread especificado.

OgetThread()função retorna oThreadObjeto com o threadId especificado pelo parâmetro

ThreadObjeto

getThread ((ThreadId)

O parâmetrothreadIdé o ID do objeto do thread. Obtenha o objeto do thread correspondente especificando o parâmetro.

threadId verdade Número

function main() {
    var t1 = threading.Thread(function () {
        Log("Hello thread1")
    })
    // The Thread object has a method: id(), which is used to get the thread ID. You can view the section of the document corresponding to the Thread object.
    var threadId = t1.id()
    var threadName = t1.name()
    Log("threadId:", threadId, ", threadName:", threadName)
    
    var t2 = threading.getThread(threadId)
    Log(`threadId == t2.id():`, threadId == t2.id(), `, threadName == t2.name():`, threadName == t2.name())
}

Obtenha o objeto de thread especificado atravésthreadId.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

Se o thread que você quer obter foi executado e liberado, você não pode usarthreading.getThread(threadId)para obter o objeto do fio do fio.

{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}

principalThread

OmainThread()A função é utilizada para obter o objeto do fio do fio principal, ou seja, o fio onde omain()A função na estratégia está localizada.

OmainThread()função retorna o objeto thread do thread principal.

ThreadObjeto

mainThread ((()

function main() {
    Log("The threadId of the main thread:", threading.mainThread().id())
}

Apanha oThreadObjeto do fio principal e saída dothreadIdda linha principal.

function test() {
    Log("Output the main thread ID in the test function:", threading.mainThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

O objeto do fio do fio principal também pode ser obtido em fios concorrentes.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop Loop}

corrente

OcurrentThread()função é usada para obter o objeto thread do thread atual.

OcurrentThread()função retorna o objeto thread do thread atual.

ThreadObjeto

CurrentThread ((()

function test() {
    Log("Id of the current thread:", threading.currentThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

Apanha oThreadobjeto do fio de corrente e saída dothreadIddo fio corrente.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threading/threading/Dict Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}

Bloqueio

OLock()A função é usada para criar um objeto de bloqueio de thread.

OLock()A função retorna um objeto de bloqueio de thread.

ThreadLockObjeto

Bloqueio

function consumer(productionQuantity, dict, lock) {
    for (var i = 0; i < productionQuantity; i++) {
        lock.acquire()
        var count = dict.get("count")        
        Log("consumer:", count)
        Sleep(1000)
        lock.release()
    }
}

function producer(productionQuantity, dict, lock) {
    for (var i = 0; i < productionQuantity; i++) {
        lock.acquire()
        dict.set("count", i)
        Log("producer:", i)
        Sleep(1000)
        lock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("count", -1)
    var lock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, lock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, lock)

    consumerThread.join()
    producerThread.join()
}

Dois tópicos simultâneos acessam um recurso comum.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threads/threading/ThreadThread}, {@fun/Threads/threads/threading/Condition Condition}, {@fun/Threads/threads/threading/Event Event}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop event}

Condição

OCondition()função é usada para criar um objeto de variável de condição, que é usado para alcançar a sincronização e comunicação entre threads em um ambiente simultâneo multi-threaded.Condition(), um thread pode esperar quando certas condições não são cumpridas até que outro thread notifique que a condição foi cumprida.

OCondition()função retorna aThreadCondition object.

ThreadConditionObjeto

Condição

function consumer(productionQuantity, dict, condition) {
    for (var i = 0; i < productionQuantity; i++) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            condition.wait()
        }
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        condition.release()
        Sleep(1000)
    }
}

function producer(productionQuantity, dict, condition) {
    for (var i = 0; i < productionQuantity; i++) {
        condition.acquire()
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        condition.notify()
        condition.release()
        Sleep(1000)
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var condition = threading.Condition()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, condition)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, condition)
    consumerThread.join()
    producerThread.join()
}

Dois tópicos simultâneos acessam um recurso comum.

O sistema de backtesting não implementa esta funcionalidade, ele apenas a define.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}

Evento

OEvent()função é usada para criar umevento de threadobjeto, que é usado para a sincronização entre os tópicos, permitindo que um tópico espere por notificação ou sinal de outro tópico.

OEvent()função retorna aThreadEvent object.

ThreadEventObjeto

Eventos

function consumer(productionQuantity, dict, pEvent, cEvent) {
    for (var i = 0; i < productionQuantity; i++) {
        while (dict.get("array").length == 0) {
            pEvent.wait()
        }
        if (pEvent.isSet()) {
            pEvent.clear()
        }

        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cEvent.set()
        Sleep(1000)
    }
}

function producer(productionQuantity, dict, pEvent, cEvent) {
    for (var i = 0; i < productionQuantity; i++) {
        while (dict.get("array").length != 0) {
            cEvent.wait()
        }
        if (cEvent.isSet()) {
            cEvent.clear()
        }

        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)        
        pEvent.set()       
        Sleep(1000)
    }
}

function main() {    
    var dict = threading.Dict()
    dict.set("array", [])
    var pEvent = threading.Event()
    var cEvent = threading.Event()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pEvent, cEvent)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pEvent, cEvent)

    consumerThread.join()
    producerThread.join()
}

Dois tópicos simultâneos acessam um recurso comum.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop eventop}

Dicionário

ODict()função é usada para criar um objeto de dicionário para passar para tópicos concorrentes.

ODict()função retorna aThreadDict object.

ThreadDictObjeto

Dicionário

function threadFun1(obj) {
    obj["age"] = 100
    while (true) {
        Log("threadFun1 obj:", obj)
        Sleep(5000)
    }
}

function threadFun2(obj) {
    while (true) {
        Log("threadFun2 obj:", obj)
        Sleep(5000)
    }
}

function main() {
    var obj = {"age": 10}
    var t1 = threading.Thread(threadFun1, obj)
    var t2 = threading.Thread(threadFun2, obj)
    t1.join()
    t2.join()    
}

Passar um objeto normal para a função de execução de thread simultâneo para testar se modificar o valor da chave do objeto causará alterações no valor da chave do objeto em outros threads.

function threadFun1(threadDict) {
    threadDict.set("age", 100)
    while (true) {
        Log(`threadFun1 threadDict.get("age"):`, threadDict.get("age"))
        Sleep(5000)
    }
}

function threadFun2(threadDict) {
    while (true) {
        Log(`threadFun2 threadDict.get("age"):`, threadDict.get("age"))
        Sleep(5000)
    }
}

function main() {
    var threadDict = threading.Dict()
    threadDict.set("age", 10)
    var t1 = threading.Thread(threadFun1, threadDict)
    var t2 = threading.Thread(threadFun2, threadDict)

    t1.join()
    t2.join()    
}

Passa oThreadDictObjeto criado peloDict()função para a função de execução de thread simultânea, e testar se a modificação do valor da chave do objeto fará com que o valor da chave do objeto em outros threads mude.

Quando um objeto comum é passado para uma função de thread concorrente, ele é passado como uma cópia profunda.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/event}, {@fun/Threads/threading/threading/thread}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop}

pendente

Opendingfunção é usada para obter o número de tópicos concorrentes em execução no programa de estratégia atual.

Opending()função retorna o número de tópicos simultâneos que o programa de estratégia atual está executando.

Número

pendente

function threadFun1() {
    Log("threadFun1")
    Sleep(3000)
}

function threadFun2() {
    for (var i = 0; i < 3; i++) {
        LogStatus(_D(), "print from threadFun2")
        Sleep(3000)
    }
}

function main() {
    Log(`begin -- threading.pending():`, threading.pending())

    var t1 = threading.Thread(threadFun1)
    var t2 = threading.Thread(threadFun2)
    Log(`after threading.Thread -- threading.pending():`, threading.pending())

    t1.join()
    t2.join()
    Log(`after thread.join -- threading.pending():`, threading.pending())
}

Crie dois tópicos em execução simultânea e chame opending()função em diferentes pontos de tempo.

Quando a estratégiamain()função começa a executar, chamando a funçãopending()diretamente irá retornar 1, porque o fio principal onde a estratégiamain()função está localizado é também um fio pendente.

Suporta sistema de backtesting e ambiente de negociação ao vivo.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/Condition Condition}, {@fun/Threads/threading/Event Event}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/eventLoop}

Fios

Threadobjetos podem ser criados ou devolvidos porthreading.Thread(), threading.getThread(), threading.mainThread(), ethreading.currentThread().

PeekMensagem

OpeekMessage()função é usada para obter uma mensagem de um thread.

OpeekMessage()função retorna a mensagem recebida pelo thread associado ao objeto do thread atual.

string, number, bool, object, array, null value e outros tipos suportados pelo sistema

PeekMessagem() PeekMessage ((timeout)

O parâmetrotimeouté a definição de timeout. Ele irá bloquear e esperar o número de milissegundos definidos pelo parâmetro e retornar dados. Se não houver dados e o timeout exceder o limite, um valor nulo será devolvido. Setimeouté definido como 0 ou otimeoutParâmetro não é passado, significa que o processo irá bloquear e esperar até que os dados sejam recebidos do canal.timeoutse for definido em -1, significa que o processo não bloqueará e retornará dados imediatamente.

tempo de espera Falso Número

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })

    while (true) {
        var msg = threading.currentThread().peekMessage()
        Log("main peekMessage():", msg)
        if (msg == 9) {
            break
        }
        Sleep(1000)
    }

    t1.join()
}

Enviar mensagens para o tópico principal de um tópico concorrente.

Quando escrevemos programas, precisamos prestar atenção aos problemas de thread deadlock.

{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name}, {@Threads/Threads/eventLoop eventLoop}

PostMensagem

OpostMessage()função é usada para enviar uma mensagem para um tópico.

PostMessage ((msg)

O parâmetromsgé a mensagem a ser enviada.

msg verdade Qualquer tipo suportado pelo sistema, como string, número, bool, objeto, matriz, função, valor nulo, etc.

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })
    for (var i = 0; i < 10; i++) {
        var event = threading.mainThread().eventLoop()
        Log("main event:", event)
        Sleep(500)
    }
    t1.join()
}

Enviar mensagens em tópicos simultâneos e usareventLoop()para receber notificações de mensagens.

function main() {
    threading.mainThread().postMessage(function(msg) {
        Log("func from mainThread, msg:", msg)
    })
    
    threading.Thread(function() {
        var func = threading.mainThread().peekMessage()
        func("in " + threading.currentThread().name())
    }).join()
}

Suporta enviar uma função.

Quando uma função de execução de threads chama opostMessage()A função para enviar um sinal ou dados, um evento de mensagem também é gerado.eventLoop()Função para receber notificações de mensagens.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

juntar-se

Ojoin()A função é usada para esperar que o thread saia e recupere os recursos do sistema.

OThreadRetObjetocontém dados sobre o resultado da execução. As propriedades incluem:

  • Identificação: Identificação do fio.
  • terminado: se o fio é forçado a terminar.
  • decorrido: tempo de execução do fio em nanossegundos.
  • ret: O valor de retorno da função thread.

ThreadRetObjeto

Junte-se. Participação (timeout)

OtimeoutO parâmetro é usado para definir o timeout em milissegundos para esperar que o fio termine.timeoutParâmetro é definido em 0 ou otimeoutParâmetro não definido, ojoin()função irá bloquear e esperar até que o tópico terminar de executar.timeoutParâmetro definido em -1, ojoin()A função irá voltar imediatamente.

tempo de espera Falso Número

function main() {
    var t1 = threading.Thread(function() {
        Log("Hello thread1")
        Sleep(5000)
    })

    var ret = t1.join(1000)
    Log("ret:", ret)   // ret: undefined

    ret = t1.join()
    Log("ret:", ret)   // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}

Teste ojoin()Função de timeout e saída do valor de retorno.

Ojoin()Função out times e returnsundefined.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

encerrar

Oterminate()A função é usada para encerrar forçosamente um thread e liberar os recursos de hardware utilizados pelo thread criado.

Terminar (((

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 i:", i)
            Sleep(1000)
        }
    })

    Sleep(3000)
    t1.terminate()
    Log("after t1.terminate()")

    while (true) {
        LogStatus(_D())
        Sleep(1000)
    }
}

Terminar a execução de um thread com força.

Para fios que são forçosamente terminados peloterminate()A função, já não podemos usar ojoin()Função para esperar que eles terminem.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

getData

OgetData()A função é usada para acessar variáveis registradas no ambiente do thread.join()função (em espera de saída bem sucedida) e não executou oterminate()Função (terminar o fio à força).

OgetData()função retorna o valor da chave correspondente aokeyParâmetro no par chave-valor armazenado no contexto do thread atual.

string, number, bool, object, array, null value e outros tipos suportados pelo sistema

GetData (em inglês) GetData (chave)

OkeyParâmetro é o nome da chave do par chave-valor armazenado.

Chave verdade cordel

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 5; i++) {
            threading.currentThread().setData("count", i)
            Log(`setData("count"):`, i)
            Sleep(1000)
        }
    })
    for (var i = 0; i < 5; i++) {
        var count = threading.getThread(t1.id()).getData("count")
        Log(`getData("count"):`, count)
        Sleep(1000)
    }
    t1.join()
}

Gravar o valor da chavecountno ambiente de thread simultâneo, e depois ler o valor chave decountno assunto principal.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

setData

OsetData()função é usada para armazenar variáveis no contexto do thread.

setData ((chave, valor)

OkeyO parâmetro é utilizado para especificar o nome da chave do par chave-valor armazenado.

Chave verdade cordel OvalueO parâmetro é utilizado para especificar o valor da chave do par chave-valor armazenado.

Valor verdade Qualquer tipo suportado pelo sistema, como string, número, bool, objeto, matriz, função, valor nulo, etc.

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Sleep(1000)
    Log(`t1.getData("data"):`, t1.getData("data"))
    t1.join()
}

Configure o par chave-valor no thread concorrente e leia o par chave-valor no thread principal.

function main() {
    threading.mainThread().setData("func2", function(p) {
        Log("func2 p:", p)
    })
    
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("func1", function(p) {
            Log("func1 p:", p)
        })
    
        var func2 = threading.mainThread().getData("func2")
        func2("test2")
    })
    
    Sleep(1000)
    var func1 = t1.getData("func1")
    func1("test1")
    t1.join()
}

Suporta a passagem de valores-chave em funções.

Os dados são válidos quando o tópico não executou ojoin()função (em espera de saída bem sucedida) e não executou oterminate()Função (terminando o fio forçosamente).valuedeve ser uma variável serializável.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

Identificação

Oid()função é usada para retornar othreadIdda instância de objeto multithread atual.

O valor de retorno doid()função éthreadId.

Número

id()

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.id():`, t1.id())
    t1.join()
}

Crie um thread em execução simultânea e faça a saídathreadIddeste fio concorrente no fio principal.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

nome

Oname()função é usada para retornar o nome da instância atual de objeto multithreaded.

Oname()função retorna o nome do thread concorrente.

cordel

Nome (s)

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.name():`, t1.name())  // t1.name(): Thread-1
    t1.join()
}

Crie um tópico concorrente e produza o nome do tópico concorrente no tópico principal.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/eventLoop eventLoop}

eventLoop

OeventLoop()função é usada para ouvir eventos recebidos pelo thread.

OeventLoop()função retorna a informação do evento recebida pelo thread atual.Estrutura de informação de eventos.

Objeto, valor nulo

EventLoop (em inglês) EventLoop (tempo de espera)

O parâmetrotimeouté a definição de timeout em milissegundos.timeoutSe for definido como 0, ele vai esperar que um evento ocorra antes de retornar. Se for maior que 0, ele irá definir o evento de espera de tempo. Se for menor que 0, ele retornará o último evento imediatamente.

tempo de espera Falso Número

function main() {
    var t1 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop()     // Blocking wait
            // 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
            Log(_D(), "thread1 eventMsg:", eventMsg)
        }
    })

    var t2 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(-1)   // Return immediately
            Log(_D(), "thread2 eventMsg:", eventMsg)
            Sleep(5000)
        }
    })

    var t3 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
            Log(_D(), "thread3 eventMsg:", eventMsg)
        }
    })

    t1.postMessage("Hello ", t1.name())
    t2.postMessage("Hello ", t2.name())
    t3.postMessage("Hello ", t3.name())
    t1.join()
    t2.join()
    t3.join()
}

Se o timeout ocorrer ou a função retornar imediatamente, o valor de saída é nulo.

O mecanismo de tratamento doeventLoop()função é o mesmo que a função globalEventLoop().

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}

ThreadLock

Objeto de bloqueio de thread, utilizado para processamento de sincronização multi-thread.

adquire

Oacquire()A função é utilizada para solicitar um bloqueio (bloqueio) do fio.

Adquirir (((

Por favor, consulte othreading.Lock()secção para exemplos.

Oacquire()A função é usada para solicitar um bloqueio de thread.acquire()Função de um objeto de bloqueio de thread, ele tenta adquirir o bloqueio. Se o bloqueio não está atualmente mantido por outro thread, o thread chamador adquire o bloqueio com sucesso e continua a execução. Se o bloqueio já está mantido por outro thread, o thread chamadoracquire()será bloqueado até que a fechadura seja liberada.

Não, não, não, não, não.

libertação

Orelease()A função é utilizada para liberar um bloqueio de fio (desbloqueio).

libertação

function consumer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        pLock.acquire()
        cLock.acquire()
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cLock.release()
        Sleep(1000)
        pLock.release()
    }
}

function producer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        cLock.acquire()   // cLock.acquire() placed after pLock.acquire() will not cause deadlock
        pLock.acquire()   
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        pLock.release()
        Sleep(1000)
        cLock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var pLock = threading.Lock()
    var cLock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)

    consumerThread.join()
    producerThread.join()
}

Teste de cenários de impasse

Deve notar-se que a utilização inadequada de fechaduras de fios pode conduzir a um impasse.

Não, não, não, não, não.

ThreadEvent

Objeto de evento, utilizado para notificação e sinal de evento multi-threaded.

Conjunto

Oset()A função é utilizada para notificar eventos (sinais definidos).

Conjunto

Por favor, consulte othreading.Event()secção para exemplos.

Se o sinal tiver sido definido usandoset()Temos de limpar o sinal e voltar a colocá-lo.

{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

limpo

Oclear()A função é utilizada para eliminar o sinal.

Está tudo limpo.

Por favor, consulte othreading.Event()secção para exemplos.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

- Espera.

Owait()A função é utilizada para definir um evento (sinal) de espera, e bloqueará antes do evento (sinal) ser definido; suporta a definição de um parâmetro de timeout.

Owait()A função retorna se o timeout ocorreu. Se sim, retorna um valor verdadeiro.

Bool

Espere. Espere (Timeout)

OtimeoutO parâmetro é utilizado para definir o tempo de espera em milissegundos.

tempo de espera Falso Número

function main() {
    var event = threading.Event()
    var t1 = threading.Thread(function(event) {
        var ret = event.wait(100)
        Log(`event.wait(100):`, ret)
        ret = event.wait()
        Log(`event.wait():`, ret)
    }, event)

    Sleep(1000)
    event.set()
    t1.join()
}

Teste o valor de retorno dowait() function.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}

isSet

OisSet()Função utilizada para determinar se um evento (sinal) foi definido.

OisSet()A função retorna se o evento (sinal) foi definido; se o evento (sinal) foi definido, retorna um valor verdadeiro.

Bool

isSet()

Por favor, consulte othreading.Event()secção para exemplos.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}

ThreadCondição

Objeto de condição, utilizado para sincronização multi-thread.

Notificar

Onotify()A função é usada para acordar um tópico em espera (se houver).wait()O método vai despertar.

Notificar

function consumer(dict, condition) {
    while (true) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
            condition.wait()
        }
        var arr = dict.get("array")
        var num = arr.shift()
        Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
        dict.set("array", arr)
        Sleep(1000)
        condition.release()
    }
}

function main() {
    var condition = threading.Condition()
    var dict = threading.Dict()
    dict.set("array", [])
    var t1 = threading.Thread(consumer, dict, condition)
    var t2 = threading.Thread(consumer, dict, condition)
    var t3 = threading.Thread(consumer, dict, condition)
    Sleep(1000)
    var i = 0
    while (true) {
        condition.acquire()
        var msg = ""
        var arr = dict.get("array")
        var randomNum = Math.floor(Math.random() * 5) + 1
        if (arr.length >= 3) {
            condition.notifyAll()
            msg = "notifyAll"
        } else {
            arr.push(i)
            dict.set("array", arr)
            if (randomNum > 3 && arr.length > 0) {
                condition.notify()
                msg = "notify"
            } else {
                msg = "pass"
            }
            i++
        }

        Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
        condition.release()
        Sleep(1000)
    }
}

Utilize onotify()Função para acordar o fio de espera.

Onotify()Função acorda um fio na fila de espera.

Quando onotify()Função acorda um fio, o fio vai recuperar o bloqueio do fio.

{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

Notificar a todos

OnotifyAll()A função acorda todos os fios em espera.

Avise a todos

Por favor, consulte oThreadCondition.notify()secção para exemplos.

OnotifyAll()A função acorda todos os fios em espera um por um, e os fios despertados recuperam o bloqueio do fio.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

- Espera.

Owait()A função é usada para fazer um fio esperar sob certas condições projetadas.

Espere.

Por favor, consulte oThreadCondition.notify()secção para exemplos.

Owait()A função liberta o bloqueio do fio e recupera o bloqueio do fio quando acordado.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

adquire

Oacquire()A função é utilizada para solicitar um bloqueio (bloqueio) do fio.

Adquirir (((

Por favor, consulte oThreadCondition.notify()secção para exemplos.

Antes de utilizarwait(), você precisa solicitar o bloqueio de thread (bloqueio) do objeto de condição atual.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}

libertação

Orelease()A função é utilizada para liberar um bloqueio de fio (desbloqueio).

libertação

Por favor, consulte oThreadCondition.notify()secção para exemplos.

Após utilizaçãowait(), precisamos liberar o thread lock (desbloquear) do objeto de condição atual.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}

ThreadDict

Objeto de dicionário, usado para partilha de dados.

- Não.

Oget()função é usada para obter o valor chave registrado no objeto do dicionário.

Oget()função retorna o valor da chave especificada pelokey parameter.

string, number, bool, object, array, null value e outros tipos suportados pelo sistema

Get (chave)

OkeyO parâmetro é utilizado para especificar o nome da chave correspondente à chave a obter.

Chave verdade cordel

function main() {
    var event = threading.Event()
    var dict = threading.Dict()
    dict.set("data", 100)
    
    var t1 = threading.Thread(function(dict, event) {
        Log(`thread1, dict.get("data"):`, dict.get("data"))
        
        event.set()
        event.clear()
        
        event.wait()
        Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
    
        dict.set("data", 0)
    }, dict, event)
    
    event.wait()
    
    dict.set("data", 99)
    
    event.set()
    event.clear()
    
    t1.join()
    Log(`main thread, dict.get("data"):`, dict.get("data"))
}

Usar objetos de evento para notificar threads para ler e modificar dados.

Não, não, não, não.

Conjunto

Oset()A função é utilizada para definir um par chave-valor.

Set (chave, valor)

O parâmetrokeyé utilizado para definir o nome da chave a modificar.

Chave verdade cordel O parâmetrovalueÉ utilizada para definir o valor chave a modificar.

Valor verdade cadeia, número, bool, objeto, matriz, função, valor nulo e outros tipos suportados pelo sistema

function main() {
    var dict1 = threading.Dict()
    dict1.set("func1", function(p) {
        Log("func1 p:", p)
    })
    
    threading.Thread(function(dict1) {
        var func1 = dict1.get("func1")
        func1("test")
    }, dict1).join()
}

Suporta a passagem de valores-chave em funções.

Não, não, não, não.

Configurações da rede Web3

2019 FMZ - Todos os direitos reservados