Fazer com que as políticas sejam executadas em simultâneo, aumentando o suporte a múltiplos fios no fundo do sistema para as políticas do JavaScript

Fazer com que as políticas sejam executadas em simultâneo, aumentando o suporte a múltiplos fios no fundo do sistema para as políticas do JavaScript

Quando se desenvolve uma política em FMZ usando a linguagem JavaScript, a estrutura da política é consultada.exchange.GoFunções para realizar chamadas simultâneas de algumas interfaces, o que atende às necessidades de algumas cenas simultâneas. Mas não é possível se quiser realmente criar um thread separadamente para executar uma série de operações, como no Python, por exemplo.threadingO blogueiro também escreveu sobre o assunto:

Com base nessa necessidade, a plataforma FMZ atualizou o sistema baseado em JavaScript.

• Criar e executar funções personalizadas em simultâneo.
• A comunicação entre fios.
• Variações armazenadas entre fios compartilhados.
• Esperar que a execução do thread termine o recurso de recuperação e retorne o resultado da execução.
• O que é que isso significa para o mundo?
• Obter o ID do thread atual em funções executadas em simultâneo.

A seguir, um pequeno tutorial que irá levá-lo a compreender cada uma delas individualmente.

Criar funções personalizadas para execução simultânea de threads

__ThreadUma função pode ser criada em um thread para executar uma função em simultâneo. Por exemplo, é necessário criar uma função em simultâneofunc1，func1O que é que a função faz? Podemos fazer com que ela aumente de 0 para 9, e para ver este processo de adição gradual, a função func1 usa o ciclo for para pausar a cada vez (a função Sleep é usada para dormir por um certo número de milissegundos) por um determinado 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 um cenário de aplicação real, podemos fazer uma solicitação HTTP em simultâneo:

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))
    })
}

Esperar que o thread termine de recuperar recursos e retorne resultados de execução

E o exemplo acima é o último que usamos na função principal.__threadJoinFunções que esperam a execução de linhas em simultâneo, variáveisretRecebido__threadJoinO valor de retorno da função, que nós imprimimos, pode ser observado como o resultado específico da execução desse fio em simultâneo.

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

O que é que isso significa para nós?

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
}

Ou, no exemplo que acabei de dar, depois de criar um thread, você pode forçar o término da execução do thread depois de esperar 1 segundo.

Comunicação entre fios

Comunicação entre fios é usada principalmente__threadPostMessageFunções e__threadPeekMessageFunções. Vejamos um 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 mensagens para um determinado thread, sendo que o primeiro parâmetro é o ID específico do thread para o qual é enviado, e o segundo parâmetro é a mensagem enviada, que pode ser uma string, um valor numérico, uma matriz, um objeto JSON, etc.; pode ser enviada para o thread principal em funções de thread paralelas, cujo ID é definido como 0;

__threadPeekMessageA função é usada para escutar mensagens enviadas por um fio, pode ser definida como um tempo de espera (millisecundos) ou pode ser definida como 0 para bloquear e continuar escutando até que uma mensagem seja devolvida.

Claro, além da comunicação entre os fios paralelos e os fios principais, também é possível a comunicação direta entre os fios paralelos.

Obter o ID do thread atual em funções executadas em simultâneo

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

Variáveis armazenadas entre fios compartilhados

Além da comunicação entre fios, pode-se interagir com variáveis compartilhadas.

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的值
}

A partir de agora, o Google já está a trabalhar com o Google Maps.