जावास्क्रिप्ट रणनीति डिजाइन में __थ्रेड फ़ंक्शन का अनुप्रयोग

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

यहां तक कि नए छात्र जो FMZ का उपयोग परिचयात्मक मात्रात्मक व्यापार के लिए करते हैं, वे FMZ के उपयोग को नहीं समझ सकते हैं।exchange.Go()उपयोग करनाexchange.Go()अभी भी अनुक्रमिक रूप से निष्पादित कोड में एक-एक करके कथन निष्पादित करता प्रतीत होता है। इस लेख में, हम एफएमजेड प्लेटफॉर्म में नए जोड़े गए समवर्ती धागे कार्यक्षमता के उपयोग का पता लगाएंगेः__Thread()और अन्य संबंधित कार्य, साथ ही रणनीतिक कार्यक्रमों के असिंक्रोनस डिजाइन।

1. सरल समवर्ती डिजाइन

यदि हम चाहते हैं कि रणनीति का मुख्य धागा हमारे द्वारा लिखे गए कस्टम फ़ंक्शन को निष्पादित करने वाले उप-थ्रेड के साथ समवर्ती रूप से चलाया जाए, तो हम निम्न कोड के समान डिज़ाइन का उपयोग कर सकते हैं। रणनीति कोड में, एक कस्टम फ़ंक्शन को परिभाषित करेंGetTickerAsync()और इस फ़ंक्शन की विशिष्ट कार्यक्षमता लिखें। यह फ़ंक्शन एक अनंत लूप निष्पादित करता है और लगातार FMZ एपीआई इंटरफ़ेस को कॉल करता हैGetTicker()बाजार के आंकड़े प्राप्त करने के लिए।

फिर, इस कथन का प्रयोग करें__threadSetData(0, "ticker", t)मुख्य धागे के लिए डेटा लिखने के लिए. डेटा नाम हैtickerऔर डेटा मान हैt, जो कि रिटर्न वैल्यू हैGetTicker().

__threadSetData(0, "ticker", t)

समवर्ती धागे निष्पादन के लिए कस्टम समारोह डिजाइन करने के बाद, हम कोड में लिख सकते हैंmain()कार्य की शुरुआत में।main()कार्य, हम उपयोग करते हैंः

__Thread(GetTickerAsync, 0)   // GetTickerAsync is a custom function that needs to be executed concurrently, and 0 is the parameter that is passed to the GetTickerAsync function.

एक समवर्ती थ्रेड बनाएँ जो निष्पादन शुरू करता हैGetTickerAsync()तब,main()फ़ंक्शन अपने स्वयं के निष्पादन शुरू होता हैwhileलूप, जिसमें यह अद्यतन डेटा प्राप्त करता हैGetTickerAsync()कार्य करता है और इसे मुद्रित करता हैः

var t = __threadGetData(0, "ticker")
Log(t)

पूर्ण कोड उदाहरणः

function GetTickerAsync(index) {
    while (true) {
        var t = exchanges[index].GetTicker()
        __threadSetData(0, "ticker", t)
        Sleep(500)
    }
}

function main() {
    __Thread(GetTickerAsync, 0)

    while(true) {
        var t = __threadGetData(0, "ticker")
        Log(t)
        Sleep(1000)
    }
}

लाइव ट्रेडिंग परीक्षणः

यह सबसे सरल अनुप्रयोग डिजाइनों में से एक है, तो चलो कुछ अन्य आवश्यकता डिजाइनों को देखते हैं।

2. समवर्ती ऑर्डर प्लेसमेंट डिजाइन

हम एक फ़ंक्शन डिजाइन कर सकते हैं एक साथ 10 थ्रेड बनाने के लिए, प्रत्येक आदेश प्लेसमेंट फ़ंक्शन निष्पादित।main()समारोह, हम एक डिजाइन कर सकते हैंwhileलूप रणनीति बातचीत आदेशों का पता लगाने के लिए. जब हम बातचीत आदेश प्राप्तplaceMultipleOrders, हम समवर्ती आदेश प्लेसमेंट फ़ंक्शन कहते हैंtestPlaceMultipleOrders().

if (cmd == "placeMultipleOrders") {
    // ...
}

रणनीति संपादन पृष्ठ पर रणनीति बातचीत डिजाइन जोड़ें आदेश के साथ एक बटन जोड़करः placeMultipleOrders.

पूर्ण कोड उदाहरणः

function placeOrder(exIndex, type, price, amount) {
    var id = null 
    if (type == "Buy") {
        id = exchanges[exIndex].Buy(price, amount)
    } else if (type == "Sell") {
        id = exchanges[exIndex].Sell(price, amount)
    } else {
        throw "type error! type:" + type
    }
}

function testPlaceMultipleOrders(index, beginPrice, endPrice, step, type, amount) {
    Log("beginPrice:", beginPrice, ", endPrice:", endPrice, ", step:", step, ", type:", type, ", amount:", amount)
    var tids = []
    for (var p = beginPrice; p <= endPrice; p += step) {
        var tid = __Thread(placeOrder, index, type, p, amount)
        tids.push(tid)
        Sleep(10)
    }
    Sleep(1000)
    for (var i = 0; i < tids.length; i++) {
        __threadTerminate(tids[i])
    }
}

function main() {
    while(true) {
        LogStatus(_D())
        var cmd = GetCommand()
        if (cmd) {
            if (cmd == "placeMultipleOrders") {
                var t = _C(exchange.GetTicker)
                var beginPrice = t.Last * 0.8
                var endPrice = t.Last * 0.9
                var step = t.Last * 0.01
                testPlaceMultipleOrders(0, beginPrice, endPrice, step, "Buy", 0.01)
                var orders = exchange.GetOrders()
                for (var i = 0; i < orders.length; i++) {
                    Log(orders[i])
                }
            }
        }
        Sleep(1000)
    }
}

• परीक्षण एक सिमुलेटेड ट्रेडिंग वातावरण में लंबित आदेशों को अपनाता है, जो वर्तमान मूल्य के 80% से 90% तक बढ़ता है। परीक्षण आदेश प्लेसमेंट को ट्रिगर करने के लिए इंटरैक्शन बटन पर क्लिक करें।

placeMultipleOrders बटन पर क्लिक करने के बाद, एक संदेश पूछा जाता हैः placeMultipleOrders कमांड सफलतापूर्वक भेजा गया था, कृपया लाइव ट्रेडिंग से प्रतिक्रिया की प्रतीक्षा करें!

• रणनीति लॉग समवर्ती ऑर्डर प्लेसमेंट ऑपरेशन प्रदर्शित करता हैः

3. एक समवर्ती धागे निष्पादन समारोह में एक वेबसोकेट कनेक्शन बनाएँ

यह आवश्यकता एक FMZ उपयोगकर्ता द्वारा उठाई गई थी जो एक सरल उदाहरण चाहता है जो दिखाता है कि एकवेबसॉकेटसमवर्ती धागे में कनेक्शन और कैसे डेटा को पारित करने के लिएmain()मुख्य धागे में कार्य करता है।

वास्तव में, यह काफी सरल है और पिछले उदाहरणों में समवर्ती धागे बनाने के समान है। एकमात्र अंतर यह है कि हम उपयोग करते हैं__threadPeekMessage()और__threadPostMessage()इंटर-थ्रेड संचार के लिए कार्य करता है. उदाहरण के रूप में बिनेंस एक्सचेंज के लिए वेबसॉकेट एपीआई कॉल लेते हुए, हमें वेबसॉकेट कनेक्शन के समापन ऑपरेशन को भी संभालने की आवश्यकता है. निम्नलिखित उदाहरण दिखाता है कि एक समवर्ती थ्रेड को रोकने के लिए कैसे सूचित किया जाए।

पूर्ण कोड उदाहरणः

var tid = null 

function createWS() {
    // wss://stream.binance.com:9443/ws/<streamName> , <symbol>@ticker
    
    var stream = "wss://stream.binance.com:9443/ws/btcusdt@ticker"    
    var ws = Dial(stream)
    Log("Create a WS connection:", stream)
    
    while (true) {
        var data = ws.read()
        if (data) {            
            __threadPostMessage(0, data)
        }
        Log("receiving data pushed by the WS link, data:", data)
        
        // __threadPeekMessage timeout parameter set to -1, no blocking
        var msg = __threadPeekMessage(-1)
        if (msg) {
            if (msg == "stop") {
                Log("Concurrent Thread Id:", __threadId(), "Received stop command")
                break
            }
        }
    }

    Log("Concurrent threads finish execution, close ws connection")
    ws.close()
}

function main() {
    tid = __Thread(createWS)
    Log("Create concurrent threads, thread Id:", tid)

    while(true) {
        // __threadPeekMessage's timeout parameter is set to 0, blocking for data
        var data = __threadPeekMessage(0)
        Log("Received from concurrent thread", ", Id:", tid, ", the data sent, data:", data, "#FF0000")
        
        var tbl = {
            type : "table", 
            title : "<symbol>@ticker channel push message",
            cols : ["Event Type", "Event Time", "Trading Pairs", "24 Hour Price Change", "24 Hour Price Change %", "Average Price", "Last Traded Price", "Volume in 24 Hours", "Turnover in 24 Hours"],
            rows : []
        }

        try {
            data = JSON.parse(data)
            tbl.rows.push([data.e, _D(data.E), data.s, data.p, data.P, data.w, data.c, data.v, data.q])
        } catch (e) {
            Log("e.name:", e.name, "e.stack:", e.stack, "e.message:", e.message)
        }
        LogStatus(_D(), "\n`" + JSON.stringify(tbl) + "`")
    }
}

function onexit() {
    Log("Finalize function, send a stop command to the concurrent thread with ID ", tid,"")
    __threadPostMessage(tid, "stop")
    Log("Wait for the concurrent thread with ID ", tid, " to stop")
    __threadJoin(tid)
    Log("Finalize function execution completed")
}

लाइव ट्रेडिंग परीक्षण के दौरान, हम देख सकते हैं किmain()फ़ंक्शन लगातार समवर्ती थ्रेडों द्वारा बनाए गए वेबसॉकेट कनेक्शन से बाजार डेटा प्राप्त करता है.

जब लाइव ट्रेडिंग रणनीति को रोक दिया जाता है, तो फाइनलाइज़ फ़ंक्शन काम करना शुरू कर देगा।