DiethreadingObject ist ein globales Multithreading-Management-Tool, das Funktionen wie das Erstellen von gleichzeitigen Threads, Thread-Locks und Condition-Objekten bietet.threadingObjekt. Dieses Objekt wird nur von derJavaScriptSprachstrategie.
DieThread()Funktion wird verwendet, um gleichzeitige Threads zu erstellen.
DieThread()Funktion gibt a zurückThreadObjekt, mit dem gleichzeitige Threads verwaltet werden, Threads kommunizieren usw.
ThreadGegenstand
Thread ((func,...args) Der Begriff "Thread" (Artikel)
Der Parameterfuncist eine Funktion zur gleichzeitigen Ausführung (übergeben durch Referenz) und unterstützt die Übergabe anonymer Funktionen.funckann mehrere Parameter akzeptieren, die durch...argsDaher wird die Parameterliste vonfuncdie in der Richtlinie...args.
Funktion
wahr
Funktion
Der Parameterargist der tatsächliche Parameter, der anfunc(d. h. die Funktion zur gleichzeitigen Ausführung von Threads), wenn der Rückruf ausgeführt wird; es kann mehrere Parameter gebenarg, und die Parameterliste derfuncdie in der Richtlinie...args.
Arg
falsche
String, Zahl, bool, Objekt, Array, Funktion, Nullwert und andere vom System unterstützte Typen
Der Parameteritemist ein Array, das die gleichzeitig auszuführenden Funktionsreferenzen und deren Parameter enthält.itemParameter können bei Aufruf derThread function.
Artikel wahr Reihenfolge
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()
}
Erstellen Sie gleichzeitige Threads für eine benutzerdefinierte Funktion und eine anonyme Funktion.
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()
}
VerwendenThread(...items)Form, um gleichzeitige Threads zu erstellen und mehrere Funktionen sequenziell auszuführen.
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)
}
Es unterstützt die Übergabe von Funktionsfolgen und kann dynamisch externe Bibliotheken für gleichzeitiges Rechnen importieren.
Die Fädenfunktionfuncin dieThread()Die Funktion für die gleichzeitige Ausführung läuft in einer isolierten Umgebung, so dass Variablen außerhalb des Threads nicht direkt referenziert werden können, und die Kompilierung wird beim Referenzieren fehlschlagen. Gleichzeitig werden Referenzen zu anderen Closure-Funktionen nicht innerhalb des Threads unterstützt. Alle von der Plattform bereitgestellten APIs können innerhalb des Threads aufgerufen werden, aber andere benutzerdefinierte Funktionen können nicht aufgerufen werden.
Es unterstützt Backtesting-System und Live-Trading-Umgebung. Alle gleichzeitigen Thread-bezogenen Funktionen werden nur als Code-Kompatibilität im Backtesting-System unterstützt und werden nicht tatsächlich von gleichzeitigen Threads ausgeführt, so dass sie in diesem Kapitel nicht wiederholt werden.
{@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 event}
DiegetThread()Die Funktion wird verwendet, um das Thread-Objekt basierend auf der angegebenen Thread-ID zu erhalten.
DiegetThread()Funktion gibt dieThreadObjekt mit der durch den Parameter angegebenen ThreadId
ThreadGegenstand
getThread (ThreadId)
Der ParameterthreadIdist die Thread-Objekt-ID. Erhalten Sie das entsprechende Thread-Objekt, indem Sie den Parameter angeben.
Schleifen wahr Zahl
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())
}
Das angegebene Thread-Objekt durchlaufenthreadId.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
Wenn der Thread, den Sie erhalten möchten, ausgeführt und freigegeben wurde, können Sie nicht verwendenthreading.getThread(threadId)um das Gewindeobjekt des Gewindes zu erhalten.
{@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/event Loop}, {@fun/threads/threads/threads/dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop}
DiemainThread()Die Funktion wird verwendet, um das Gewindeobjekt des Hauptgewindes zu erhalten, d. h. das Gewinde, bei dem diemain()die Funktion in der Strategie liegt.
DiemainThread()Funktion gibt das Thread-Objekt des Hauptthreads zurück.
ThreadGegenstand
Hauptthread (()
function main() {
Log("The threadId of the main thread:", threading.mainThread().id())
}
Holen Sie dieThreadObjekt des Hauptgurtes und Ausgang derthreadIdvon der Hauptschnur.
function test() {
Log("Output the main thread ID in the test function:", threading.mainThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Das Gewindeobjekt des Hauptgewindes kann auch in gleichzeitigen Gewinden gewonnen werden.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/pending pending}, {@fun/threads/threading/eventLoop eventLoop}
DiecurrentThread()Funktion wird verwendet, um das Thread-Objekt des aktuellen Threads zu erhalten.
DiecurrentThread()Funktion gibt das Thread-Objekt des aktuellen Threads zurück.
ThreadGegenstand
Der aktuelle Thread (((
function test() {
Log("Id of the current thread:", threading.currentThread().id())
}
function main() {
var t1 = threading.Thread(test)
t1.join()
}
Holen Sie dieThreadGegenstand des Stromdrehs und Ausgang derthreadIdDer aktuelle Faden.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/Threading/Thread Thread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/condition condition}, {@fun/threads/threading/event event}, {@fun/threads/threading/event dictt}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/event Loop event Loop}, {@fun/threads/threading/event Loop}
DieLock()Die Funktion wird verwendet, um ein Thread-Lock-Objekt zu erstellen.
DieLock()Funktion gibt ein Threadlock-Objekt zurück.
ThreadLockGegenstand
Schließung
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@fun/Threads/threading/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/threading/threadThread}, {@fun/threads/threading/condition Condition}, {@fun/threads/threading/event Event}, {@fun/threads/threading/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop event}
DieCondition()Die Funktion wird verwendet, um ein Objekt der Bedingungsvariablen zu erstellen, das zur Synchronisierung und Kommunikation zwischen Threads in einer mehrthreadigen gleichzeitigen Umgebung verwendet wird.Condition(), kann ein Thread warten, wenn bestimmte Bedingungen nicht erfüllt sind, bis ein anderer Thread ihm mitteilt, dass die Bedingung erfüllt ist.
DieCondition()Funktion gibt a zurückThreadCondition object.
ThreadConditionGegenstand
Zustand
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Das Backtesting-System implementiert diese Funktionalität nicht, es definiert sie nur.
{@fun/Threads/getThread getThread}, {@fun/Threads/threading/mainThread mainThread}, {@fun/Threads/threading/currentThread currentThread}, {@fun/Threads/threading/Lock Lock}, {@fun/Threads/threading/threading/thread Thread}, {@fun/threads/threading/event Event}, {@fun/threads/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop Loop}
DieEvent()Funktion wird verwendet, um eineThread-EreignisObjekt, das für die Synchronisierung zwischen Threads verwendet wird, sodass ein Thread auf eine Benachrichtigung oder ein Signal von einem anderen Thread warten kann.
DieEvent()Funktion gibt a zurückThreadEvent object.
ThreadEventGegenstand
Ereignis
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()
}
Zwei gleichzeitige Threads greifen auf eine gemeinsame Ressource zu.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/threading/thread Thread}, {@fun/threads/threading/Dict Dict}, {@fun/threads/threading/pending pending}, {@fun/threads/threading/eventLoop eventop}
DieDict()Die Funktion wird verwendet, um ein Wörterbuchobjekt zu erstellen, das an gleichzeitige Threads übergeben wird.
DieDict()Funktion gibt a zurückThreadDict object.
ThreadDictGegenstand
Das ist ein Diktat.
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()
}
Übertragen eines normalen Objekts an die gleichzeitige Thread-Ausführungsfunktion, um zu testen, ob die Änderung des Schlüsselwerts des Objekts Änderungen des Schlüsselwerts des Objekts in anderen Threads bewirkt.
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()
}
Geben Sie mir dieThreadDictEin Objekt, das von derDict()Funktion an die gleichzeitige Thread-Ausführungsfunktion und prüfen, ob die Änderung des Schlüsselwerts des Objekts dazu führt, dass sich der Schlüsselwert des Objekts in anderen Threads ändert.
Wenn ein gemeinsames Objekt an eine gleichzeitige Thread-Funktion weitergegeben wird, wird es als Deep Copy weitergegeben.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/pending pending}, {@fun/threads/threading/eventLoop}
DiependingFunktion wird verwendet, um die Anzahl der gleichzeitigen Threads zu erhalten, die im aktuellen Strategieprogramm ausgeführt werden.
Diepending()Funktion gibt die Anzahl der gleichzeitigen Threads zurück, die das aktuelle Strategieprogramm ausführt.
Zahl
Ausstehend
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())
}
Erstellen Sie zwei gleichzeitig laufende Threads und rufen Sie diepending()Funktion in verschiedenen Zeitknoten.
Wenn die Strategiemain()Funktion beginnt zu laufen, ruft die Funktionpending()direkt 1 zurückgeben wird, weil der Haupt-Thread, wo die Strategiemain()Funktion ist auch ein ausstehender Thread.
Es unterstützt Backtesting-System und Live-Handelsumgebung.
{@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/Dict Dict}, {@fun/threads/threading/thread Thread}, {@fun/threads/threading/eventLoop}
Netzeinstellungen Faden