Faden

Die FMZ Quant Trading Plattform unterstützt wirklich die Mehrthread-Funktion derJavaScriptDas System setzt eine Sprachstrategie von Grund auf ein und verfolgt folgende Ziele:

Gegenstände	Anweisungen	Anmerkungen
Schleiffaden	Mehrthreadedes globales Objekt	Funktionen der Mitglieder:Thread, getThread, mainThread, usw.
Faden	Thread-Objekt	Funktionen der Mitglieder:peekMessage, postMessage, join, usw.
ThreadLock	Thread-Sperrobjekt	Funktionen der Mitglieder:acquire, release. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden.
ThreadEvent	Ereignisobjekt	Funktionen der Mitglieder:set, clear, wait, isSet. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden.
ThreadBedingung	Objekt der Bedingung	Funktionen der Mitglieder:notify, notifyAll, wait, acquire, release. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden.
ThreadDict	Wörterbuchobjekt	Funktionen der Mitglieder:get, set. Sie können als Parameter der Thread-Ausführungsfunktion in die Thread-Umgebung übergeben werden.

Schleiffaden

DiethreadingObject ist ein globales Multithreading-Management-Tool, das Funktionen wie das Erstellen von gleichzeitigen Threads, Thread-Locks und Condition-Objekten bietet.threadingObjekt. Dieses Objekt wird nur von derJavaScriptSprachstrategie.

Faden

DieThread()Funktion wird verwendet, um gleichzeitige Threads zu erstellen.

DieThread()Funktion gibt a zurückThreadObjekt, mit dem gleichzeitige Threads verwaltet werden, Threads kommunizieren usw.

ThreadGegenstand

Thread ((func,...args) Der Begriff "Thread" (Artikel)

Der Parameterfuncist eine Funktion zur gleichzeitigen Ausführung (übergeben durch Referenz) und unterstützt die Übergabe anonymer Funktionen.funckann mehrere Parameter akzeptieren, die durch...argsDaher wird die Parameterliste vonfuncdie in der Richtlinie...args.

Funktion wahr Funktion Der Parameterargist der tatsächliche Parameter, der anfunc(d. h. die Funktion zur gleichzeitigen Ausführung von Threads), wenn der Rückruf ausgeführt wird; es kann mehrere Parameter gebenarg, und die Parameterliste derfuncdie in der Richtlinie...args.

Arg falsche String, Zahl, bool, Objekt, Array, Funktion, Nullwert und andere vom System unterstützte Typen Der Parameteritemist ein Array, das die gleichzeitig auszuführenden Funktionsreferenzen und deren Parameter enthält.itemParameter können bei Aufruf derThread function.

Artikel wahr Reihenfolge

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

Erstellen Sie gleichzeitige Threads für eine benutzerdefinierte Funktion und eine anonyme Funktion.

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

VerwendenThread(...items)Form, um gleichzeitige Threads zu erstellen und mehrere Funktionen sequenziell auszuführen.

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

Es unterstützt das Übergeben von Parametern an gleichzeitig ausgeführte Funktionen.

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

Es unterstützt die Übergabe von Funktionsfolgen und kann dynamisch externe Bibliotheken für gleichzeitiges Rechnen importieren.

Die Fädenfunktionfuncin dieThread()Die Funktion für die gleichzeitige Ausführung läuft in einer isolierten Umgebung, so dass Variablen außerhalb des Threads nicht direkt referenziert werden können, und die Kompilierung wird beim Referenzieren fehlschlagen. Gleichzeitig werden Referenzen zu anderen Closure-Funktionen nicht innerhalb des Threads unterstützt. Alle von der Plattform bereitgestellten APIs können innerhalb des Threads aufgerufen werden, aber andere benutzerdefinierte Funktionen können nicht aufgerufen werden.

Es unterstützt Backtesting-System und Live-Trading-Umgebung. Alle gleichzeitigen Thread-bezogenen Funktionen werden nur als Code-Kompatibilität im Backtesting-System unterstützt und werden nicht tatsächlich von gleichzeitigen Threads ausgeführt, so dass sie in diesem Kapitel nicht wiederholt werden.

{@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 wird verwendet

DiegetThread()Die Funktion wird verwendet, um das Thread-Objekt basierend auf der angegebenen Thread-ID zu erhalten.

DiegetThread()Funktion gibt dieThreadObjekt mit der durch den Parameter angegebenen ThreadId

ThreadGegenstand

getThread (ThreadId)

Der ParameterthreadIdist die Thread-Objekt-ID. Erhalten Sie das entsprechende Thread-Objekt, indem Sie den Parameter angeben.

Schleifen wahr Zahl

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

Das angegebene Thread-Objekt durchlaufenthreadId.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

Wenn der Thread, den Sie erhalten möchten, ausgeführt und freigegeben wurde, können Sie nicht verwendenthreading.getThread(threadId)um das Gewindeobjekt des Gewindes zu erhalten.

{@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/threads/event Loop}, {@fun/threads/threads/threads/dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop}

Hauptthread

DiemainThread()Die Funktion wird verwendet, um das Gewindeobjekt des Hauptgewindes zu erhalten, d. h. das Gewinde, bei dem diemain()die Funktion in der Strategie liegt.

DiemainThread()Funktion gibt das Thread-Objekt des Hauptthreads zurück.

ThreadGegenstand

Hauptthread (()

function main() {
    Log("The threadId of the main thread:", threading.mainThread().id())
}

Holen Sie dieThreadObjekt des Hauptgurtes und Ausgang derthreadIdvon der Hauptschnur.

function test() {
    Log("Output the main thread ID in the test function:", threading.mainThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

Das Gewindeobjekt des Hauptgewindes kann auch in gleichzeitigen Gewinden gewonnen werden.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@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 eventLoop}

aktueller Faden

DiecurrentThread()Funktion wird verwendet, um das Thread-Objekt des aktuellen Threads zu erhalten.

DiecurrentThread()Funktion gibt das Thread-Objekt des aktuellen Threads zurück.

ThreadGegenstand

Der aktuelle Thread (((

function test() {
    Log("Id of the current thread:", threading.currentThread().id())
}

function main() {
    var t1 = threading.Thread(test)
    t1.join()
}

Holen Sie dieThreadGegenstand des Stromdrehs und Ausgang derthreadIdDer aktuelle Faden.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@fun/Threads/Threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/condition condition}, {@fun/threads/threading/event event}, {@fun/threads/threading/event dictt}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/event Loop event Loop}, {@fun/threads/threading/event Loop}

Schließung

DieLock()Die Funktion wird verwendet, um ein Thread-Lock-Objekt zu erstellen.

DieLock()Funktion gibt ein Threadlock-Objekt zurück.

ThreadLockGegenstand

Schließung

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

Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/threadThread}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop event}

Zustand

DieCondition()Die Funktion wird verwendet, um ein Objekt der Bedingungsvariablen zu erstellen, das zur Synchronisierung und Kommunikation zwischen Threads in einer mehrthreadigen gleichzeitigen Umgebung verwendet wird.Condition(), kann ein Thread warten, wenn bestimmte Bedingungen nicht erfüllt sind, bis ein anderer Thread ihm mitteilt, dass die Bedingung erfüllt ist.

DieCondition()Funktion gibt a zurückThreadCondition object.

ThreadConditionGegenstand

Zustand

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

Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.

Das Backtesting-System implementiert diese Funktionalität nicht, es definiert sie nur.

{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/thread Thread}, {@fun/threads/threading/event Event}, {@fun/threads/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop Loop}

Ereignis

DieEvent()Funktion wird verwendet, um eineThread-EreignisObjekt, das für die Synchronisierung zwischen Threads verwendet wird, sodass ein Thread auf eine Benachrichtigung oder ein Signal von einem anderen Thread warten kann.

DieEvent()Funktion gibt a zurückThreadEvent object.

ThreadEventGegenstand

Ereignis

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

Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@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}

Diktat

DieDict()Die Funktion wird verwendet, um ein Wörterbuchobjekt zu erstellen, das an gleichzeitige Threads übergeben wird.

DieDict()Funktion gibt a zurückThreadDict object.

ThreadDictGegenstand

Das ist ein Diktat.

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

Übertragen eines normalen Objekts an die gleichzeitige Thread-Ausführungsfunktion, um zu testen, ob die Änderung des Schlüsselwerts des Objekts Änderungen des Schlüsselwerts des Objekts in anderen Threads bewirkt.

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

Geben Sie mir dieThreadDictEin Objekt, das von derDict()Funktion an die gleichzeitige Thread-Ausführungsfunktion und prüfen, ob die Änderung des Schlüsselwerts des Objekts dazu führt, dass sich der Schlüsselwert des Objekts in anderen Threads ändert.

Wenn ein gemeinsames Objekt an eine gleichzeitige Thread-Funktion weitergegeben wird, wird es als Deep Copy weitergegeben.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@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/threading/thread Thread}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop}

Ausstehend

DiependingFunktion wird verwendet, um die Anzahl der gleichzeitigen Threads zu erhalten, die im aktuellen Strategieprogramm ausgeführt werden.

Diepending()Funktion gibt die Anzahl der gleichzeitigen Threads zurück, die das aktuelle Strategieprogramm ausführt.

Zahl

Ausstehend

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

Erstellen Sie zwei gleichzeitig laufende Threads und rufen Sie diepending()Funktion in verschiedenen Zeitknoten.

Wenn die Strategiemain()Funktion beginnt zu laufen, ruft die Funktionpending()direkt 1 zurückgeben wird, weil der Haupt-Thread, wo die Strategiemain()Funktion ist auch ein ausstehender Thread.

Es unterstützt Backtesting-System und Live-Handelsumgebung.

{@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/threading/Dict Dict}, {@fun/threads/threading/thread Thread}, {@fun/threads/threading/eventLoop}

Faden

ThreadObjekte können erstellt oder zurückgegeben werdenthreading.Thread(), threading.getThread(), threading.mainThread(), undthreading.currentThread().

Ein Blick

DiepeekMessage()Funktion wird verwendet, um eine Nachricht von einem Thread zu erhalten.

DiepeekMessage()Funktion gibt die Nachricht zurück, die vom Thread empfangen wurde, der mit dem aktuellen Thread-Objekt verknüpft ist.

Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen

Ein BlickMessage() Sieh nach Nachricht (Timeout)

Der Parametertimeoutist die Timeout-Einstellung. Sie blockiert und wartet auf die Anzahl der Millisekunden, die vom Parameter festgelegt werden, und gibt Daten zurück. Wenn keine Daten vorliegen und die Timeout-Einstellung das Limit überschreitet, wird ein Nullwert zurückgegeben.timeoutist auf 0 oder dietimeoutWenn die Daten des Kanals nicht übergeben werden, wird der Prozess blockiert und wartet, bis Daten aus dem Kanal empfangen werden.timeoutist auf -1 gesetzt, bedeutet dies, dass der Prozess Daten nicht sofort blockiert und zurückgibt.

Zeitverzögerung falsche Zahl

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })

    while (true) {
        var msg = threading.currentThread().peekMessage()
        Log("main peekMessage():", msg)
        if (msg == 9) {
            break
        }
        Sleep(1000)
    }

    t1.join()
}

Senden Sie Nachrichten an den Hauptthread von einem gleichzeitigen Thread.

Beim Schreiben von Programmen müssen wir auf Thread-Standstillstandsprobleme achten.

{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/threads/Thread/name}, {@Threads/threads/eventLoop EventLoop}

Nachricht

DiepostMessage()Funktion wird verwendet, um eine Nachricht an einen Thread zu senden.

PostNachricht ((msg)

Der Parametermsgist die Botschaft, die gesendet wird.

Msg - Das stimmt. Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Funktion, Nullwert usw.

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })
    for (var i = 0; i < 10; i++) {
        var event = threading.mainThread().eventLoop()
        Log("main event:", event)
        Sleep(500)
    }
    t1.join()
}

Senden von Nachrichten in gleichzeitigen Threads und VerwendungeventLoop()um Benachrichtigungen über Nachrichten zu erhalten.

function main() {
    threading.mainThread().postMessage(function(msg) {
        Log("func from mainThread, msg:", msg)
    })
    
    threading.Thread(function() {
        var func = threading.mainThread().peekMessage()
        func("in " + threading.currentThread().name())
    }).join()
}

Es unterstützt das Senden einer Funktion.

Wenn die Ausführungsfunktion eines Threads diepostMessage()Wir können die Funktion verwenden, um ein Signal oder Daten zu senden, ein Nachrichtenereignis wird auch generiert.eventLoop()Funktion zum Empfangen von Nachrichtenbenachrichtigungen.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

Eintritt

Diejoin()Funktion wird verwendet, um zu warten, bis der Thread aussteigt und die Systemressourcen zurückfordert.

DieThreadRetGegenstandenthält Daten über das Ausführungsergebnis. Zu den Eigenschaften gehören:

• id: Thread-ID.
• beendet: Ob der Faden zum Ende gezwungen wird.
• Vergangenheit: Laufzeit des Faden in Nanosekunden.
• Ret: Der Rückgabewert der Thread-Funktion.

ThreadRetGegenstand

Ich bin ein Teil von dir. Teilnahme (Timeout)

DietimeoutDie Zeitdauer in Millisekunden für das Warten auf das Ende des Threads wird verwendet.timeoutParameter auf 0 oder dietimeoutParameter nicht eingestellt ist,join()Funktion wird blockieren und warten, bis der Thread ausführt.timeoutDer Parameter ist auf -1,join()Die Funktion wird sofort wiederhergestellt.

Zeitverzögerung falsche Zahl

function main() {
    var t1 = threading.Thread(function() {
        Log("Hello thread1")
        Sleep(5000)
    })

    var ret = t1.join(1000)
    Log("ret:", ret)   // ret: undefined

    ret = t1.join()
    Log("ret:", ret)   // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}

Test derjoin()Funktion für Timeout und Ausgabe des Rückgabewerts.

Diejoin()Funktionszeiten aus und zurückundefined.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

beenden

Dieterminate()Funktion wird verwendet, um einen Thread zwangsweise zu beenden und die Hardware-Ressourcen freizugeben, die vom erstellten Thread verwendet werden.

beenden

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 i:", i)
            Sleep(1000)
        }
    })

    Sleep(3000)
    t1.terminate()
    Log("after t1.terminate()")

    while (true) {
        LogStatus(_D())
        Sleep(1000)
    }
}

Die Ausführung eines Threads wird gewaltsam beendet. Nach dem gewaltsamen Beenden eines Threads gibt es keinen Ausgang aus diesem Thread im Protokoll.

Für Fäden, die gewaltsam durch dieterminate()Wir können nicht mehr diejoin()Funktion, um zu warten, bis sie beendet werden.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

GetDaten

DiegetData()Diese Funktion wird verwendet, um auf Variablen zuzugreifen, die in der Thread-Umgebung aufgezeichnet sind.join()Funktion (Wartend auf erfolgreichen Ausgang) und hat dieterminate()Funktion (Zwangsschließung des Gurtes).

DiegetData()Funktion gibt den Schlüsselwert zurückkeyParameter im Schlüssel-Wert-Paar, das im aktuellen Thread-Kontext gespeichert ist.

Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen

GetDaten (siehe unten) GetData (Schlüssel)

DiekeyParameter ist der Schlüsselname des gespeicherten Schlüssel-Wert-Paares.

Schlüssel wahr String

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 5; i++) {
            threading.currentThread().setData("count", i)
            Log(`setData("count"):`, i)
            Sleep(1000)
        }
    })
    for (var i = 0; i < 5; i++) {
        var count = threading.getThread(t1.id()).getData("count")
        Log(`getData("count"):`, count)
        Sleep(1000)
    }
    t1.join()
}

Wert des Schlüssels erfassencountin der gleichzeitigen Thread-Umgebung, und dann lesen Sie den Schlüsselwert voncountin den Hauptgedanken.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

SetDaten

DiesetData()Funktion wird verwendet, um Variablen im Thread-Kontext zu speichern.

SetDaten (Schlüssel, Wert)

DiekeyParameter wird verwendet, um den Schlüsselnamen des gespeicherten Schlüssel-Wert-Paares anzugeben.

Schlüssel wahr String DievalueParameter wird verwendet, um den Schlüsselwert des gespeicherten Schlüssel-Wert-Paares anzugeben.

Wert - Das stimmt. Jeder vom System unterstützte Typ, z. B. Zeichenfolge, Zahl, bool, Objekt, Array, Funktion, Nullwert usw.

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Sleep(1000)
    Log(`t1.getData("data"):`, t1.getData("data"))
    t1.join()
}

Setzen Sie das Schlüssel-Wert-Paar im gleichzeitigen Thread und lesen Sie das Schlüssel-Wert-Paar im Hauptthread.

function main() {
    threading.mainThread().setData("func2", function(p) {
        Log("func2 p:", p)
    })
    
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("func1", function(p) {
            Log("func1 p:", p)
        })
    
        var func2 = threading.mainThread().getData("func2")
        func2("test2")
    })
    
    Sleep(1000)
    var func1 = t1.getData("func1")
    func1("test1")
    t1.join()
}

Es unterstützt die Übertragung von Schlüsselwerten auf Funktionen.

Die Daten sind gültig, wenn der Thread diejoin()Funktion (Wartend auf erfolgreichen Ausgang) und hat dieterminate()Funktion (Zwangsbeenden des Threads).valuemuss eine serialisierbare Variable sein.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/eventLoop eventLoop}

Identifizierung

Dieid()Funktion wird verwendet, um diethreadIdder aktuellen multithreaded Objektinstanz.

Der Rücklaufwert derid()Funktion istthreadId.

Zahl

Die Daten sind hier:

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.id():`, t1.id())
    t1.join()
}

Erstellen Sie einen gleichzeitig laufenden Thread und geben Sie diethreadIdvon diesem gleichlaufenden Faden im Hauptfaden.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

Name

Diename()Funktion wird verwendet, um den Namen der aktuellen Multithreaded-Objektinstanz zurückzugeben.

Diename()Funktion gibt den gleichzeitigen Threadnamen zurück.

String

Name (n)

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.name():`, t1.name())  // t1.name(): Thread-1
    t1.join()
}

Erstellen Sie einen gleichzeitigen Thread und geben Sie den Namen des gleichzeitigen Threads im Hauptthread aus.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/eventLoop eventLoop}

EventLoop

DieeventLoop()Die Funktion wird verwendet, um die vom Thread empfangenen Ereignisse anzuhören.

DieeventLoop()Funktion gibt die vom aktuellen Thread empfangenen Ereignisinformationen zurück. SieheVeranstaltungsinformationsstruktur.

Objekt, Nullwert

EventLoop ((() EventLoop (Zeitrahmen)

Der Parametertimeoutist die Timeout-Einstellung in Millisekunden.timeoutist auf 0 gesetzt, wartet es, bis ein Ereignis stattfindet, bevor es zurückkehrt. Wenn es größer als 0 ist, setzt es das Ereignis auf Wartezeit. Wenn es kleiner als 0 ist, gibt es sofort das letzte Ereignis zurück.

Zeitverzögerung falsche Zahl

function main() {
    var t1 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop()     // Blocking wait
            // 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
            Log(_D(), "thread1 eventMsg:", eventMsg)
        }
    })

    var t2 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(-1)   // Return immediately
            Log(_D(), "thread2 eventMsg:", eventMsg)
            Sleep(5000)
        }
    })

    var t3 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
            Log(_D(), "thread3 eventMsg:", eventMsg)
        }
    })

    t1.postMessage("Hello ", t1.name())
    t2.postMessage("Hello ", t2.name())
    t3.postMessage("Hello ", t3.name())
    t1.join()
    t2.join()
    t3.join()
}

Führen Sie drei Threads gleichzeitig aus und geben Sie die empfangenen Ereignisinformationen aus.

Der Verarbeitungsmechanismus dereventLoop()Funktion ist die gleiche wie die globale FunktionEventLoop().

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}

ThreadLock

Thread-Lock-Objekt, für die Synchronisierung von mehreren Threads verwendet.

zu erwerben

Dieacquire()Die Funktion wird verwendet, um ein Threadlock (Schließen) anzufordern.

Erwerben

Siehethreading.Lock()Abschnitt für Beispiele.

Dieacquire()Wenn ein Thread die Funktion "Thread Lock" anruft, wird die Funktion "Thread Lock" verwendet.acquire()Wenn der Schloss nicht von einem anderen Thread gehalten wird, erhält der aufrufende Thread den Schloss erfolgreich und setzt die Ausführung fort. Wenn der Schloss bereits von einem anderen Thread gehalten wird, wird der aufrufende Threadacquire()wird blockiert, bis das Schloss freigegeben ist.

Ich habe eine Frage. Ich habe eine Frage.

Freisetzung

Dierelease()Die Funktion wird verwendet, um ein Gewindeverriegelung (Entriegelung) zu lösen.

Freisetzung

function consumer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        pLock.acquire()
        cLock.acquire()
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cLock.release()
        Sleep(1000)
        pLock.release()
    }
}

function producer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        cLock.acquire()   // cLock.acquire() placed after pLock.acquire() will not cause deadlock
        pLock.acquire()   
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        pLock.release()
        Sleep(1000)
        cLock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var pLock = threading.Lock()
    var cLock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)

    consumerThread.join()
    producerThread.join()
}

Prüfung von Stillstandsszenarien

Es ist zu beachten, dass eine unsachgemäße Verwendung von Fadenverschlüssen zu einer Sackgasse führen kann.

Ich bin nicht derjenige, der das Problem hat, aber ich bin derjenige, der es hat.

ThreadEvent

Ereignisobjekt, das für mehrstufige Ereignisbenachrichtigungen und -signale verwendet wird.

Satz

Dieset()Funktion wird verwendet, um Ereignisse zu benachrichtigen (Satzsignale).

Einheitlich

Siehethreading.Event()Abschnitt für Beispiele.

Wenn das Signal mitset()Wir müssen das Signal löschen und wieder einstellen.

{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

klar

Dieclear()Die Funktion wird verwendet, um das Signal zu löschen.

Klar, klar.

Siehethreading.Event()Abschnitt für Beispiele.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

Warten Sie.

Diewait()Die Funktion wird verwendet, um ein Ereignis (Signal) warten zu lassen, und wird blockiert, bevor das Ereignis (Signal) gesetzt wird. Sie unterstützt das Setzen eines Timeouts.

Diewait()Wenn dies der Fall ist, gibt es einen wahren Wert.

Boole

Warten Sie. Warten Sie.

DietimeoutDer Parameter wird verwendet, um die Wartezeit in Millisekunden festzulegen.

Zeitverzögerung falsche Zahl

function main() {
    var event = threading.Event()
    var t1 = threading.Thread(function(event) {
        var ret = event.wait(100)
        Log(`event.wait(100):`, ret)
        ret = event.wait()
        Log(`event.wait():`, ret)
    }, event)

    Sleep(1000)
    event.set()
    t1.join()
}

Testen Sie den Rückgabewert derwait() function.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}

istSet

DieisSet()Funktion wird verwendet, um festzustellen, ob ein Ereignis (Signal) eingestellt wurde.

DieisSet()Funktion gibt zurück, ob das Ereignis (Signal) eingestellt wurde; wenn das Ereignis (Signal) eingestellt wurde, gibt sie einen wahren Wert zurück.

Boole

istSet()

Siehethreading.Event()Abschnitt für Beispiele.

Das ist eine sehr schwierige Sache.

ThreadBedingung

Bedingungsgegenstand, für die Synchronisierung von mehreren Threads verwendet.

Anzeigen

Dienotify()Funktion wird verwendet, um einen wartenden Thread (falls vorhanden) aufzuwecken.wait()Die Methode wird aufgewacht.

Anmeldung

function consumer(dict, condition) {
    while (true) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
            condition.wait()
        }
        var arr = dict.get("array")
        var num = arr.shift()
        Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
        dict.set("array", arr)
        Sleep(1000)
        condition.release()
    }
}

function main() {
    var condition = threading.Condition()
    var dict = threading.Dict()
    dict.set("array", [])
    var t1 = threading.Thread(consumer, dict, condition)
    var t2 = threading.Thread(consumer, dict, condition)
    var t3 = threading.Thread(consumer, dict, condition)
    Sleep(1000)
    var i = 0
    while (true) {
        condition.acquire()
        var msg = ""
        var arr = dict.get("array")
        var randomNum = Math.floor(Math.random() * 5) + 1
        if (arr.length >= 3) {
            condition.notifyAll()
            msg = "notifyAll"
        } else {
            arr.push(i)
            dict.set("array", arr)
            if (randomNum > 3 && arr.length > 0) {
                condition.notify()
                msg = "notify"
            } else {
                msg = "pass"
            }
            i++
        }

        Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
        condition.release()
        Sleep(1000)
    }
}

Verwendennotify()Funktion, um den wartenden Faden zu wecken.

Dienotify()Funktion weckt einen Thread in der Warteschlange.

Wenn dienotify()Wenn eine Funktion einen Thread weckt, erhält der Thread das Thread-Lock zurück.

{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

Benachrichtigen Sie alle

DienotifyAll()Funktion weckt alle wartenden Threads auf.

Benachrichtigen Sie alle.

SieheThreadCondition.notify()Abschnitt für Beispiele.

DienotifyAll()Die Funktion weckt alle wartenden Threads einzeln auf, und die erwachten Threads erwerben das Threadlock wieder.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

Warten Sie.

Diewait()Die Funktion wird verwendet, um einen Faden unter bestimmten Bedingungen warten zu lassen.

Warten Sie.

SieheThreadCondition.notify()Abschnitt für Beispiele.

Diewait()Die Funktion entlässt die Schraube und erhält die Schraube wieder, wenn man aufwacht.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

zu erwerben

Dieacquire()Die Funktion wird verwendet, um ein Threadlock (Schließen) anzufordern.

Erwerben

SieheThreadCondition.notify()Abschnitt für Beispiele.

Vor Gebrauchwait(), müssen Sie das Thread-Lock (Lock) des aktuellen Condition-Objekts anfordern.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}

Freisetzung

Dierelease()Die Funktion wird verwendet, um ein Gewindeverriegelung (Entriegelung) zu lösen.

Freisetzung

SieheThreadCondition.notify()Abschnitt für Beispiele.

Nach Gebrauchwait(), müssen wir das Thread-Lock (Unlock) des aktuellen Condition-Objekts freigeben.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}

ThreadDict

Wörterbuchobjekt, zum Teilen von Daten verwendet.

- Geht schon.

Dieget()Die Funktion wird verwendet, um den im Wörterbuchobjekt aufgezeichneten Schlüsselwert zu erhalten.

Dieget()Funktion gibt den Wert des Schlüssels zurück, der von derkey parameter.

Zeichenfolge, Zahl, bool, Objekt, Array, Nullwert und andere vom System unterstützte Typen

Get (Schlüssel)

DiekeyParameter wird verwendet, um den Schlüsselnamen anzugeben, der dem zu erhaltenden Schlüssel entspricht.

Schlüssel wahr String

function main() {
    var event = threading.Event()
    var dict = threading.Dict()
    dict.set("data", 100)
    
    var t1 = threading.Thread(function(dict, event) {
        Log(`thread1, dict.get("data"):`, dict.get("data"))
        
        event.set()
        event.clear()
        
        event.wait()
        Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
    
        dict.set("data", 0)
    }, dict, event)
    
    event.wait()
    
    dict.set("data", 99)
    
    event.set()
    event.clear()
    
    t1.join()
    Log(`main thread, dict.get("data"):`, dict.get("data"))
}

Verwenden Sie Ereignisobjekte, um Threads zu benachrichtigen, um Daten zu lesen und zu ändern.

Ich bin nicht derjenige, der das Problem hat.

Satz

Dieset()Die Funktion wird verwendet, um ein Schlüssel-Wert-Paar festzulegen.

Set (Schlüssel, Wert)

Der Parameterkeywird verwendet, um den zu ändernden Schlüsselnamen festzulegen.

Schlüssel wahr String Der Parametervaluewird verwendet, um den zu ändernden Schlüsselwert festzulegen.

Wert - Das stimmt. String, Zahl, bool, Objekt, Array, Funktion, Nullwert und andere vom System unterstützte Typen

function main() {
    var dict1 = threading.Dict()
    dict1.set("func1", function(p) {
        Log("func1 p:", p)
    })
    
    threading.Thread(function(dict1) {
        var func1 = dict1.get("func1")
        func1("test")
    }, dict1).join()
}

Es unterstützt die Übertragung von Schlüsselwerten auf Funktionen.

Ich bin ein guter Freund.

Netzeinstellungen Web3