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

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

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

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

यदि हम रणनीति मुख्य थ्रेड के चलने के दौरान हमारे द्वारा लिखे गए कस्टम फ़ंक्शन को निष्पादित करने के लिए चाइल्ड थ्रेड को समवर्ती रूप से चलाना चाहते हैं, तो हम निम्नलिखित कोड के समान डिज़ाइन का उपयोग कर सकते हैं। रणनीति कोड में फ़ंक्शन को अनुकूलित करेंGetTickerAsync(), इस फ़ंक्शन की विशिष्ट कार्यक्षमता लिखें. यह फ़ंक्शन एक अनंत लूप निष्पादित करता है।whileFMZ API इंटरफ़ेस को लगातार लूप में बुलाया जाता है:GetTicker()बाजार डेटा प्राप्त करने के लिए.

फिर उपयोग करें__threadSetData(0, "ticker", t)यह वाक्य मुख्य थ्रेड में डेटा लिखता है। डेटा का नाम हैticker, डेटा मान हैtअभीGetTicker()का वापसी मान.

__threadSetData(0, "ticker", t)

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

__Thread(GetTickerAsync, 0)   // GetTickerAsync为需要并发执行的自定义函数，0为这个传入GetTickerAsync函数的参数

एक समवर्ती थ्रेड बनाएं, जो निष्पादन शुरू करता है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” बटन पर क्लिक करने के बाद, संदेश प्रदर्शित होता है:

• रणनीति लॉग समवर्ती आदेश संचालन दिखाता है:

3. समवर्ती थ्रेड निष्पादन फ़ंक्शन में एक WebSocket कनेक्शन बनाएँ

यह आवश्यकता एक FMZ उपयोगकर्ता द्वारा उठाई गई थी, जो यह प्रदर्शित करने के लिए एक सरल उदाहरण चाहता था कि समवर्ती थ्रेड्स में इसका उपयोग कैसे किया जाए।WebSocketमुख्य थ्रेड में डेटा पास करने का तरीका कनेक्ट करें और डिज़ाइन करें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("创建WS连接:", stream)
    
    while (true) {
        var data = ws.read()
        if (data) {            
            __threadPostMessage(0, data)
        }
        Log("接收到WS链接推送的数据，data:", data)
        
        // __threadPeekMessage 超时参数设置-1，不阻塞
        var msg = __threadPeekMessage(-1)
        if (msg) {
            if (msg == "stop") {
                Log("并发线程Id:", __threadId(), "接收到stop指令")
                break
            }
        }
    }

    Log("并发线程执行完毕，关闭ws连接")
    ws.close()
}

function main() {
    tid = __Thread(createWS)
    Log("创建并发线程，线程Id:", tid)

    while(true) {
        // __threadPeekMessage 的超时参数设置为0，阻塞等待数据
        var data = __threadPeekMessage(0)
        Log("接收到并发线程", ", Id:", tid, ", 发送的数据，data:", data, "#FF0000")
        
        var tbl = {
            type : "table", 
            title : "<symbol>@ticker频道推送消息",
            cols : ["事件类型", "事件时间", "交易对", "24小时价格变化", "24小时价格变化百分比", "平均价格", "最新成交价格", "24小时内成交量", "24小时内成交额"],
            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("扫尾函数，向Id为", tid, "的并发线程发送stop指令")
    __threadPostMessage(tid, "stop")
    Log("等待Id为", tid, "的并发线程停止")
    __threadJoin(tid)
    Log("扫尾函数执行完毕")
}

वास्तविक डिस्क संचालन परीक्षण:

आप देख सकते हैंmain()यह फ़ंक्शन समवर्ती थ्रेड द्वारा बनाए गए वेबसॉकेट कनेक्शन से लगातार बाज़ार डेटा प्राप्त करता है।

जब रणनीति रोक दी जाती है, तो स्वीप फ़ंक्शन काम करना शुरू कर देगा: