### Thread
```Thread()```函数用于创建并发线程。
```Thread()```函数返回一个```Thread```对象，用于管理创建出的并发线程、线程通信等。
```Thread```对象
Thread(func, ...args)
Thread(...items)
参数```func```是用于并发执行的函数（通过引用传递），支持传入匿名函数。```func```可接受多个参数，这些参数将在并发执行时通过```...args```传入。因此，```func```的参数列表需要与```...args```一致。
func
true
function
参数```arg```是在回调执行时传递给```func```（即并发线程执行函数）的实际参数；参数```arg```可能有多个，```func```的参数列表需要与```...args```一致。
arg
false
string、number、bool、object、array、function、空值等系统支持的所有类型
参数```item```是一个数组，包含待并发执行的函数引用及其参数，调用```Thread```函数时的参数```item```可以传入多组。
item
true
array
```javascript
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)
}
इनपुट फ़ंक्शन संख्यात्मक स्ट्रिंग का समर्थन करता है, जो गतिशील रूप से एक बाहरी संग्रह में आयात किया जा सकता है।
प्रवेशThread()फ़ंक्शन एक साथ निष्पादित किए जाने वाले स्ट्रिंग फ़ंक्शन के लिए उपयोग किया जाता हैfuncएक अलग वातावरण में चल रहा है, इसलिए सीधे थ्रेड के बाहर के चर का संदर्भ नहीं ले सकता है, संदर्भ के दौरान संकलन विफलता; साथ ही, थ्रेड में अन्य समापन कार्यों का संदर्भ लेने का समर्थन नहीं करता है; थ्रेड के भीतर प्लेटफॉर्म द्वारा प्रदान किए गए सभी एपीआई को बुलाया जा सकता है, लेकिन उपयोगकर्ता द्वारा अनुकूलित अन्य कार्यों को नहीं बुलाया जा सकता है।
जब कोई थ्रेड निष्पादित हो जाता है और लगातार संदर्भित नहीं होता है, तो सिस्टम बेसलेयर स्वचालित रूप से थ्रेड से संबंधित संसाधनों को पुनः प्राप्त करता है, बिना किसी स्पष्ट कॉल केjoin()फ़ंक्शन संसाधनों को मुक्त करने के लिए। यदि निरंतर संदर्भ के कारण संसाधनों को मुक्त नहीं किया जा सकता है, तो 2000 से अधिक के साथ-साथ रिलीज़ होने की संख्या में त्रुटि होगीःInternalError: too many routine wait, max is 2000。
समर्थन पुनरावृत्ति प्रणाली, वास्तविक डिस्क वातावरण; सभी समवर्ती धागे से संबंधित कार्य, पुनरावृत्ति प्रणाली में केवल कोड संगतता समर्थन के रूप में, वास्तव में वास्तविक समवर्ती धागे निष्पादन नहीं करते हैं, इस अध्याय में और अधिक चर्चा नहीं की जाएगी।
{@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()```函数返回通过参数指定threadId的```Thread```对象
```Thread```对象
getThread(threadId)
参数```threadId```为线程对象Id，通过指定参数获取对应的线程对象。
threadId
true
number
```javascript
function main() {
var t1 = threading.Thread(function () {
// Thread 对象有方法：id()，用于获取线程的Id，可以查看文档对应Thread对象的章节
var id = threading.currentThread().id()
var thread1 = threading.getThread(id)
Log("id:", id, ", thread1.id():", thread1.id())
Log(`id == thread1.id():`, id == thread1.id())
})
t1.join()
}
अनुमोदित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()```函数返回主线程的线程对象。
```Thread```对象
mainThread()
```javascript
function main() {
Log("主线程的threadId：", threading.mainThread().id())
}
मुख्य सूत्रों को प्राप्त करने के लिएThreadऑब्जेक्ट, आउटपुट मेन थ्रेडthreadId。
function test() {
Log("test函数中输出主线程Id：", 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()```函数返回当前线程的线程对象。
```Thread```对象
currentThread()
```javascript
function test() {
Log("当前线程的Id：", 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()```函数返回一个线程锁对象。
```ThreadLock```对象
Lock()
```javascript
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()```函数返回一个```ThreadCondition```对象。
```ThreadCondition```对象
Condition()
```javascript
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()```函数返回一个```ThreadEvent```对象。
```ThreadEvent```对象
Event()
```javascript
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()```函数返回一个```ThreadDict```对象。
```ThreadDict```对象
Dict()
```javascript
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()
}
समवर्ती धागे के लिए निष्पादन फ़ंक्शन को भेजेंDict()फ़ंक्शन द्वारा बनाया गयाThreadDictऑब्जेक्ट, परीक्षण करता है कि क्या ऑब्जेक्ट के कुंजी मान को संशोधित करने के बाद किसी अन्य धागे में ऑब्जेक्ट कुंजी मान का परिवर्तन होता है।
जब कोई सामान्य वस्तु में एक स्ट्रिंग के साथ-साथ एक फ़ंक्शन आता है, तो इसे एक गहरी प्रति के रूप में पारित किया जाता है, जिससे एक स्ट्रिंग के साथ-साथ कुंजी मानों को संशोधित किया जा सकता है और अन्य स्ट्रिंगों में शब्दकोशों को प्रभावित नहीं किया जा सकता है।
यह एक बहुत ही सुविधाजनक और सुविधाजनक है।
{@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()```函数返回当前策略程序正在运行的并发线程数。
number
pending()
```javascript
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}
नेट सेटिंग्स धागा