Die Ressourcen sind geladen. Beförderung...

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}

Netzeinstellungen Faden