filtrage

LethreadingObjet est un outil de gestion multi-threading global qui fournit des fonctions telles que la création de threads concurrents, de verrouillage de thread et d'objets condition.threadingCet objet n'est pris en charge que par leJavaScriptstratégie linguistique.

Le fil

LeThread()la fonction est utilisée pour créer des threads simultanés.

LeThread()La fonction renvoie aThreadobjet, qui est utilisé pour gérer les threads simultanés créés, la communication des threads, etc.

Threadobjet

Je ne sais pas si c'est vrai. Thème (s)

Le paramètrefuncest une fonction d'exécution simultanée (passée par référence) et prend en charge le passage de fonctions anonymes.funcpeut accepter plusieurs paramètres, qui seront transmis à travers...argsPar conséquent, la liste de paramètres defuncdoit être conforme à...args.

fonction vrai fonction Le paramètreargest le paramètre réel passé àfunc(c'est-à-dire la fonction d'exécution simultanée du thread) lorsque le rappel est exécuté; il peut y avoir plusieurs paramètresarg, et la liste des paramètres defuncdoit être conforme à...args.

arg faux chaîne, nombre, bool, objet, tableau, fonction, valeur nulle et autres types pris en charge par le système Le paramètreitemest un tableau contenant les références de fonction et leurs paramètres à exécuter simultanément.itemLes paramètres peuvent être passés lors de l'appel duThread function.

point vrai séquence

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

Créez des threads simultanés pour une fonction personnalisée et une fonction anonyme.

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

Utilisez leThread(...items)forme pour créer des threads simultanés et exécuter plusieurs fonctions séquentiellement.

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

Il prend en charge le passage de paramètres à des fonctions exécutées simultanément.

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

Il prend en charge le passage de chaînes de fonctions et peut importer des bibliothèques externes de manière dynamique pour le calcul simultané.

La fonction de filfuncpassé dans leThread()Une fonction pour l'exécution simultanée s'exécute dans un environnement isolé, de sorte que les variables en dehors du thread ne peuvent pas être directement référencées, et la compilation échouera lorsqu'elle est référencée.

Il prend en charge le système de backtesting et l'environnement de trading en direct. Toutes les fonctions liées aux threads concurrents ne sont prises en charge que comme compatibilité de code dans le système de backtesting et ne seront pas réellement exécutées par des threads concurrents, elles ne seront donc pas répétées dans ce chapitre.

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

- Je ne sais pas.

LegetThread()fonction est utilisée pour obtenir l'objet de thread basé sur l'ID de thread spécifié.

LegetThread()Retourne leThreadobjet avec le threadId spécifié par le paramètre

Threadobjet

Je ne sais pas si c'est vrai.

Le paramètrethreadIdest l'ID de l'objet de thread. Obtenez l'objet de thread correspondant en spécifiant le paramètre.

Le fil vrai Numéro

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

Obtenir l'objet de thread spécifiéthreadId.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

Si le fil que vous voulez obtenir a été exécuté et libéré, vous ne pouvez pas utiliserthreading.getThread(threadId)pour obtenir l'objet du fil du fil.

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

le fil principal

LemainThread()fonction est utilisée pour obtenir l'objet de fil du fil principal, c'est-à-dire le fil où lemain()La fonction dans la stratégie est localisée.

LemainThread()la fonction renvoie l'objet de thread du thread principal.

Threadobjet

le fil principal (((

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

Prends leThreadl'objet du fil principal et la sortiethreadIddu fil conducteur.

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

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

L'objet de fil du fil principal peut également être obtenu dans des fils concurrents.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

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

Le fil de chaîne actuel

LecurrentThread()la fonction est utilisée pour obtenir l'objet thread du thread actuel.

LecurrentThread()la fonction renvoie l'objet de thread du thread en cours.

Threadobjet

Le fil de discussion actuel

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

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

Prends leThreadl'objet du fil de courant et la sortiethreadIddu fil actuel.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

{@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/Condition Condition}, {@fun/Threads/threading/event Event}, {@fun/Threads/threads/threading/event Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop eventLoop}, {@fun/Threads/threading/eventLoop}, {@fun/Threads/threads/threading/eventLoop}, {@fun/threads/threads/threading/eventLoop}, {@fun/threads/threads/threads/ev

Fermeture

LeLock()la fonction est utilisée pour créer un objet de verrouillage de thread.

LeLock()la fonction renvoie un objet de verrouillage de thread.

ThreadLockobjet

Fermeture

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

Deux fils concurrents accèdent à une ressource commune.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

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

Condition

LeCondition()fonction est utilisée pour créer un objet variable de condition, qui est utilisé pour réaliser la synchronisation et la communication entre les threads dans un environnement concurrent multi-threaded.Condition(), un thread peut attendre lorsque certaines conditions ne sont pas remplies jusqu'à ce qu'un autre thread l'informe que la condition a été remplie.

LeCondition()La fonction renvoie aThreadCondition object.

ThreadConditionobjet

Condition (s)

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

Deux fils concurrents accèdent à une ressource commune.

Le système de backtesting ne met pas en œuvre cette fonctionnalité, il la définit seulement.

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

Événement

LeEvent()fonction est utilisée pour créer unévénement de filobjet, qui est utilisé pour la synchronisation entre les threads, permettant à un thread d'attendre une notification ou un signal d'un autre thread.

LeEvent()La fonction renvoie aThreadEvent object.

ThreadEventobjet

Événement

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

Deux fils concurrents accèdent à une ressource commune.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

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

Le dicton

LeDict()fonction est utilisée pour créer un objet de dictionnaire pour passer à des threads concurrents.

LeDict()La fonction renvoie aThreadDict object.

ThreadDictobjet

Le dictionnaire

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

Passer un objet normal à la fonction d'exécution de thread concurrent pour tester si la modification de la valeur de clé de l'objet entraînera des modifications de la valeur de clé de l'objet dans d'autres threads.

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

Passe leThreadDictl'objet créé par leDict()fonction à la fonction d'exécution de thread en parallèle, et tester si la modification de la valeur de clé de l'objet entraînera la modification de la valeur de clé de l'objet dans d'autres threads.

Lorsqu'un objet commun est passé à une fonction de thread concurrent, il est passé comme une copie profonde.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

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

en attente

Lependingfonction est utilisée pour obtenir le nombre de threads simultanés exécutés dans le programme de stratégie en cours.

Lepending()la fonction renvoie le nombre de threads simultanés que le programme de stratégie en cours exécute.

Numéro

En attente

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

Créez deux threads en cours d'exécution simultanée et appelez lepending()fonctionner à différents nœuds horaires.

Lorsque la stratégiemain()fonction commence à fonctionner, appelant la fonctionpending()directement renverra 1, parce que le fil principal où la stratégiemain()fonction est situé est également un fil en attente.

Il prend en charge le système de backtesting et l'environnement de trading en direct.

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

Réglages réseau Le fil