Сынтаксическое руководство

В процессе загрузки ресурсов... загрузка...

прокрутка

Вthreadingobject - это глобальный инструмент управления многопотоками, который предоставляет такие функции, как создание одновременных потоков, блокировки потоков и объекты условий.threadingЭтот объект поддерживается толькоJavaScriptязыковой стратегии.

Нить

ВThread()Функция используется для создания одновременных потоков.

ВThread()функция возвращает aThreadобъект, который используется для управления созданными параллельными потоками, коммуникацией потоков и т.д.

Threadобъект

Ведущий (забавный) Речь идет о... предметах.

Параметрfuncявляется функцией для одновременного выполнения (передается по ссылке) и поддерживает передачу анонимных функций.funcможет принимать несколько параметров, которые будут передаваться через...argsПоэтому список параметровfuncдолжна соответствовать...args.

Функция неправда Функция Параметрargявляется фактическим параметром, переданнымfunc(т.е. функция одновременного выполнения потока) при выполнении обратного вызова; может быть несколько параметровarg, и перечень параметровfuncдолжна соответствовать...args.

арг ложное string, number, bool, object, array, function, null value и другие типы, поддерживаемые системой Параметрitemпредставляет собой массив, содержащий ссылки на функции и их параметры, которые должны быть выполнены одновременно.itemпараметры могут быть переданы при вызовеThread function.

пункт неправда массив

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

Создавать одновременные потоки как для пользовательской функции, так и для анонимной функции.

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

ИспользуйтеThread(...items)Форма для создания одновременных потоков и выполнения нескольких функций последовательно.

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

Он поддерживает передачу параметров одновременно выполняемым функциям.

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

Он поддерживает передачу последовательностей функций и может импортировать внешние библиотеки динамически для одновременного вычисления.

Функция ниткиfuncпрошел вThread()Функция для одновременного выполнения выполняется в изолированной среде, поэтому переменные за пределами потока не могут быть напрямую ссылаются, и компиляция не удастся при ссылке. В то же время ссылки на другие функции закрытия не поддерживаются в потоке. Все API, предоставляемые платформой, могут быть вызваны в потоке, но другие функции, определенные пользователем, не могут быть вызваны.

Все параллельные функции, связанные с потоком, поддерживаются только как совместимость кода в системе параллельного тестирования и не будут фактически выполняться параллельными потоками, поэтому они не будут повторяться в этой главе.

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

ВgetThread()функция используется для получения объекта потока на основе указанного ID потока.

ВgetThread()функция возвращаетThreadОбъект с threadId, указанный параметром

Threadобъект

getThread ((ThreadId)

ПараметрthreadIdПолучить соответствующий объект потока, указав параметр.

Проводка неправда Номер

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

Получить указанный объект потока черезthreadId.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

Если вы хотите получить нить была выполнена и выпущена, вы не можете использоватьthreading.getThread(threadId)чтобы получить предмет нитки нитки.

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

Главная нить

ВmainThread()Функция используется для получения объекта нитки основного нитки, то есть нитки, гдеmain()функция в стратегии расположена.

ВmainThread()Функция возвращает объект потока основного потока.

Threadобъект

ГлавныйThread ((()

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

ВозьмиThreadОбъект основной нити и выходthreadIdГлавной нитью.

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

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

Объект нитки основной нитки также может быть получен в одновременных нитках.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

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

текущая нить

ВcurrentThread()функция используется для получения объекта потока текущей потоки.

ВcurrentThread()функция возвращает объект потока текущей потоки.

Threadобъект

текущийThread ((()

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

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

ВозьмиThreadобъекта текущей нити и выходthreadIdтекущей нити.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

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

Замок.

ВLock()Функция используется для создания объекта блокировки потока.

ВLock()Функция возвращает объект блокировки потока.

ThreadLockобъект

Замок ((()

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

Два параллельных потока получают доступ к общему ресурсу.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

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

Состояние

ВCondition()функция используется для создания объекта переменной условия, который используется для достижения синхронизации и связи между потоками в многопоточной параллельной среде.Condition(), нить может ждать, когда определенные условия не выполнены, пока другая нить не уведомит ее о том, что условие выполнено.

ВCondition()функция возвращает aThreadCondition object.

ThreadConditionобъект

Состояние

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

Два параллельных потока получают доступ к общему ресурсу.

Система обратного тестирования не реализует эту функциональность, она только определяет ее.

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

Событие

ВEvent()функция используется для созданиясобытие потокаобъект, который используется для синхронизации между потоками, позволяя одному потоку ждать уведомления или сигнала от другого потока.

ВEvent()функция возвращает aThreadEvent object.

ThreadEventобъект

Событие

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

Два параллельных потока получают доступ к общему ресурсу.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

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

Диктант

ВDict()Функция используется для создания объекта словаря для передачи на одновременные потоки.

ВDict()функция возвращает aThreadDict object.

ThreadDictобъект

Диктант

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

Передача нормального объекта на функцию выполнения параллельного потока, чтобы проверить, будет ли изменение значения ключа объекта вызывать изменения значения ключа объекта в других потоках.

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

ПередайThreadDictОбъект, созданныйDict()Функция выполняется одновременно с функцией выполнения потока, и проверяется, будет ли изменение значения ключа объекта приводить к изменению значения ключа объекта в других потоках.

При передаче общего объекта в функцию параллельного потока, он передается как глубокая копия.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

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

В ожидании

ВpendingФункция используется для получения количества одновременных потоков, работающих в текущей программе стратегии.

Вpending()функция возвращает количество одновременных потоков, которые запускает текущая стратегия программы.

Номер

В ожидании))

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

Создать два одновременно работающих потока и вызватьpending()Функция в разных временных узлах.

Когда стратегияmain()Функция начинает работать, вызывая функциюpending()непосредственно вернет 1, потому что основная нить, где стратегияmain()функция находится также в ожидании нить.

Он поддерживает систему обратного тестирования и среду торговли в реальном времени.

Настройки сети Нить