Permet aux programmes de stratégie d’être réellement exécutés simultanément et ajoute la prise en charge du multithreading au niveau du système aux stratégies JavaScript

Lors du développement de stratégies sur FMZ à l’aide du langage JavaScript, l’architecture de la stratégie est un sondage. S’il existe un scénario de conception simultané, il estexchange.GoLes fonctions sont utilisées pour effectuer des appels simultanés à certaines interfaces, répondant ainsi aux besoins de certains scénarios simultanés. Cependant, si vous souhaitez créer un thread séparé pour effectuer une série d’opérations, ce n’est pas possible. Par exemple, comme dans Python, utilisezthreadingLa bibliothèque est utilisée pour effectuer certaines conceptions simultanées.

Sur la base de cette demande, la plateforme FMZ a mis à niveau le système sous-jacent. Un véritable support multithread a également été ajouté au langage JavaScript. Les fonctionnalités détaillées incluent :

• Créez des threads pour exécuter simultanément des fonctions personnalisées.
• Communication inter-thread.
• Partager des variables stockées entre les threads.
• Attendez que le thread termine son exécution, récupérez les ressources et renvoyez le résultat de l’exécution.
• Forcer le thread à se terminer et à récupérer des ressources.
• Obtenez l’ID de thread actuel dans une fonction d’exécution de thread simultanée.

Ensuite, l’éditeur vous amènera à comprendre chaque fonction une par une.

Créer des threads pour exécuter simultanément des fonctions personnalisées

__ThreadUne fonction peut créer un thread pour exécuter une fonction simultanément. Par exemple, vous devez créer une fonction concurrentefunc1，func1A quoi sert la fonction ? Nous pouvons le laisser s’accumuler de 0 à 9. Afin de voir ce processus d’accumulation progressif, utilisez une boucle for dans la fonction func1 pour faire une pause à chaque fois (la fonction Sleep est utilisée pour dormir pendant un certain nombre de millisecondes) pendant une certaine période du temps.

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

Dans des scénarios d’application réels, nous pouvons effectuer des requêtes http simultanées comme ceci :

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

Attendez que le thread termine son exécution, récupérez les ressources et renvoyez le résultat de l’exécution

Dans l’exemple ci-dessus, nous l’avons finalement utilisé dans la fonction principale__threadJoinFonction permettant d’attendre que les threads simultanés terminent leur exécution, variableretreprendre__threadJoinLa valeur de retour de la fonction. Nous imprimons cette valeur de retour et observons les résultats spécifiques de l’exécution de ce thread simultané.

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

Forcer le thread à se terminer et recycler les ressources

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
}

En reprenant l’exemple précédent, après avoir créé le thread, vous pouvez forcer l’exécution du thread à se terminer après avoir attendu 1 seconde.

Communication inter-thread

La communication inter-thread est principalement utilisée__threadPostMessageFonctions et__threadPeekMessagefonction. Regardons l’exemple simple suivant :

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

__threadPostMessageLa fonction est utilisée pour envoyer un message à un thread. Le premier paramètre est l’ID du thread spécifique auquel le message est envoyé, et le deuxième paramètre est le message à envoyer, qui peut être une chaîne, un nombre, un tableau, un objet JSON, etc. Vous pouvez envoyer des messages au thread principal dans une fonction de thread simultané. L’ID du thread principal est défini sur 0.

__threadPeekMessageLa fonction permet de surveiller les messages envoyés par un thread. Vous pouvez définir un délai d’attente (en millisecondes) ou le définir à 0 pour bloquer le thread et surveiller jusqu’à ce qu’un message soit envoyé avant de revenir.

Bien sûr, sauf pour les threads simultanés communiquant avec le thread principal. Les threads simultanés peuvent également communiquer directement entre eux.

Obtenir l’ID de thread actuel dans une fonction d’exécution de thread simultanée

Dans l’exemple ci-dessus, en utilisantvar id = __threadId()，__threadId()La fonction peut obtenir l’ID du thread actuel.

Partage de variables stockées entre les threads

En plus de la communication entre les threads, vous pouvez également utiliser des variables partagées pour l’interaction.

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

Ce qui précède est une démonstration simple de toutes les fonctions.