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}

Réglages réseau - Je ne sais pas.