संसाधन लोड हो रहा है... लोड करना...

धागे

एफएमजेड क्वांट ट्रेडिंग प्लेटफॉर्म वास्तव में मल्टी-थ्रेडेड फ़ंक्शन का समर्थन करता हैJavaScriptप्रणाली के नीचे से भाषा रणनीति, और निम्नलिखित उद्देश्यों को लागू करता हैः

वस्तुएँ निर्देश टिप्पणी
थ्रेडिंग बहु-थ्रेड वैश्विक वस्तु सदस्य के कार्य:Thread, getThread, mainThreadआदि।
धागा धागा वस्तु सदस्य के कार्य:peekMessage, postMessage, joinआदि।
थ्रेडलॉक थ्रेड लॉक ऑब्जेक्ट सदस्य के कार्य:acquire, releaseउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है।
थ्रेड घटना घटना वस्तु सदस्य के कार्य:set, clear, wait, isSetउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है।
थ्रेडCondition शर्त वस्तु सदस्य के कार्य:notify, notifyAll, wait, acquire, releaseउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है।
ThreadDict शब्दकोश वस्तु सदस्य के कार्य:get, setउन्हें थ्रेड निष्पादन फंक्शन के पैरामीटर के रूप में थ्रेड वातावरण में पारित किया जा सकता है।

थ्रेडिंग

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

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

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

धागा

Threadऑब्जेक्ट द्वारा बनाया या लौटाया जा सकता हैthreading.Thread(), threading.getThread(), threading.mainThread(), औरthreading.currentThread().

peekसंदेश

..peekMessage()फ़ंक्शन का उपयोग किसी थ्रेड से संदेश प्राप्त करने के लिए किया जाता है.

..peekMessage()फ़ंक्शन वर्तमान थ्रेड ऑब्जेक्ट से जुड़े थ्रेड द्वारा प्राप्त संदेश लौटाता है.

string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं

peekMessage() peekMessage ((टाइमआउट)

पैरामीटरtimeouttimeout setting है. यह पैरामीटर द्वारा सेट मिलीसेकंड की संख्या के लिए ब्लॉक और प्रतीक्षा करेगा और डेटा लौटाएगा. यदि कोई डेटा नहीं है और timeout सीमा से अधिक है, तो एक शून्य मान लौटाया जाएगा. यदिtimeout0 पर सेट है याtimeoutपैरामीटर पारित नहीं किया जाता है, इसका मतलब यह है कि प्रक्रिया अवरुद्ध होगा और प्रतीक्षा जब तक चैनल से डेटा प्राप्त होता है।timeoutयदि -१ पर सेट किया गया है, तो इसका अर्थ है कि प्रक्रिया तुरंत डेटा को ब्लॉक और वापस नहीं करेगी। यदि कोई डेटा नहीं है, तो शून्य मान वापस किया जाएगा।

टाइमआउट झूठी संख्या

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })

    while (true) {
        var msg = threading.currentThread().peekMessage()
        Log("main peekMessage():", msg)
        if (msg == 9) {
            break
        }
        Sleep(1000)
    }

    t1.join()
}

एक समवर्ती थ्रेड से मुख्य थ्रेड में संदेश भेजें.

जब हम प्रोग्राम लिखते हैं, तो हमें थ्रेड गतिरोध की समस्याओं पर ध्यान देने की आवश्यकता होती है।

{@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/join name}, {@Threads/Threads/eventLoop eventLoop}

पोस्टसंदेश

..postMessage()फ़ंक्शन का उपयोग किसी थ्रेड को संदेश भेजने के लिए किया जाता है.

postMessage(msg)

पैरामीटरmsgसंदेश भेजा जाना है।

msg सच सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, फ़ंक्शन, शून्य मान आदि।

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 postMessage():", i)
            threading.mainThread().postMessage(i)
            Sleep(500)
        }        
    })
    for (var i = 0; i < 10; i++) {
        var event = threading.mainThread().eventLoop()
        Log("main event:", event)
        Sleep(500)
    }
    t1.join()
}

समवर्ती थ्रेड में संदेश भेजें और उपयोग करेंeventLoop()संदेश सूचनाएं प्राप्त करने के लिए।

function main() {
    threading.mainThread().postMessage(function(msg) {
        Log("func from mainThread, msg:", msg)
    })
    
    threading.Thread(function() {
        var func = threading.mainThread().peekMessage()
        func("in " + threading.currentThread().name())
    }).join()
}

यह फ़ंक्शन भेजने का समर्थन करता है.

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

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name join}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/

सम्मिलित होना

..join()कार्य का उपयोग थ्रेड के बाहर निकलने और सिस्टम संसाधनों को पुनः प्राप्त करने के लिए किया जाता है।

..ThreadRetवस्तुनिष्पादन परिणाम के बारे में डेटा शामिल है। गुणों में निम्नलिखित शामिल हैंः

  • आईडीः थ्रेड आईडी
  • समाप्तः क्या धागा समाप्त करने के लिए मजबूर किया जाता है।
  • बीत गया: नैनोसेकंड में धागे का चलने का समय।
  • ret: थ्रेड फ़ंक्शन का रिटर्न मान.

ThreadRetवस्तु

सम्मिलित होना शामिल होना (timeout)

..timeoutपैरामीटर का उपयोग थ्रेड के समाप्त होने की प्रतीक्षा करने के लिए मिलीसेकंड में टाइमआउट सेट करने के लिए किया जाता है।timeoutपैरामीटर 0 पर सेट है याtimeoutपैरामीटर सेट नहीं है,join()फ़ंक्शन ब्लॉक होगा और प्रतीक्षा जब तक धागा निष्पादन समाप्त होता है.timeoutपैरामीटर -1 पर सेट है,join()कार्य तुरंत वापस आ जाएगा।

टाइमआउट झूठी संख्या

function main() {
    var t1 = threading.Thread(function() {
        Log("Hello thread1")
        Sleep(5000)
    })

    var ret = t1.join(1000)
    Log("ret:", ret)   // ret: undefined

    ret = t1.join()
    Log("ret:", ret)   // ret: {"id":1,"terminated":false,"elapsed":5003252000}
}

परीक्षण करेंjoin()टाइमआउट के लिए फ़ंक्शन और रिटर्न मान आउटपुट करें.

..join()फ़ंक्शन समय बाहर और लौटाता हैundefined.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}

समाप्त करना

..terminate()फ़ंक्शन का उपयोग किसी थ्रेड को जबरन समाप्त करने और बनाए गए थ्रेड द्वारा उपयोग किए जाने वाले हार्डवेयर संसाधनों को मुक्त करने के लिए किया जाता है.

समाप्त करना

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 10; i++) {
            Log("thread1 i:", i)
            Sleep(1000)
        }
    })

    Sleep(3000)
    t1.terminate()
    Log("after t1.terminate()")

    while (true) {
        LogStatus(_D())
        Sleep(1000)
    }
}

किसी थ्रेड के निष्पादन को बलपूर्वक समाप्त करें. किसी थ्रेड को बलपूर्वक समाप्त करने के बाद, लॉग में इस थ्रेड से कोई आउटपुट नहीं होगा.

धागे के लिए जो बलपूर्वक समाप्त होते हैंterminate()कार्य, हम अब उपयोग नहीं कर सकतेjoin()उन्हें समाप्त करने के लिए प्रतीक्षा करने के लिए समारोह.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@

getData प्राप्त करें

..getData()कार्य का उपयोग थ्रेड वातावरण में दर्ज चर तक पहुँचने के लिए किया जाता है।join()कार्य (सफलता से बाहर निकलने की प्रतीक्षा) और निष्पादित नहीं किया हैterminate()कार्य (गंजा को बलपूर्वक समाप्त करना) ।

..getData()फ़ंक्शन कुंजी मान के अनुरूप लौटाता हैkeyवर्तमान थ्रेड संदर्भ में संग्रहीत कुंजी-मूल्य जोड़ी में पैरामीटर.

string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं

getData() getData ((कुंजी)

..keyपैरामीटर संग्रहीत कुंजी-मूल्य जोड़ी का कुंजी नाम है.

कुंजी सच स्ट्रिंग

function main() {
    var t1 = threading.Thread(function() {
        for (var i = 0; i < 5; i++) {
            threading.currentThread().setData("count", i)
            Log(`setData("count"):`, i)
            Sleep(1000)
        }
    })
    for (var i = 0; i < 5; i++) {
        var count = threading.getThread(t1.id()).getData("count")
        Log(`getData("count"):`, count)
        Sleep(1000)
    }
    t1.join()
}

कुंजी का मान दर्ज करेंcountसमवर्ती धागा पर्यावरण में, और फिर की कुंजी मूल्य पढ़नाcountमुख्य धागे में।

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}

setData

..setData()फ़ंक्शन का उपयोग थ्रेड संदर्भ में चर को संग्रहीत करने के लिए किया जाता है.

setData ((कुंजी, मान)

..keyपैरामीटर का उपयोग संग्रहीत कुंजी-मूल्य जोड़ी के कुंजी नाम को निर्दिष्ट करने के लिए किया जाता है.

कुंजी सच स्ट्रिंग दvalueपैरामीटर का उपयोग संग्रहीत कुंजी-मूल्य जोड़ी के कुंजी मूल्य को निर्दिष्ट करने के लिए किया जाता है।

मूल्य सच सिस्टम द्वारा समर्थित कोई भी प्रकार, जैसे स्ट्रिंग, संख्या, बोल, ऑब्जेक्ट, सरणी, फ़ंक्शन, शून्य मान आदि।

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Sleep(1000)
    Log(`t1.getData("data"):`, t1.getData("data"))
    t1.join()
}

समवर्ती धागे में कुंजी-मूल्य जोड़ी सेट करें और मुख्य धागे में कुंजी-मूल्य जोड़ी पढ़ें.

function main() {
    threading.mainThread().setData("func2", function(p) {
        Log("func2 p:", p)
    })
    
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("func1", function(p) {
            Log("func1 p:", p)
        })
    
        var func2 = threading.mainThread().getData("func2")
        func2("test2")
    })
    
    Sleep(1000)
    var func1 = t1.getData("func1")
    func1("test1")
    t1.join()
}

यह फ़ंक्शन में कुंजी-मूल्य पारित करने का समर्थन करता है।

डेटा वैध है जब धागा निष्पादित नहीं किया हैjoin()कार्य (सफलता से बाहर निकलने की प्रतीक्षा) और निष्पादित नहीं किया हैterminate()फंक्शन (कठोर रूप से धागे को समाप्त करना) पैरामीटर का मानvalueएक serializable चर होना चाहिए.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@

आईडी

..id()फ़ंक्शन का उपयोग लौटाता हैthreadIdवर्तमान मल्टीथ्रेडेड ऑब्जेक्ट इंस्टेंस का.

रिटर्न मूल्यid()कार्य हैthreadId.

संख्या

id()

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.id():`, t1.id())
    t1.join()
}

एक साथ चलने वाला थ्रेड बनाएँ और आउटपुटthreadIdमुख्य धागे में इस समानांतर धागे के।

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/name name name}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/thread/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/eventLoop eventLoop}, {@fun/Threads/event

नाम

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

..name()फ़ंक्शन समवर्ती थ्रेड नाम लौटाता है.

स्ट्रिंग

नाम

function main() {
    var t1 = threading.Thread(function() {
        threading.currentThread().setData("data", 100)
    })
    Log(`t1.name():`, t1.name())  // t1.name(): Thread-1
    t1.join()
}

एक समवर्ती थ्रेड बनाएँ और मुख्य थ्रेड में समवर्ती थ्रेड का नाम आउटपुट करें.

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData set}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/Thread/eventLoop}, {@fun/Threads/Thread/eventLoop eventLoop}, {@fun/Threads/

घटना लूप

..eventLoop()फ़ंक्शन का उपयोग थ्रेड द्वारा प्राप्त घटनाओं के लिए सुनने के लिए किया जाता है.

..eventLoop()फ़ंक्शन वर्तमान थ्रेड द्वारा प्राप्त घटना जानकारी लौटाता है.घटना सूचना संरचना.

वस्तु, शून्य मान

घटनाLoop() घटना लूप (टाइमआउट)

पैरामीटरtimeoutमिलीसेकंड में टाइमआउट सेटिंग है. यदि पैरामीटरtimeoutयदि यह 0 से अधिक है, तो यह घटना प्रतीक्षा समय सीमा सेट करेगा। यदि यह 0 से कम है, तो यह नवीनतम घटना को तुरंत लौटाएगा।

टाइमआउट झूठी संख्या

function main() {
    var t1 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop()     // Blocking wait
            // 2024-11-14 10:14:18 thread1 eventMsg: {"Seq":1,"Event":"thread","ThreadId":0,"Index":1,"Queue":0,"Nano":1731550458699947000}
            Log(_D(), "thread1 eventMsg:", eventMsg)
        }
    })

    var t2 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(-1)   // Return immediately
            Log(_D(), "thread2 eventMsg:", eventMsg)
            Sleep(5000)
        }
    })

    var t3 = threading.Thread(function() {
        while (true) {
            var eventMsg = threading.currentThread().eventLoop(3000) // Set a 3 second timeout
            Log(_D(), "thread3 eventMsg:", eventMsg)
        }
    })

    t1.postMessage("Hello ", t1.name())
    t2.postMessage("Hello ", t2.name())
    t3.postMessage("Hello ", t3.name())
    t1.join()
    t2.join()
    t3.join()
}

एक साथ तीन थ्रेड निष्पादित करें और प्राप्त घटना जानकारी आउटपुट करें. यदि टाइमआउट होता है या फ़ंक्शन तुरंत वापस आता है, तो आउटपुट मान शून्य है.

प्रक्रिया तंत्रeventLoop()समारोह वैश्विक समारोह के समान हैEventLoop().

{@fun/Threads/Thread/peekMessage peekMessage}, {@fun/Threads/Thread/postMessage postMessage}, {@fun/Threads/Thread/join join}, {@fun/Threads/Thread/terminate terminate}, {@fun/Threads/Thread/getData getData}, {@fun/Threads/Threads/setData setData}, {@fun/Threads/Thread/id id}, {@fun/Threads/Threads/Thread/name name name}, {@fun/Threads/name name name}, {@fun/Threads/Thread/name name name}, {@fun/Threads/data setData}, {@fun/Threads/Threads/id id}, {@fun/Threads/Thread/name name}, {@fun/Threads/name name name}, {@fun/Threads/Thread/name name name}, {@fun/Thre

थ्रेडलॉक

थ्रेड लॉक ऑब्जेक्ट, बहु-थ्रेड सिंक्रनाइज़ेशन प्रसंस्करण के लिए प्रयोग किया जाता है.

प्राप्त करना

..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक (लॉक) का अनुरोध करने के लिए किया जाता है।

प्राप्त करना

कृपया देखेंthreading.Lock()उदाहरणों के लिए अनुभाग।

..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक अनुरोध करने के लिए किया जाता है. जब एक थ्रेड कॉल करता हैacquire()एक थ्रेड लॉक ऑब्जेक्ट का कार्य, यह लॉक प्राप्त करने का प्रयास करता है। यदि लॉक वर्तमान में किसी अन्य थ्रेड द्वारा आयोजित नहीं किया जाता है, तो कॉलिंग थ्रेड सफलतापूर्वक लॉक प्राप्त करता है और निष्पादन जारी रखता है। यदि लॉक पहले से ही किसी अन्य थ्रेड द्वारा आयोजित किया जाता है, तो थ्रेड कॉल करनाacquire()जब तक ताला खोला नहीं जाता तब तक बंद रहेगा।

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/release release}

विमोचन

..release()फ़ंक्शन का प्रयोग धागे के ताले को खोलने के लिए किया जाता है।

विमोचन

function consumer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        pLock.acquire()
        cLock.acquire()
        var arr = dict.get("array")
        var count = arr.shift()
        dict.set("array", arr)
        Log("consumer:", count, ", array:", arr)
        cLock.release()
        Sleep(1000)
        pLock.release()
    }
}

function producer(productionQuantity, dict, pLock, cLock) {
    for (var i = 0; i < productionQuantity; i++) {
        cLock.acquire()   // cLock.acquire() placed after pLock.acquire() will not cause deadlock
        pLock.acquire()   
        var arr = dict.get("array")
        arr.push(i)
        dict.set("array", arr)
        Log("producer:", i, ", array:", arr)
        pLock.release()
        Sleep(1000)
        cLock.release()
    }
}

function main() {
    var dict = threading.Dict()
    dict.set("array", [])
    var pLock = threading.Lock()
    var cLock = threading.Lock()
    var productionQuantity = 10
    var producerThread = threading.Thread(producer, productionQuantity, dict, pLock, cLock)
    var consumerThread = threading.Thread(consumer, productionQuantity, dict, pLock, cLock)

    consumerThread.join()
    producerThread.join()
}

गतिरोध के परिदृश्यों का परीक्षण

यह ध्यान दिया जाना चाहिए कि धागे के ताले का अनुचित उपयोग गतिरोध का कारण बन सकता है।

{@fun/Threads/threading/Lock Lock}, {@fun/Threads/ThreadLock/acquire acquire}

थ्रेड घटना

घटना वस्तु, बहु-थ्रेडेड घटना अधिसूचना और संकेत के लिए प्रयोग की जाती है।

सेट

..set()समारोह का उपयोग घटनाओं (सेट संकेत) को सूचित करने के लिए किया जाता है।

सेट (()

कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।

यदि सिग्नल का उपयोग करके सेट किया गया हैset(), यह फिर से सेट नहीं किया जा सकता है. हम संकेत को साफ करने और इसे फिर से सेट करने की जरूरत है.

{@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

स्पष्ट

..clear()सिग्नल को साफ करने के लिए फ़ंक्शन का प्रयोग किया जाता है।

साफ

कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/wait wait}, {@fun/Threads/ThreadEvent/isSet isSet}

प्रतीक्षा करो

..wait()function का उपयोग एक घटना (सिग्नल) प्रतीक्षा सेट करने के लिए किया जाता है, और घटना (सिग्नल) सेट होने से पहले ब्लॉक हो जाएगा; यह एक टाइमआउट पैरामीटर सेट करने का समर्थन करता है।

..wait()फ़ंक्शन लौटाता है कि क्या टाइमआउट हुआ है. यदि हां, तो यह एक सही मान लौटाता है.

बोल

प्रतीक्षा करो प्रतीक्षा (टाइमआउट)

..timeoutपैरामीटर का उपयोग प्रतीक्षा समय को मिलीसेकंड में सेट करने के लिए किया जाता है।

टाइमआउट झूठी संख्या

function main() {
    var event = threading.Event()
    var t1 = threading.Thread(function(event) {
        var ret = event.wait(100)
        Log(`event.wait(100):`, ret)
        ret = event.wait()
        Log(`event.wait():`, ret)
    }, event)

    Sleep(1000)
    event.set()
    t1.join()
}

रिटर्न मान का परीक्षण करेंwait() function.

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/isSet isSet}

isSet

..isSet()फ़ंक्शन का उपयोग यह निर्धारित करने के लिए किया जाता है कि क्या कोई घटना (सिग्नल) सेट की गई है।

..isSet()फ़ंक्शन लौटाता है कि क्या घटना (सिग्नल) सेट की गई है; यदि घटना (सिग्नल) सेट की गई है, तो यह एक सही मान लौटाता है।

बोल

isSet()

कृपया देखेंthreading.Event()उदाहरणों के लिए अनुभाग।

{@fun/Threads/ThreadEvent/set set}, {@fun/Threads/ThreadEvent/clear clear}, {@fun/Threads/ThreadEvent/wait wait}

थ्रेडCondition

बहु-थ्रेड सिंक्रनाइज़ेशन के लिए उपयोग की जाने वाली स्थिति वस्तु।

सूचित करना

..notify()function का उपयोग प्रतीक्षा थ्रेड (यदि कोई हो) को जगाने के लिए किया जाता है. केवल थ्रेड जो कॉल किया हैwait()विधि जागृत हो जाएगा।

सूचित करना

function consumer(dict, condition) {
    while (true) {
        condition.acquire()
        while (dict.get("array").length == 0) {
            Log(threading.currentThread().name(), "wait()...", ", array:", dict.get("array"))
            condition.wait()
        }
        var arr = dict.get("array")
        var num = arr.shift()
        Log(threading.currentThread().name(), ", num:", num, ", array:", arr, "#FF0000")
        dict.set("array", arr)
        Sleep(1000)
        condition.release()
    }
}

function main() {
    var condition = threading.Condition()
    var dict = threading.Dict()
    dict.set("array", [])
    var t1 = threading.Thread(consumer, dict, condition)
    var t2 = threading.Thread(consumer, dict, condition)
    var t3 = threading.Thread(consumer, dict, condition)
    Sleep(1000)
    var i = 0
    while (true) {
        condition.acquire()
        var msg = ""
        var arr = dict.get("array")
        var randomNum = Math.floor(Math.random() * 5) + 1
        if (arr.length >= 3) {
            condition.notifyAll()
            msg = "notifyAll"
        } else {
            arr.push(i)
            dict.set("array", arr)
            if (randomNum > 3 && arr.length > 0) {
                condition.notify()
                msg = "notify"
            } else {
                msg = "pass"
            }
            i++
        }

        Log(_D(), "randomNum:", randomNum, ", array:", arr, ", msg:", msg)
        condition.release()
        Sleep(1000)
    }
}

उपयोग करेंnotify()कार्य प्रतीक्षा धागे को जगाने के लिए।

..notify()समारोह प्रतीक्षा कतार में एक धागा जागता है.

जबnotify()समारोह एक धागा जागता है, धागा धागा लॉक पुनः प्राप्त होगा.

{@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}, {@fun/Threads/ThreadCondition/release release}, {@fun/Threads/ThreadCondition/release release}

सभी को सूचित करें

..notifyAll()समारोह सभी प्रतीक्षा धागे जागता है.

सभी को सूचित करें

कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।

..notifyAll()कार्य सभी प्रतीक्षा धागे एक एक करके जागृत करता है, और जागृत धागे धागा ताला पुनः प्राप्त करते हैं।

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

प्रतीक्षा करो

..wait()कार्य का उपयोग कुछ डिज़ाइन की गई परिस्थितियों में थ्रेड को प्रतीक्षा करने के लिए किया जाता है।

प्रतीक्षा करो

कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।

..wait()कार्य थ्रेड लॉक को रिलीज़ करता है और जागने पर थ्रेड लॉक को पुनः प्राप्त करता है।

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/acquire acquire}, {@fun/Threads/ThreadCondition/release release}

प्राप्त करना

..acquire()फ़ंक्शन का उपयोग थ्रेड लॉक (लॉक) का अनुरोध करने के लिए किया जाता है।

प्राप्त करना

कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।

उपयोग करने से पहलेwait(), आपको वर्तमान स्थिति वस्तु के थ्रेड लॉक (लॉक) का अनुरोध करने की आवश्यकता है.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/release release}, {@fun/ThreadCondition/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/release release}, {@fun/ThreadCondition/release release}

विमोचन

..release()फ़ंक्शन का प्रयोग धागे के ताले को खोलने के लिए किया जाता है।

विमोचन

कृपया देखेंThreadCondition.notify()उदाहरणों के लिए अनुभाग।

उपयोग के बादwait(), हम वर्तमान स्थिति वस्तु के धागे लॉक (अनलॉक) को जारी करने की जरूरत है.

{@fun/Threads/ThreadCondition/notify notify}, {@fun/Threads/ThreadCondition/notifyAll notifyAll}, {@fun/Threads/ThreadCondition/wait wait}, {@fun/Threads/ThreadCondition/acquire acquire}

ThreadDict

शब्दकोश वस्तु, डेटा साझा करने के लिए प्रयोग की जाती है।

प्राप्त करना

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

..get()फ़ंक्शन द्वारा निर्दिष्ट कुंजी का मान लौटाता हैkey parameter.

string, number, bool, object, array, null value और अन्य प्रकार जो सिस्टम द्वारा समर्थित हैं

प्राप्त करना (key)

..keyपैरामीटर का उपयोग प्राप्त की जाने वाली कुंजी के अनुरूप कुंजी नाम निर्दिष्ट करने के लिए किया जाता है।

कुंजी सच स्ट्रिंग

function main() {
    var event = threading.Event()
    var dict = threading.Dict()
    dict.set("data", 100)
    
    var t1 = threading.Thread(function(dict, event) {
        Log(`thread1, dict.get("data"):`, dict.get("data"))
        
        event.set()
        event.clear()
        
        event.wait()
        Log(`after main change data, thread1 dict.get("data"):`, dict.get("data"))
    
        dict.set("data", 0)
    }, dict, event)
    
    event.wait()
    
    dict.set("data", 99)
    
    event.set()
    event.clear()
    
    t1.join()
    Log(`main thread, dict.get("data"):`, dict.get("data"))
}

डेटा को पढ़ने और संशोधित करने के लिए थ्रेड को सूचित करने के लिए घटना वस्तुओं का उपयोग करें.

{@fun/Threads/ThreadDict/set set}

सेट

..set()एक कुंजी-मूल्य जोड़ी सेट करने के लिए फ़ंक्शन का उपयोग किया जाता है.

सेट (कुंजी, मान)

पैरामीटरkeyपरिवर्तित होने वाले कुंजी नाम को सेट करने के लिए प्रयोग किया जाता है.

कुंजी सच स्ट्रिंग पैरामीटरvalueपरिवर्तित होने वाले कुंजी मान को निर्धारित करने के लिए प्रयोग किया जाता है।

मूल्य सच string, number, bool, object, array, function, null value और सिस्टम द्वारा समर्थित अन्य प्रकार

function main() {
    var dict1 = threading.Dict()
    dict1.set("func1", function(p) {
        Log("func1 p:", p)
    })
    
    threading.Thread(function(dict1) {
        var func1 = dict1.get("func1")
        func1("test")
    }, dict1).join()
}

यह फ़ंक्शन में कुंजी-मूल्य पारित करने का समर्थन करता है।

{@fun/Threads/ThreadDict/get get} {@fun/Threads/ThreadDict/get get}

नेट सेटिंग्स वेब3

2019 FMZ - सभी अधिकार सुरक्षित