Permitir que programas de políticas sejam realmente executados simultaneamente e adicionar suporte multithreading em nível de sistema para políticas JavaScript

Ao desenvolver estratégias no FMZ usando a linguagem JavaScript, a arquitetura da estratégia é a pesquisa. Se houver um cenário de design simultâneo, éexchange.GoFunções são usadas para fazer chamadas simultâneas para algumas interfaces, atendendo assim às necessidades de alguns cenários simultâneos. No entanto, se você quiser criar um thread separado para executar uma série de operações, isso não é possível. Por exemplo, como em Python, usethreadingA biblioteca é usada para fazer alguns projetos simultâneos.

Com base nessa demanda, a plataforma FMZ atualizou o sistema subjacente. O verdadeiro suporte multithread também foi adicionado à linguagem JavaScript. Os recursos detalhados incluem:

• Crie threads para executar funções personalizadas simultaneamente.
• Comunicação entre threads.
• Compartilhe variáveis ​​armazenadas entre threads.
• Aguarde até que o thread termine a execução, recupere os recursos e retorne o resultado da execução.
• Força o encerramento do thread e recupera recursos.
• Obtenha o ID do thread atual em uma função de execução de thread simultânea.

Em seguida, o editor levará você a entender cada função, uma por uma.

Crie threads para executar funções personalizadas simultaneamente

__ThreadUma função pode criar um thread para executar uma função simultaneamente. Por exemplo, você precisa criar uma função simultâneafunc1，func1O que a função faz? Podemos deixá-lo acumular de 0 a 9. Para ver esse processo de acumulação gradual, use um loop for na função func1 para pausar cada vez (a função Sleep é usada para dormir por um certo número de milissegundos) por um certo período do tempo.

function func1(sleepMilliseconds) {
    var sum = 0 
    for (var i = 0 ; i < 10 ; i++) {
        sum += i 
        Sleep(sleepMilliseconds)
        Log("sum:", sum)
    }
    
    return sum
}

function main() {
    // 使用__Thread函数并发创建一个线程，参数200即为func1函数的参数，
    // 如果func1函数有多个参数，这里就具体传对应的参数
    var thread1Id = __Thread(func1, 200)
    
    // 这里需要等待线程Id为thread1Id的线程执行结果，否则main函数执行完就直接释放所有线程
    var ret = __threadJoin(thread1Id)
    Log("ret:", ret)
}

Em cenários de aplicação reais, podemos fazer solicitações http simultâneas como esta:

function main() {
    let threads = [
        "https://www.baidu.com",
        "https://www.163.com"
    ].map(function(url) {
        return __Thread(function(url) {
            Log("GET", url)
            return HttpQuery(url)
        }, url)
    })
    threads.forEach(function(tid) {
        Log(__threadJoin(tid))
    })
}

Aguarde até que o thread termine a execução, recupere os recursos e retorne o resultado da execução

No exemplo acima, finalmente o usamos na função principal__threadJoinFunção para esperar que threads concorrentes concluam a execução, variávelretassumir__threadJoinO valor de retorno da função. Imprimimos esse valor de retorno e observamos os resultados específicos da execução desse thread concorrente.

// id：线程ID，terminated：是否被强制停止，elapsed：耗时（纳秒），ret：线程执行函数的返回值
ret: {"id":1,"terminated":false,"elapsed":2004884301,"ret":45}

Forçar o término do thread e reciclar recursos

function func1(sleepMilliseconds) {
    var sum = 0 
    for (var i = 0 ; i < 10 ; i++) {
        sum += i 
        Sleep(sleepMilliseconds)
        Log("sum:", sum)
    }
    
    return sum
}

function main() {
    var thread1Id = __Thread(func1, 200)
    Sleep(1000)
    retThreadTerminate = __threadTerminate(thread1Id)
    Log(retThreadTerminate)   // true
}

Tomando novamente o exemplo anterior, depois de criar o thread, você pode forçar a execução do thread a terminar após esperar 1 segundo.

Comunicação entre threads

A comunicação entre threads é usada principalmente__threadPostMessageFunções e__threadPeekMessagefunção. Vejamos o seguinte exemplo simples:

function func1() {
    var id = __threadId()
    while (true) {
        var postMsg = "来自id:" + id + "的线程函数func1的消息"
        __threadPostMessage(0, postMsg)              // 发送消息到主线程
        var peekMsg = __threadPeekMessage()         // 接收来自其它线程的消息
        Log(peekMsg)
        Sleep(5000)
    }
}

function main() {
    var threadId = __Thread(func1)
    
    while (true) {
        var postMsg = "来自主线程的main函数的消息"
        __threadPostMessage(threadId, postMsg)
        var peekMsg = __threadPeekMessage()
        Log(peekMsg, "#FF0000")                     // #FF0000 ， 设置日志为红色用于区分
        Sleep(5000)
    }
}

__threadPostMessageA função é usada para enviar uma mensagem para um thread. O primeiro parâmetro é o ID do thread específico para o qual a mensagem é enviada, e o segundo parâmetro é a mensagem a ser enviada, que pode ser uma string, um número, um array, um objeto JSON, etc. Você pode enviar mensagens para o thread principal em uma função de thread concorrente. O ID do thread principal é definido como 0.

__threadPeekMessageA função é usada para monitorar mensagens enviadas por um thread. Você pode definir um timeout (em milissegundos) ou defini-lo como 0 para bloquear o thread e monitorar até que haja uma mensagem antes de retornar.

Claro, exceto para threads simultâneos que se comunicam com o thread principal. Threads simultâneos também podem se comunicar diretamente entre si.

Obter o ID do thread atual em uma função de execução de thread simultânea

No exemplo acima, usandovar id = __threadId()，__threadId()A função pode obter o ID do thread atual.

Compartilhando variáveis ​​armazenadas entre threads

Além da comunicação entre threads, você também pode usar variáveis ​​compartilhadas para interação.

function testFunc() {
    __threadSetData(0, "testFunc", 100)   // 储存在当前线程环境，键值对 testFunc : 100 
    Log("testFunc执行完毕")
}

function main() {
    // threadId为1 ，创建的threadId为1的线程会先执行完，只要线程资源没有被回收，线程本地储存的变量就有效
    var testThread = __Thread(testFunc)
    
    Sleep(1000)

    // 输出 in main, get testFunc: 100
    Log("in main, get testFunc:", __threadGetData(testThread, "testFunc"))   // 取出键名为testFunc的值
}

O texto acima é uma demonstração simples de todas as funções.