Penggelek

Peraturanthreadingobject adalah alat pengurusan multithreading global yang menyediakan fungsi seperti membuat utas serentak, kunci utas, dan objek keadaan.threadingObjek ini hanya disokong olehJavaScriptstrategi bahasa.

Benang

PeraturanThread()fungsi digunakan untuk membuat benang serentak.

PeraturanThread()fungsi mengembalikan aThreadobjek, yang digunakan untuk menguruskan benang serentak yang dicipta, komunikasi benang, dll.

Threadobjek

Thread ((func,...args) Thread ((... item)

Parameterfuncadalah fungsi untuk pelaksanaan serentak (diterbitkan oleh rujukan), dan menyokong menyampaikan fungsi tanpa nama.funcboleh menerima pelbagai parameter, yang akan dihantar melalui...argsOleh itu, senarai parameterfuncperlu konsisten dengan...args.

fungsi betul fungsi Parameterargadalah parameter sebenar yang dihantar kepadafunc(iaitu fungsi pelaksanaan thread serentak) apabila panggilan balik dijalankan; mungkin terdapat beberapa parameterarg, dan senarai parameterfuncperlu konsisten dengan...args.

arg palsu rentetan, nombor, bool, objek, susunan, fungsi, nilai sifar dan jenis lain yang disokong oleh sistem Parameteritemadalah array yang mengandungi rujukan fungsi dan parameter mereka yang akan dijalankan secara serentak.itemparameter boleh dihantar dalam apabila memanggilThread function.

item betul Array

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

Buat utas serentak untuk kedua-dua fungsi tersuai dan fungsi tanpa nama.

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

GunakanThread(...items)bentuk untuk mencipta benang serentak dan melaksanakan pelbagai fungsi secara berurutan.

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

Ia menyokong lulus dalam rentetan fungsi dan boleh mengimport perpustakaan luaran secara dinamik untuk pengkomputeran serentak.

Fungsi benangfunctelah diteruskan ke dalamThread()fungsi untuk pelaksanaan serentak berjalan dalam persekitaran yang terpencil, jadi pembolehubah di luar benang tidak boleh dirujuk secara langsung, dan penyusunan akan gagal apabila dirujuk. Pada masa yang sama, rujukan kepada fungsi penutupan lain tidak disokong dalam benang. Semua API yang disediakan oleh platform boleh dipanggil dalam benang, tetapi fungsi lain yang ditakrifkan pengguna tidak boleh dipanggil.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung. Semua fungsi yang berkaitan dengan thread serentak hanya disokong sebagai keserasian kod dalam sistem backtesting dan tidak akan dilaksanakan oleh thread serentak, jadi mereka tidak akan diulangi dalam bab ini.

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

getThread

PeraturangetThread()fungsi digunakan untuk mendapatkan objek thread berdasarkan ID thread yang ditentukan.

PeraturangetThread()fungsi mengembalikanThreadobjek dengan threadId yang ditentukan oleh parameter

Threadobjek

getThread ((threadId)

ParameterthreadIdadalah ID objek thread. Dapatkan objek thread yang sepadan dengan menentukan parameter.

ThreadId betul nombor

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

Dapatkan objek benang yang ditentukan melaluithreadId.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

Jika benang yang anda ingin mendapatkan telah dijalankan dan dikeluarkan, anda tidak boleh menggunakanthreading.getThread(threadId)untuk mendapatkan objek benang benang.

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

mainThread

PeraturanmainThread()fungsi digunakan untuk mendapatkan objek benang benang utama, iaitu benang di manamain()fungsi dalam strategi terletak.

PeraturanmainThread()fungsi mengembalikan objek benang benang utama.

Threadobjek

mainThread()

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

DapatkanThreadobjek benang utama dan outputthreadIddaripada benang utama.

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

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

Objek benang benang utama juga boleh diperoleh dalam benang serentak.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

Thread semasa

PeraturancurrentThread()fungsi digunakan untuk mendapatkan objek benang benang semasa.

PeraturancurrentThread()fungsi mengembalikan objek benang benang semasa.

Threadobjek

CurrentThread ((()

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

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

DapatkanThreadobjek benang semasa dan outputthreadIddaripada benang semasa.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

Kunci

PeraturanLock()fungsi digunakan untuk mencipta objek kunci benang.

PeraturanLock()fungsi mengembalikan objek kunci benang.

ThreadLockobjek

Kunci.

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

Dua benang serentak mengakses sumber yang sama.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

Keadaan

PeraturanCondition()fungsi digunakan untuk membuat objek pembolehubah keadaan, yang digunakan untuk mencapai penyegerakan dan komunikasi antara benang dalam persekitaran serentak berbilang benang.Condition(), benang boleh menunggu apabila keadaan tertentu tidak dipenuhi sehingga benang lain memaklumkan bahawa keadaan telah dipenuhi.

PeraturanCondition()fungsi mengembalikan aThreadCondition object.

ThreadConditionobjek

Keadaan

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

Dua benang serentak mengakses sumber yang sama.

Sistem backtesting tidak melaksanakan fungsi ini, ia hanya mentakrifkannya.

{@fun/Threads/getThread getThread}, {@fun/Threads/threads/mainThread mainThread}, {@fun/Threads/threading/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}

Acara

PeraturanEvent()fungsi digunakan untuk menciptaperistiwa benangobjek, yang digunakan untuk menyegerakkan antara utas, membolehkan satu utas menunggu pemberitahuan atau isyarat dari utas lain.

PeraturanEvent()fungsi mengembalikan aThreadEvent object.

ThreadEventobjek

Acara

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

Dua benang serentak mengakses sumber yang sama.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

Dikt

PeraturanDict()fungsi digunakan untuk membuat objek kamus untuk lulus ke benang serentak.

PeraturanDict()fungsi mengembalikan aThreadDict object.

ThreadDictobjek

Dict ((()

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

Memindahkan objek biasa ke fungsi pelaksanaan utas serentak untuk menguji sama ada mengubah suai nilai kunci objek akan menyebabkan perubahan nilai kunci objek di utas lain.

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

BerikanThreadDictobjek yang dicipta olehDict()fungsi kepada fungsi pelaksanaan utas serentak, dan menguji sama ada mengubah suai nilai kunci objek akan menyebabkan nilai kunci objek dalam utas lain berubah.

Apabila objek biasa diteruskan ke fungsi utas serentak, ia diteruskan sebagai salinan mendalam.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

menunggu

Peraturanpendingfungsi digunakan untuk mendapatkan bilangan benang serentak yang berjalan dalam program strategi semasa.

Peraturanpending()fungsi mengembalikan bilangan benang serentak bahawa program strategi semasa sedang berjalan.

nombor

masih belum selesai.

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

Buat dua benang yang berjalan serentak dan panggilpending()fungsi pada nod masa yang berbeza.

Apabila strategimain()fungsi mula berjalan, memanggil fungsipending()langsung akan kembali 1, kerana benang utama di mana strategimain()fungsi terletak juga benang menunggu.

Ia menyokong sistem backtesting dan persekitaran perdagangan langsung.

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

Tetapan Rangkaian Benang