Les ressources ont été chargées... Je charge...

Les fils

La plate-forme de négociation quantitative FMZ prend réellement en charge la fonction multi-threaded duJavaScriptLa stratégie linguistique est mise en place de bas en haut du système et vise à atteindre les objectifs suivants:

Objets Directions de conduite Les commentaires
filtrage Objet global à plusieurs fils Les fonctions des membres:Thread, getThread, mainThread, etc.
Le fil Objet de fil Les fonctions des membres:peekMessage, postMessage, join, etc.
Fermeture de fil Objet de verrouillage de fil Les fonctions des membres:acquire, release. Ils peuvent être passés dans l'environnement du thread en tant que paramètres de la fonction d'exécution du thread.
ThreadÉvénement Objet événement Les fonctions des membres:set, clear, wait, isSet. Ils peuvent être passés dans l'environnement du thread comme paramètre de la fonction d'exécution du thread.
ThreadCondition Objet de condition Les fonctions des membres:notify, notifyAll, wait, acquire, release. Ils peuvent être passés dans l'environnement du thread comme paramètre de la fonction d'exécution du thread.
ThreadDict Objet du dictionnaire Les fonctions des membres:get, set. Ils peuvent être passés dans l'environnement du thread en tant que paramètres de la fonction d'exécution du thread.

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}

Le fil

ThreadLes objets peuvent être créés ou retournés parthreading.Thread(), threading.getThread(), threading.mainThread(), etthreading.currentThread().

Un coup d'œilMessage

LepeekMessage()la fonction est utilisée pour obtenir un message d'un thread.

LepeekMessage()fonction renvoie le message reçu par le thread associé à l'objet de thread en cours.

chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système

Je suis en train de lire un article. Je suis en train d'essayer d'arrêter.

Le paramètretimeoutest le paramètre de temps d'arrêt. Il bloque et attend le nombre de millisecondes défini par le paramètre et renvoie les données. S'il n'y a pas de données et que le temps d'arrêt dépasse la limite, une valeur nulle est renvoyée. Sitimeoutest réglé sur 0 ou letimeoutsi le paramètre n'est pas passé, cela signifie que le processus va bloquer et attendre jusqu'à ce que les données soient reçues du canal.timeoutSi la valeur est réglée sur -1, cela signifie que le processus ne bloquera pas et ne renverra pas les données immédiatement.

temps d'arrêt faux Numéro

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

Envoyer des messages au fil principal à partir d'un fil concurrent.

Lorsque nous écrivons des programmes, nous devons prêter attention aux problèmes d'impasse des threads.

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

PostMessage

LepostMessage()fonction est utilisée pour envoyer un message à un thread.

PostMessage (message)

Le paramètremsgest le message à envoyer.

Message à envoyer vrai Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, fonction, valeur nulle, etc.

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

Envoyer des messages dans des threads simultanés et utilisereventLoop()pour recevoir des notifications de messages.

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

Il prend en charge l'envoi d'une fonction.

Lorsque la fonction d'exécution d'un thread appelle lepostMessage()Nous pouvons utiliser la fonction pour envoyer un signal ou des données, un événement de message est également généré.eventLoop()fonction de réception des notifications de messages.

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

rejoindre

Lejoin()fonction est utilisée pour attendre que le thread sorte et récupère les ressources du système.

LeThreadRetobjetcontient des données sur le résultat de l'exécution.

  • id: Id du fil.
  • terminé: si le fil est forcé de se terminer.
  • dépassé: temps de fonctionnement du fil en nanosecondes.
  • ret: la valeur renvoyée par la fonction thread.

ThreadRetobjet

rejoignez rejoindre ((timeout)

LetimeoutLe paramètre est utilisé pour définir le temps d'arrêt en millisecondes pour attendre la fin du fil.timeoutparamètre est réglé sur 0 ou letimeoutparamètre n'est pas réglé, lejoin()fonction va bloquer et attendre jusqu'à ce que le fil termine l'exécution.timeoutle paramètre est réglé sur -1,join()La fonction va revenir immédiatement.

temps d'arrêt faux Numéro

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

Testez lejoin()fonction pour le temps d'arrêt et la sortie de la valeur de retour.

Lejoin()temps de sortie et de retour de la fonctionundefined.

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

terminer

Leterminate()fonction est utilisée pour mettre fin de force à un thread et libérer les ressources matérielles utilisées par le thread créé.

terminé

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

Terminer l'exécution d'un thread par la force. Après avoir terminé un thread par la force, il n'y aura pas de sortie de ce thread dans le journal.

Pour les fils qui sont terminés de force par leterminate()Nous ne pouvons plus utiliser lejoin()fonction d'attendre qu'ils se terminent.

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

Pour obtenir les données

LegetData()Les données sont valables lorsque le thread n'a pas exécuté lejoin()fonction (en attente de sortie réussie) et n'a pas exécuté leterminate()fonction (termination du fil par la force).

LegetData()La fonction renvoie la valeur de clé correspondant à la valeur dekeyparamètre dans la paire clé-valeur stockée dans le contexte du thread en cours.

chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système

- Je ne sais pas. Je suis en train d' écrire.

Lekeyparamètre est le nom de la clé de la paire clé-valeur stockée.

clé vrai chaîne

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

Enregistrer la valeur de la clécountdans l'environnement de fil en parallèle, puis lire la valeur clé decountdans le fil principal.

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

Réglage des données

LesetData()la fonction est utilisée pour stocker des variables dans le contexte du thread.

définitionDétails (clé, valeur)

Lekeyparamètre est utilisé pour spécifier le nom de clé de la paire clé-valeur stockée.

clé vrai chaîne Levalueparamètre est utilisé pour spécifier la valeur de clé de la paire clé-valeur stockée.

valeur vrai Tout type pris en charge par le système, tel que chaîne, nombre, bool, objet, tableau, fonction, valeur nulle, etc.

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

Définissez la paire clé-valeur dans le thread concurrent et lisez la paire clé-valeur dans le thread principal.

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

Il prend en charge le passage de la valeur de la clé dans les fonctions.

Les données sont valables lorsque le thread n'a pas exécuté lejoin()fonction (en attente de sortie réussie) et n'a pas exécuté leterminate()La valeur du paramètrevaluedoit être une variable sérialisable.

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

Nom de l'entreprise

Leid()fonction est utilisée pour retourner lethreadIdde l'instance d'objet multithread actuelle.

La valeur de rendement de laid()la fonction estthreadId.

Numéro

Nom de l'entreprise

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

Créez un fil en cours d'exécution simultanée et sortez lethreadIdde ce fil parallèle dans le fil principal.

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

Nom

Lename()fonction est utilisée pour renvoyer le nom de l'instance d'objet multithreaded en cours.

Lename()la fonction renvoie le nom du fil concurrent.

une chaîne

Nom (s)

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

Créez un fil de discussion concurrent et sortez le nom du fil de discussion concurrent dans le fil principal.

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

événementLoop

LeeventLoop()la fonction est utilisée pour écouter les événements reçus par le thread.

LeeventLoop()fonction renvoie les informations d'événement reçues par le fil courant.Structure de l'information sur les événements.

objet, valeur nulle

événementLoop() événement Loop (délai de réponse)

Le paramètretimeoutest le temps d'arrêt en millisecondes.timeouts'il est défini sur 0, il attend qu'un événement se produise avant de retourner. s'il est supérieur à 0, il définit le temps d'attente de l'événement. s'il est inférieur à 0, il renvoie immédiatement le dernier événement.

temps d'arrêt faux Numéro

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

Exécuter trois threads simultanément et produire les informations d'événement reçues.

Le mécanisme de traitement deseventLoop()est la même que la fonction globaleEventLoop().

{@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 set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/Thread/name name},

Fermeture de fil

Objet de verrouillage de thread, utilisé pour le traitement de synchronisation multi-thread.

acquérir

Leacquire()la fonction est utilisée pour demander un verrouillage de fil.

acquérir

Veuillez vous référer authreading.Lock()section pour les exemples.

Leacquire()fonction est utilisée pour demander un verrouillage de thread.acquire()fonction d'un objet de verrouillage de thread, il tente d'acquérir le verrouillage. Si le verrouillage n'est pas actuellement détenu par un autre thread, le thread appelant acquiert avec succès le verrouillage et continue l'exécution. Si le verrouillage est déjà détenu par un autre thread, le thread appelantacquire()sera bloqué jusqu'à ce que le verrou soit relâché.

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release} Je suis désolé.

libération

Lerelease()fonction est utilisée pour libérer un verrou de fil (déverrouiller).

libération

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

Test de scénarios d'impasse

Il convient de noter que l'utilisation inappropriée de serrures à fil peut entraîner un blocage.

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquérir acquérir}

ThreadÉvénement

Objet événement, utilisé pour la notification et le signal d'événement multi-threaded.

ensemble

Leset()La fonction est utilisée pour notifier les événements (signaux définis).

le groupe

Veuillez vous référer authreading.Event()section pour les exemples.

Si le signal a été réglé en utilisantset()Il faut nettoyer le signal et le réinitialiser.

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

dégagé

Leclear()fonction est utilisée pour effacer le signal.

C' est clair.

Veuillez vous référer authreading.Event()section pour les exemples.

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

Attends un peu!

Lewait()fonction est utilisée pour définir un événement (signal) d'attente, et va bloquer avant que l'événement (signal) est définie; il prend en charge la définition d'un paramètre de temps d'arrêt.

Lewait()la fonction renvoie si le timeout s'est produit. Si oui, elle renvoie une valeur vraie.

Boole

Attends! Attends une minute.

LetimeoutLe paramètre est utilisé pour définir le temps d'attente en millisecondes.

temps d'arrêt faux Numéro

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

Testez la valeur de retour duwait() function.

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

estSet

LeisSet()fonction est utilisée pour déterminer si un événement (signal) a été défini.

LeisSet()la fonction renvoie si l'événement (signal) a été défini; si l'événement (signal) a été défini, elle renvoie une valeur vraie.

Boole

estSélectionné ((()

Veuillez vous référer authreading.Event()section pour les exemples.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/ThreadEvent/wait wait}, {@fun/Threads/Threads/Threads/Wait wait}, {@fun/Threads/Threads/Wait wait wait}, {@fun/Threads/ThreadsEvent/wait wait wait}, {@fun/Threads/ThreadsEvent/Wait wait}, {@fun/Th

ThreadCondition

Objet de condition, utilisé pour la synchronisation multi-thread.

prévenir

Lenotify()fonction est utilisée pour réveiller un fil d'attente (le cas échéant).wait()La méthode sera réveillée.

Il faut le signaler.

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

Utilisez lenotify()fonction pour réveiller le fil d'attente.

Lenotify()fonction réveille un fil dans la file d'attente.

Lorsque lenotify()fonction réveille un fil, le fil récupérera le verrou de fil.

{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}

prévenir tout le monde

LenotifyAll()la fonction réveille tous les threads en attente.

Je vous préviens.

Veuillez vous référer auThreadCondition.notify()section pour les exemples.

LenotifyAll()fonction réveille tous les fils en attente un par un, et les fils réveillés reprennent le verrou de fil.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}

Attends un peu!

Lewait()La fonction est utilisée pour faire attendre un fil dans certaines conditions de conception.

Attends!

Veuillez vous référer auThreadCondition.notify()section pour les exemples.

Lewait()La fonction relâche le verrouillage du fil et récupère le verrouillage du fil lorsqu'il est réveillé.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquérir acquérir}, {@fun/Threads/ThreadCondition/release release}

acquérir

Leacquire()la fonction est utilisée pour demander un verrouillage de fil.

acquérir

Veuillez vous référer auThreadCondition.notify()section pour les exemples.

Avant utilisationwait(), vous devez demander le verrouillage de thread (verrouillage) de l'objet condition actuel.

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

libération

Lerelease()fonction est utilisée pour libérer un verrou de fil (déverrouiller).

libération

Veuillez vous référer auThreadCondition.notify()section pour les exemples.

Après utilisationwait(), nous avons besoin de libérer le verrouillage de fil (déverrouiller) de l'objet condition actuelle.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquérir acquérir}

ThreadDict

Objet de dictionnaire, utilisé pour le partage de données.

Je vous en prie.

Leget()fonction est utilisée pour obtenir la valeur de clé enregistrée dans l'objet du dictionnaire.

Leget()Retourne la valeur de la clé spécifiée par lekey parameter.

chaîne, nombre, bool, objet, tableau, valeur nulle et autres types pris en charge par le système

Je vais vous donner une clé.

LekeyLe paramètre est utilisé pour spécifier le nom de la clé correspondant à la clé à obtenir.

clé vrai chaîne

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

Utiliser des objets événement pour notifier les threads pour lire et modifier les données.

{@fun/Threads/ThreadDict/set set} Je ne sais pas si vous êtes d'accord.

ensemble

Leset()La fonction est utilisée pour définir une paire clé-valeur.

définition (clés, valeurs)

Le paramètrekeyest utilisé pour définir le nom de la clé à modifier.

clé vrai chaîne Le paramètrevalueest utilisé pour définir la valeur clé à modifier.

valeur vrai chaîne, nombre, bool, objet, tableau, fonction, valeur nulle et autres types pris en charge par le système

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

Il prend en charge le passage de la valeur de la clé dans les fonctions.

Je ne sais pas.

Réglages réseau Le Web3

2019 FMZ - Tous les droits réservés