exchange.Go

मल्टी-थ्रेडेड असिंक्रोनस सपोर्ट फंक्शन सभी सपोर्ट किए गए फंक्शन के ऑपरेशन को असिंक्रोनस समवर्ती निष्पादन में बदल सकते हैं।

..exchange.Go()फ़ंक्शन तुरंत एक समवर्ती वस्तु देता है, और आप उपयोग कर सकते हैंwait()समवर्ती अनुरोध का परिणाम प्राप्त करने के लिए उस समवर्ती वस्तु की विधि. वस्तु

विनिमय.जाओ ((प्रक्रिया) आदान-प्रदान.जाओ ((प्रक्रिया,... args)

..methodपैरामीटर का उपयोग समवर्ती फ़ंक्शन का नाम निर्दिष्ट करने के लिए किया जाता है. ध्यान दें कि पैरामीटर फ़ंक्शन नाम स्ट्रिंग है, फ़ंक्शन संदर्भ नहीं। विधि सच स्ट्रिंग पैरामीटरसमवर्ती रूप से कार्य निष्पादित करना, एक से अधिक पैरामीटर हो सकते हैंarg. पैरामीटर का प्रकार और संख्याargपर निर्भर करता हैसमवर्ती निष्पादन कार्य. आर्ग झूठी string, number, bool, object, array, function, null, और अन्य सभी प्रकार सिस्टम द्वारा समर्थित

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()फ़ंक्शन उपयोग उदाहरण, निर्धारित करने के लिएundefinedप्रयोग करने के लिएtypeof(xx) === "undefined", क्योंकिnull == undefinedजावास्क्रिप्ट में मान्य है.

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);
}

बुला रहा हैwait()एक समवर्ती ऑब्जेक्ट पर विधि जो जारी किया गया है एक त्रुटि रिपोर्ट करेगाः

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);
    }
}

एकाधिक विनिमय टिकरों तक एक साथ पहुँचः

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");
}

समवर्ती आमंत्रणexchange.IO("api", ...)कार्य:

यह फ़ंक्शन केवल वास्तविक ट्रेडिंग में चलने पर बहु-थ्रेडेड निष्पादन कार्य बनाता है, बैकटेस्टिंग बहु-थ्रेडेड समवर्ती कार्य निष्पादन का समर्थन नहीं करता है (बैकटेस्टिंग उपलब्ध है, लेकिन फिर भी क्रमिक रूप से निष्पादित किया जाता है) । के बादexchange.Go()फ़ंक्शन एक ऑब्जेक्ट देता है, इसकेwait()फ़ंक्शन उस ऑब्जेक्ट के माध्यम से कहा जाता है धागे द्वारा लौटाए गए डेटा प्राप्त करने के लिए.wait()कार्य स्वचालित रूप से जारी किया जाएगा इससे पहले कि धागा डेटा प्राप्त करने के लिए बुलाया जाना चाहिए.wait()function निर्दिष्ट है, तो थ्रेड स्वचालित रूप से रिलीज़ नहीं होगा, भले ही टाइमआउट हो। थ्रेड का परिणाम स्वचालित रूप से रिलीज़ होने से पहले प्राप्त किया जाना चाहिए (समानकालिक पहुंच के लिए इंटरफ़ेस कॉल की सफलता या विफलता के बावजूद) । सरल शब्दों में, अनुरोधित थ्रेड को प्राप्त किया जाना चाहिएwait()कार्य चाहे निष्पादन सफल हो या असफल, और धागे के संसाधन द्वारा अनुरोध किया द्वाराexchange.Go()कार्य को डॉकर द्वारा स्वचालित रूप से जारी किया जाना चाहिए। दwait()विधि एक टाइमआउट पैरामीटर का समर्थन करती हैः एक समय सीमा पैरामीटर के बिना, कि है,wait(), या एक समय सीमा पैरामीटर 0 के साथ, यानी,wait(0).wait()फ़ंक्शन ब्लॉक करता है और तब तक प्रतीक्षा करता है जब तक समवर्ती थ्रेड समाप्त नहीं हो जाता है, समवर्ती थ्रेड के निष्पादन का परिणाम लौटाता है। समय सीमा पैरामीटर सेट -1, यानीwait(-1).wait()फ़ंक्शन तुरंत रिटर्न करता है, विभिन्न प्रोग्रामिंग भाषाओं के लिए अलग-अलग रिटर्न मानों के साथ, एक उदाहरण कॉल के लिए इस उपखंड को देखें। विशिष्ट टाइमआउट पैरामीटर सेट करें,wait(300), औरwait()कार्य वापस जाने से पहले अधिकतम 300 मिलीसेकंड का इंतजार करेगा।

यदि अंतिम परिणाम लौटायाwait()कार्य प्राप्त नहीं होता है, धागा संसाधन स्वचालित रूप से जारी नहीं किया जाएगा, जो अनुरोधित धागे के संचय का कारण होगा और 2000 से अधिक एक त्रुटि की रिपोर्ट करेगाः"too many routine wait, max is 2000". समर्थित कार्यःGetTicker, GetDepth, GetTrades, GetRecords, GetAccount, GetOrders, GetOrder, CancelOrder, Buy, Sell, GetPositions, IO. इन सभी कार्यों को वर्तमान {@var/EXCHANGE exchange} विनिमय वस्तु के आधार पर निष्पादित किया जाता है जब समवर्ती रूप से बुलाया जाता है. पायथन भाषा और जावास्क्रिप्ट भाषा के बीच अंतर यह है किwait()पायथन भाषा में समवर्ती ऑब्जेक्ट्स का फ़ंक्शन दो पैरामीटर लौटाता है। पहला पैरामीटर एक असिंक्रोनस एपीआई कॉल द्वारा लौटाया गया परिणाम है, और दूसरा पैरामीटर इंगित करता है कि क्या असिंक्रोनस कॉल पूरा हो गया है।

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)  

{@fun/Global/Mail_Go Mail_Go}, {@fun/Global/HttpQuery_Go HttpQuery_Go}, {@fun/Global/EventLoop EventLoop}

exchange.Encode खाता