थ्रेडिंग

..threadingobject एक वैश्विक मल्टीथ्रेडिंग प्रबंधन उपकरण है जो समवर्ती थ्रेड, थ्रेड लॉक, और शर्त ऑब्जेक्ट बनाने जैसे कार्य प्रदान करता है। यह अनुभाग सदस्य कार्यों का परिचय देता हैthreadingइस ऑब्जेक्ट केवल द्वारा समर्थित हैJavaScriptभाषा रणनीति।

धागा

..Thread()समारोह समवर्ती धागे बनाने के लिए प्रयोग किया जाता है.

..Thread()फ़ंक्शन a लौटाता हैThreadऑब्जेक्ट, जिसका उपयोग बनाए गए समवर्ती थ्रेड, थ्रेड संचार आदि को प्रबंधित करने के लिए किया जाता है।

Threadवस्तु

थ्रेड ((मज़ा,... args) थ्रेड ((...आइटम)

पैरामीटर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 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()समवर्ती निष्पादन के लिए फ़ंक्शन एक अलग वातावरण में चलता है, इसलिए थ्रेड के बाहर के चर का सीधे संदर्भ नहीं दिया जा सकता है, और संदर्भित होने पर संकलन विफल हो जाएगा। उसी समय, थ्रेड के भीतर अन्य क्लोजर फ़ंक्शन के संदर्भ का समर्थन नहीं किया जाता है। प्लेटफ़ॉर्म द्वारा प्रदान किए गए सभी एपीआई को थ्रेड के भीतर बुलाया जा सकता है, लेकिन अन्य उपयोगकर्ता-परिभाषित फ़ंक्शन को नहीं बुलाया जा सकता है।

यह बैकटेस्टिंग सिस्टम और लाइव ट्रेडिंग वातावरण का समर्थन करता है। सभी समवर्ती धागे से संबंधित कार्यों को केवल बैकटेस्टिंग सिस्टम में कोड संगतता के रूप में समर्थित किया जाता है और वास्तव में समवर्ती धागे द्वारा निष्पादित नहीं किया जाएगा, इसलिए वे इस अध्याय में दोहराए नहीं जाएंगे।

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

getThread

..getThread()फ़ंक्शन का उपयोग निर्दिष्ट थ्रेड आईडी के आधार पर थ्रेड ऑब्जेक्ट प्राप्त करने के लिए किया जाता है.

..getThread()फ़ंक्शन रिटर्नThreadपैरामीटर द्वारा निर्दिष्ट threadId के साथ वस्तु

Threadवस्तु

getThread ((थ्रेडआईडी)

पैरामीटर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/Lock Lock}, {@fun/Threads/threading/eventLoop}

मुख्यथ्रेड

..mainThread()मुख्य धागे की धागा वस्तु प्राप्त करने के लिए, अर्थात् धागा जहांmain()रणनीति में कार्य स्थित है।

..mainThread()फ़ंक्शन मुख्य फ़ंक्शन के थ्रेड ऑब्जेक्ट को लौटाता है.

Threadवस्तु

mainThread()

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

वर्तमान थ्रेड

..currentThread()फ़ंक्शन का प्रयोग वर्तमान फ़ंक्शन के थ्रेड ऑब्जेक्ट को प्राप्त करने के लिए किया जाता है.

..currentThread()फ़ंक्शन वर्तमान फ़ंक्शन के थ्रेड ऑब्जेक्ट को लौटाता है.

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

ताला

..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/eventLoop}

स्थिति

..Condition()function का उपयोग एक condition variable object बनाने के लिए किया जाता है, जिसका उपयोग मल्टी-थ्रेडेड समवर्ती वातावरण में थ्रेडों के बीच सिंक्रनाइज़ेशन और संचार प्राप्त करने के लिए किया जाता है।Condition(), एक थ्रेड जब कुछ शर्तें पूरी नहीं होती हैं तब तक प्रतीक्षा कर सकता है जब तक कि कोई अन्य थ्रेड उसे सूचित नहीं करता कि शर्त पूरी हो गई है।

..Condition()फ़ंक्शन a लौटाता हैThreadCondition 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/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threading/eventLoop}

घटना

..Event()फ़ंक्शन का उपयोग एक बनाने के लिए किया जाता हैथ्रेड घटनाऑब्जेक्ट, जिसका उपयोग थ्रेडों के बीच सिंक्रनाइज़ेशन के लिए किया जाता है, जिससे एक थ्रेड दूसरे थ्रेड से सूचना या संकेत का इंतजार कर सकता है।

..Event()फ़ंक्शन a लौटाता हैThreadEvent 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/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}, {@fun/Threads/threads/threading/Dict Dict}, {@fun/Threads/threading/pending pending}, {@fun/Threads/threads/threading/eventLoop}

डिक्टे

..Dict()function का उपयोग समवर्ती धागे में पारित करने के लिए एक शब्दकोश वस्तु बनाने के लिए किया जाता है.

..Dict()फ़ंक्शन a लौटाता हैThreadDict 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/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}

प्रतीक्षा में

..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()फ़ंक्शन स्थित है भी एक लंबित धागा है.

यह बैकटेस्टिंग प्रणाली और लाइव ट्रेडिंग वातावरण का समर्थन करता है।

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

नेट सेटिंग्स धागा