Pembuatan thread

Peraturanthreadingobject adalah alat manajemen multithreading global yang menyediakan fungsi seperti membuat thread paralel, kunci thread, dan objek kondisi.threadingObyek ini hanya didukung olehJavaScriptstrategi bahasa.

Benang

PeraturanThread()fungsi digunakan untuk membuat thread bersamaan.

PeraturanThread()fungsi mengembalikan aThreadobjek, yang digunakan untuk mengelola thread yang dibuat secara bersamaan, komunikasi thread, dll.

Threadobjek

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

Parameterfuncadalah fungsi untuk eksekusi bersamaan (diperkenalkan dengan referensi), dan mendukung pemasangan fungsi anonim.funcdapat menerima beberapa parameter, yang akan diteruskan melalui...argsOleh karena itu, daftar parameter darifuncharus konsisten dengan...args.

fungsi benar fungsi Parameterargadalah parameter aktual yang diteruskan kefunc(yaitu fungsi pelaksanaan thread bersamaan) ketika callback dijalankan; mungkin ada beberapa parameterarg, dan daftar parameter darifuncharus konsisten dengan...args.

arg palsu string, number, bool, object, array, function, null value dan tipe lain yang didukung oleh sistem Parameteritemadalah array yang berisi referensi fungsi dan parameter mereka yang akan dijalankan secara bersamaan.itemparameter dapat diteruskan dalam ketika memanggilThread function.

item benar 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 thread bersamaan untuk fungsi kustom dan fungsi anonim.

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 membuat thread bersamaan dan menjalankan beberapa fungsi secara berurutan.

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

Ini mendukung lulus parameter ke fungsi yang dijalankan secara bersamaan.

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

Ini mendukung lulus dalam string fungsi dan dapat mengimpor perpustakaan eksternal secara dinamis untuk komputasi simultan.

Fungsi benangfuncmelewati ke dalamThread()fungsi untuk eksekusi bersamaan berjalan di lingkungan yang terisolasi, sehingga variabel di luar thread tidak dapat dirujuk secara langsung, dan kompilasi akan gagal ketika dirujuk. Pada saat yang sama, referensi ke fungsi penutupan lainnya tidak didukung di dalam thread. Semua API yang disediakan oleh platform dapat dipanggil di dalam thread, tetapi fungsi yang didefinisikan pengguna lainnya tidak dapat dipanggil.

Ini mendukung sistem backtesting dan lingkungan perdagangan langsung. Semua fungsi terkait thread bersamaan hanya didukung sebagai kompatibilitas kode dalam sistem backtesting dan tidak akan benar-benar dieksekusi oleh thread bersamaan, jadi mereka tidak akan diulang 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 ini 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 sesuai dengan menentukan parameter.

ThreadId benar Nomor

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 thread yang ditentukan melaluithreadId.

Ini mendukung sistem backtesting dan lingkungan perdagangan langsung.

Jika thread yang ingin Anda dapatkan telah dieksekusi dan dilepaskan, Anda tidak dapat 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 dari benang utama, yaitu benang di manamain()fungsi dalam strategi yang terletak.

PeraturanmainThread()fungsi mengembalikan objek thread dari thread utama.

Threadobjek

mainThread ((()

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

DapatkanThreadobjek dari benang utama dan outputthreadIddari 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 dari benang utama juga dapat diperoleh dalam benang paralel.

Ini mendukung sistem backtesting dan lingkungan 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/threading/Dict Dict}, {@fun/Threads/threading/threading/pending pending}, {@fun/Threads/threading/eventLoop Loop}

Thread saat ini

PeraturancurrentThread()fungsi digunakan untuk mendapatkan objek thread dari thread saat ini.

PeraturancurrentThread()fungsi mengembalikan objek thread dari thread saat ini.

Threadobjek

currentThread ((()

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

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

DapatkanThreadobjek dari benang arus dan outputthreadIddari benang saat ini.

Ini mendukung sistem backtesting dan lingkungan perdagangan langsung.

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

Kunci

PeraturanLock()fungsi digunakan untuk membuat obyek thread lock.

PeraturanLock()fungsi mengembalikan objek thread lock.

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 thread bersamaan mengakses sumber daya yang sama.

Ini mendukung sistem backtesting dan lingkungan 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}

Kondisi

PeraturanCondition()fungsi digunakan untuk membuat objek variabel kondisi, yang digunakan untuk mencapai sinkronisasi dan komunikasi antara thread dalam lingkungan serentak multi-threaded.Condition(), sebuah thread dapat menunggu ketika kondisi tertentu tidak terpenuhi sampai thread lain memberitahunya bahwa kondisi telah terpenuhi.

PeraturanCondition()fungsi mengembalikan aThreadCondition object.

ThreadConditionobjek

Kondisi

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 thread bersamaan mengakses sumber daya yang sama.

Sistem backtesting tidak menerapkan fungsi ini, hanya mendefinisikannya.

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

Peristiwa

PeraturanEvent()fungsi digunakan untuk membuatacara threadobjek, yang digunakan untuk sinkronisasi antara thread, memungkinkan satu thread untuk menunggu pemberitahuan atau sinyal dari thread 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 thread bersamaan mengakses sumber daya yang sama.

Ini mendukung sistem backtesting dan lingkungan 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/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop eventop}

Dict

PeraturanDict()fungsi digunakan untuk membuat objek kamus untuk lulus ke thread bersamaan.

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

Melalui objek normal ke fungsi pelaksanaan thread bersamaan untuk menguji apakah memodifikasi nilai kunci objek akan menyebabkan perubahan nilai kunci objek di thread 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 dibuat olehDict()fungsi ke fungsi eksekusi thread bersamaan, dan menguji apakah memodifikasi nilai kunci objek akan menyebabkan nilai kunci objek dalam thread lain berubah.

Ketika sebuah objek umum diteruskan ke fungsi thread bersamaan, itu diteruskan sebagai salinan mendalam.

Ini mendukung sistem backtesting dan lingkungan 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/threading/pending pending}, {@fun/Threads/threading/eventLoop}

sedang menunggu

PeraturanpendingFungsi ini digunakan untuk mendapatkan jumlah thread bersamaan yang berjalan dalam program strategi saat ini.

Peraturanpending()fungsi mengembalikan jumlah thread bersamaan yang sedang dijalankan oleh program strategi saat ini.

nomor

sedang menunggu ((()

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 thread yang berjalan bersamaan dan panggilpending()fungsi pada titik waktu yang berbeda.

Ketika strategimain()fungsi mulai berjalan, memanggil fungsipending()langsung akan mengembalikan 1, karena benang utama di mana strategimain()fungsi yang terletak juga thread yang sedang menunggu.

Ini mendukung sistem backtesting dan lingkungan 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}

Pengaturan Jaringan Benang