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}

Configurações da rede Fios