Ermöglicht die tatsächlich gleichzeitige Ausführung von Richtlinienprogrammen und ergänzt JavaScript-Richtlinien um Multithreading-Unterstützung auf Systemebene.

Bei der Entwicklung von Strategien auf FMZ unter Verwendung der Sprache JavaScript erfolgt die Strategiearchitektur per Polling. Wenn es ein paralleles Design-Szenario gibt, ist esexchange.GoFunktionen werden verwendet, um gleichzeitige Aufrufe einiger Schnittstellen durchzuführen und so die Anforderungen einiger gleichzeitiger Szenarien zu erfüllen. Wenn Sie jedoch einen separaten Thread erstellen möchten, um eine Reihe von Operationen auszuführen, ist dies nicht möglich. Verwenden Sie beispielsweise wie in PythonthreadingDie Bibliothek wird für einige parallele Entwürfe verwendet.

Basierend auf dieser Nachfrage hat die FMZ-Plattform das zugrunde liegende System aktualisiert. Der JavaScript-Sprache wurde außerdem echte Multithreading-Unterstützung hinzugefügt. Zu den detaillierten Funktionen gehören:

• Erstellen Sie Threads, um benutzerdefinierte Funktionen gleichzeitig auszuführen.
• Inter-Thread-Kommunikation.
• Geben Sie gespeicherte Variablen zwischen Threads frei.
• Warten Sie, bis die Ausführung des Threads abgeschlossen ist, fordern Sie Ressourcen zurück und geben Sie das Ausführungsergebnis zurück.
• Erzwingt die Beendigung des Threads und fordert Ressourcen zurück.
• Holen Sie sich die aktuelle Thread-ID in einer Funktion zur gleichzeitigen Thread-Ausführung.

Anschließend erklärt Ihnen der Editor nacheinander alle Funktionen.

Erstellen Sie Threads, um benutzerdefinierte Funktionen gleichzeitig auszuführen

__ThreadEine Funktion kann einen Thread erstellen, um eine Funktion gleichzeitig auszuführen. Sie müssen beispielsweise eine gleichzeitige Funktion erstellenfunc1，func1Was macht die Funktion? Wir können es von 0 bis 9 akkumulieren lassen. Um diesen allmählichen Akkumulationsprozess zu sehen, verwenden Sie eine for-Schleife in der Funktion func1, um jedes Mal für einen bestimmten Zeitraum eine Pause einzulegen (die Sleep-Funktion wird verwendet, um für eine bestimmte Anzahl von Millisekunden zu schlafen). der Zeit.

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

In tatsächlichen Anwendungsszenarien können wir gleichzeitige HTTP-Anfragen wie folgt stellen:

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

Warten Sie, bis die Ausführung des Threads abgeschlossen ist, fordern Sie Ressourcen zurück und geben Sie das Ausführungsergebnis zurück

Im obigen Beispiel haben wir es schließlich in der Hauptfunktion verwendet__threadJoinFunktion zum Warten auf die Ausführung paralleler Threads, variabelretübernehmen__threadJoinDer Rückgabewert der Funktion. Wir drucken diesen Rückgabewert aus und beobachten die spezifischen Ergebnisse der Ausführung dieses parallelen Threads.

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

Erzwingen Sie das Beenden des Threads und das Recyceln von Ressourcen

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
}

Wenn wir das vorherige Beispiel noch einmal aufgreifen: Nachdem Sie den Thread erstellt haben, können Sie die Beendigung der Thread-Ausführung nach einer Wartezeit von 1 Sekunde erzwingen.

Inter-Thread-Kommunikation

Die Inter-Thread-Kommunikation wird hauptsächlich verwendet__threadPostMessageFunktionen und__threadPeekMessageFunktion. Schauen wir uns das folgende einfache Beispiel an:

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

__threadPostMessageDie Funktion wird verwendet, um eine Nachricht an einen Thread zu senden. Der erste Parameter ist die ID des spezifischen Threads, an den die Nachricht gesendet wird, und der zweite Parameter ist die zu sendende Nachricht, die eine Zeichenfolge, eine Zahl, ein Array, ein JSON-Objekt usw. Sie können in einer parallelen Thread-Funktion Nachrichten an den Hauptthread senden. Die ID des Hauptthreads ist als 0 definiert.

__threadPeekMessageDie Funktion wird verwendet, um von einem Thread gesendete Nachrichten zu überwachen. Sie können ein Timeout (in Millisekunden) festlegen oder es auf 0 setzen, um den Thread zu blockieren und zu überwachen, bis eine Nachricht vorliegt, bevor er zurückkehrt.

Natürlich mit Ausnahme von gleichzeitigen Threads, die mit dem Hauptthread kommunizieren. Gleichzeitige Threads können auch direkt miteinander kommunizieren.

Abrufen der aktuellen Thread-ID in einer Funktion zur gleichzeitigen Thread-Ausführung

Im obigen Beispiel verwendenvar id = __threadId()，__threadId()Die Funktion kann die ID des aktuellen Threads abrufen.

Gemeinsame Nutzung von zwischen Threads gespeicherten Variablen

Neben der Kommunikation zwischen Threads können Sie zur Interaktion auch gemeinsame Variablen verwenden.

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

Das Obige ist eine einfache Demonstration aller Funktionen.