Mehrthreaded asynchrone Support-Funktionen können die Operationen aller unterstützten Funktionen in eine asynchrone gleichzeitige Ausführung umwandeln.
Dieexchange.Go()Funktion gibt ein gleichzeitiges Objekt sofort zurück, und Sie können diewait()Methode dieses gleichzeitigen Objekts, um das Ergebnis der gleichzeitigen Anfrage zu erhalten.
Gegenstand
Wechsel.Gehen (Methode) Auswechselung.Go (Methode,... args)
DiemethodParameter wird verwendet, um den Namen der gleichzeitigen Funktion anzugeben. Beachten Sie, dass der Parameter eine Funktionsnamenfolge ist, keine Funktionsreferenz.
Methode
- Das stimmt.
String
Parameter bisgleichzeitig Funktionen ausführen, kann es mehr als einen Parameter gebenarg. Typ und Anzahl des ParametersargDie Ergebnisse der Studiegleichzeitige Ausführung- Ich weiß.
Arg
falsche
String, number, bool, object, array, function, null und alle anderen vom System unterstützten Typen
function main(){
// The following four operations are concurrently executed asynchronously by multiple threads and do not take time and return immediately
var a = exchange.Go("GetTicker")
var b = exchange.Go("GetDepth")
var c = exchange.Go("Buy", 1000, 0.1)
var d = exchange.Go("GetRecords", PERIOD_H1)
// Call the wait method to wait for the return of the ticker results asynchronously
var ticker = a.wait()
// Returns the depth, or null if it fails
var depth = b.wait()
// return order number, limited to 1 second timeout, if timeout, returns undefined, the object can continue to call wait if the last wait timeout
var orderId = c.wait(1000)
if(typeof(orderId) == "undefined") {
// Timeout, reacquire
orderId = c.wait()
}
var records = d.wait()
}
def main():
a = exchange.Go("GetTicker")
b = exchange.Go("GetDepth")
c = exchange.Go("Buy", 1000, 0.1)
d = exchange.Go("GetRecords", PERIOD_H1)
ticker, ok = a.wait()
depth, ok = b.wait()
orderId, ok = c.wait(1000)
if ok == False:
orderId, ok = c.wait()
records, ok = d.wait()
void main() {
auto a = exchange.Go("GetTicker");
auto b = exchange.Go("GetDepth");
auto c = exchange.Go("Buy", 1000, 0.1);
auto d = exchange.Go("GetRecords", PERIOD_H1);
Ticker ticker;
Depth depth;
Records records;
TId orderId;
a.wait(ticker);
b.wait(depth);
if(!c.wait(orderId, 300)) {
c.wait(orderId);
}
d.wait(records);
}
Exchange.Go()Funktionsanwendungsbeispiel, um zu bestimmenundefinedzu verwendentypeof(xx) === "undefined", weilnull == undefinedist in JavaScript gültig.
function main() {
var d = exchange.Go("GetRecords", PERIOD_H1)
// Waiting for K-line results
var records = d.wait()
// Here waits an asynchronous operation that has been waited and finished, it will return null, and log the error message
var ret = d.wait()
}
def main():
d = exchange.Go("GetRecords", PERIOD_H1)
records, ok = d.wait()
ret, ok = d.wait()
void main() {
auto d = exchange.Go("GetRecords", PERIOD_H1);
Records records;
d.wait(records);
Records ret;
d.wait(ret);
}
Ich rufe diewait()Methode auf einem gleichzeitigen Objekt, das freigegeben wurde, wird einen Fehler melden:
function main() {
while(true) {
var beginTS = new Date().getTime()
var arrRoutine = []
var arrTicker = []
var arrName = []
for(var i = 0; i < exchanges.length; i++) {
arrRoutine.push(exchanges[i].Go("GetTicker"))
arrName.push(exchanges[i].GetName())
}
for(var i = 0; i < arrRoutine.length; i++) {
arrTicker.push(arrRoutine[i].wait())
}
var endTS = new Date().getTime()
var tbl = {
type: "table",
title: "ticker",
cols: ["index", "name", "latest-deal-price"],
rows: []
}
for(var i = 0; i < arrTicker.length; i++) {
tbl.rows.push([i, arrName[i], arrTicker[i].Last])
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "millisecond", "\n", "`" + JSON.stringify(tbl) + "`")
Sleep(500)
}
}
import time
import json
def main():
while True:
beginTS = time.time()
arrRoutine = []
arrTicker = []
arrName = []
for i in range(len(exchanges)):
arrRoutine.append(exchanges[i].Go("GetTicker"))
arrName.append(exchanges[i].GetName())
for i in range(len(exchanges)):
ticker, ok = arrRoutine[i].wait()
arrTicker.append(ticker)
endTS = time.time()
tbl = {
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
}
for i in range(len(arrTicker)):
tbl["rows"].append([i, arrName[i], arrTicker[i]["Last"]])
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", endTS - beginTS, "second", "\n", "`" + json.dumps(tbl) + "`")
Sleep(500)
void main() {
while(true) {
int length = exchanges.size();
auto beginTS = UnixNano() / 1000000;
Ticker arrTicker[length] = {};
string arrName[length] = {};
// Note that to add several exchange objects, several exchanges[n].Go functions have to be executed here, this example is to add four exchange objects, the details can be modified
auto r0 = exchanges[0].Go("GetTicker");
auto r1 = exchanges[1].Go("GetTicker");
auto r2 = exchanges[2].Go("GetTicker");
auto r3 = exchanges[3].Go("GetTicker");
GoObj *arrRoutine[length] = {&r0, &r1, &r2, &r3};
for(int i = 0; i < length; i++) {
arrName[i] = exchanges[i].GetName();
}
for(int i = 0; i < length; i++) {
Ticker ticker;
arrRoutine[i]->wait(ticker);
arrTicker[i] = ticker;
}
auto endTS = UnixNano() / 1000000;
json tbl = R"({
"type": "table",
"title": "ticker",
"cols": ["index", "name", "latest-deal-price"],
"rows": []
})"_json;
for(int i = 0; i < length; i++) {
json arr = R"(["", "", ""])"_json;
arr[0] = format("%d", i);
arr[1] = arrName[i];
arr[2] = format("%f", arrTicker[i].Last);
tbl["rows"].push_back(arr);
}
LogStatus(_D(), "Total time taken to obtain tickers from multiple exchanges concurrently:", format("%d", endTS - beginTS), "millisecond", "\n", "`" + tbl.dump() + "`");
Sleep(500);
}
}
Gleichzeitiger Zugriff auf mehrere Exchange-Tickers:
function main() {
/*
Testing with OKX futures order interface
POST /api/v5/trade/order
*/
var beginTS = new Date().getTime()
var param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
var ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", JSON.stringify(param))
var id1 = ret1.wait()
var id2 = ret2.wait()
var id3 = ret3.wait()
var endTS = new Date().getTime()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond")
}
import time
import json
def main():
beginTS = time.time()
param = {"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"}
ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", json.dumps(param))
id1, ok1 = ret1.wait()
id2, ok2 = ret2.wait()
id3, ok3 = ret3.wait()
endTS = time.time()
Log("id1:", id1)
Log("id2:", id2)
Log("id3:", id3)
Log("Concurrent order placement time consumption:", endTS - beginTS, "second")
void main() {
auto beginTS = UnixNano() / 1000000;
json param = R"({"instId":"BTC-USDT-SWAP","tdMode":"cross","side":"buy","ordType":"limit","px":"16000","sz":"1","posSide":"long"})"_json;
auto ret1 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret2 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
auto ret3 = exchange.Go("IO", "api", "POST", "/api/v5/trade/order", "", param.dump());
json id1 = R"({})"_json;
json id2 = R"({})"_json;
json id3 = R"({})"_json;
ret1.wait(id1);
ret2.wait(id2);
ret3.wait(id3);
auto endTS = UnixNano() / 1000000;
Log("id1:", id1);
Log("id2:", id2);
Log("id3:", id3);
Log("Concurrent order placement time consumption:", endTS - beginTS, "millisecond");
}
Gleichzeitige Aufrufeexchange.IO("api", ...)Funktion:
Diese Funktion erstellt nur mehrthreaded Ausführungsaufgaben, wenn sie im realen Handel ausgeführt wird, Backtesting unterstützt nicht mehrthreaded gleichzeitige Ausführung von Aufgaben (Backtesting ist verfügbar, aber immer noch sequenziell ausgeführt).
Nach derexchange.Go()Funktion gibt ein Objekt zurück, seinwait()Funktion wird durch dieses Objekt aufgerufen, um die Daten des Threads zurückzugeben.wait()Die Funktion muss aufgerufen werden, um die Daten zu erhalten, bevor der Thread automatisch freigegeben wird.wait()Wenn die Funktion nicht angegeben ist, wird der Thread nicht automatisch freigegeben, selbst wenn ein Timeout eintritt. Das Ergebnis des Threads muss erhalten werden, bevor er automatisch freigegeben wird (unabhängig vom Erfolg oder Scheitern des Schnittstellenanrufs für gleichzeitigen Zugriff).wait()Funktion, unabhängig davon, ob die Ausführung erfolgreich oder fehlschlägt, und die Ressource des vom Thread angefordertenexchange.Go()Funktion muss automatisch vom Docker freigegeben werden.
Diewait()Methode unterstützt einen Timeout-Parameter:
Ohne einen Timeout-Parameter, alsowait(), oder mit einem Timeout-Parameter von 0, d. h.wait(0). Diewait()Funktionsblöcke und wartet, bis der gleichzeitige Thread ausgeführt ist, und gibt das Ergebnis der gleichzeitigen Threadwait(-1). Diewait()Funktion gibt sofort mit unterschiedlichen Rückgabewerten für verschiedene Programmiersprachen zurück, siehe diesen Unterabschnitt für einen Beispielruf.
Setzen Sie den spezifischen Timeout-Parameter,wait(300), und diewait()Die Funktion wird maximal 300 Millisekunden warten, bevor sie zurückkehrt.
Wenn das Ergebnis der letztenwait()Funktion nicht erreicht wird, werden die Thread-Ressourcen nicht automatisch freigegeben, was zur Anhäufung der angeforderten Threads führt, und mehr als 2000 werden einen Fehler melden:"too many routine wait, max is 2000"- Ich weiß.
Unterstützte Funktionen:GetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. Alle diese Funktionen werden basierend auf dem aktuellen Exchange-Objekt {@var/EXCHANGE exchange} ausgeführt, wenn sie gleichzeitig aufgerufen werden.
Der Unterschied zwischen Python und JavaScript besteht darin, dasswait()Die Funktion der gleichzeitigen Objekte in der Python-Sprache gibt zwei Parameter zurück. Der erste Parameter ist das Ergebnis eines asynchronen API-Aufrufs und der zweite Parameter gibt an, ob der asynchrone Aufruf abgeschlossen ist.
def main():
d = exchange.Go("GetRecords", PERIOD_D1)
# ok will return True definitely, unless the strategy is stopped
ret, ok = d.wait()
# If the wait times out, or if it waits for an instance that has already ended, ok returns False
ret, ok = d.wait(100)
Wir haben eine Reihe von Programmen entwickelt.
exchange.Encode Abrechnung