Verwenden Sie JavaScript, um die gleichzeitige Ausführung der quantitativen Strategie umzusetzen - die Go-Funktion einkapseln

Verwenden Sie JavaScript, um die gleichzeitige Ausführung der quantitativen Strategie umzusetzen - die Go-Funktion einkapseln

Bei der Umsetzung der quantitativen Strategie kann die gleichzeitige Ausführung die Latenzzeit reduzieren und die Effizienz in vielen Fällen verbessern.

var depthA = exchanges[0].GetDepth()
var depthB = exchanges[1].GetDepth()

Es gibt eine Verzögerung bei der Anforderung einer Rest-API. Angenommen, es ist 100ms, ist die Zeit für die Gewinnung der Tiefe tatsächlich anders. Wenn mehr Zugriff erforderlich ist, wird das Verzögerungsproblem prominent und wirkt sich auf die Umsetzung der Strategie aus.

JavaScript verfügt nicht über Multithreading, so dass die Go-Funktion unten eingekapselt ist, um dieses Problem zu lösen.

var a = exchanges[0].Go("GetDepth")
var b = exchanges[1].Go("GetDepth")
var depthA = a.wait() // Call the wait method to wait for the return of the depth result asynchronously 
var depthB = b.wait()

In den meisten einfachen Fällen ist es nichts falsch daran, die Strategie so zu schreiben. Allerdings ist zu beachten, dass dieser Prozess für jede Strategie-Schleife wiederholt werden sollte. Die Zwischenvariablen a und b sind nur temporäre Hilfsmittel. Wenn wir viele gleichzeitige Aufgaben haben, müssen wir die entsprechende Beziehung zwischen a und depthA und b und depthB aufzeichnen. Wenn unsere gleichzeitigen Aufgaben unsicher sind, wird die Situation komplexer. Daher wollen wir eine Funktion implementieren: Wenn wir Go gleichzeitig schreiben, binden wir eine Variable gleichzeitig, und wenn das Ergebnis der gleichzeitigen Operation zurückkehrt, wird das Ergebnis automatisch der Variable zugeordnet, wodurch die Zwischenvariable eliminiert wird und das Programm somit präziser wird. Die konkrete Implementierung ist wie folgt:

function G(t, ctx, f) {
    return {run:function(){
        f(t.wait(1000), ctx)
    }}
}

Wir definieren eine G-Funktion, wo der Parameter t die auszuführende Go-Funktion ist, ctx der Kontext des Aufzeichnungsprogramms und f die spezifische Zuweisungsfunktion.

Der Gesamtprogrammrahmen kann zu diesem Zeitpunkt dem Produzent-Verbraucher-Modell ähnlich geschrieben werden (mit einigen Unterschieden). Der Produzent sendet Aufgaben aus und der Verbraucher führt sie gleichzeitig aus.

var Info = [{depth:null, account:null}, {depth:null, account:null}] // If we need to obtain the depth and account of the two exchanges, more information can also be put in, such as order ID, status, etc.
var tasks = [ ] // Global list of tasks

function produce(){ // Issue various concurrent tasks
  // The logic of task generation is omitted here, for demonstration purposes only.
  tasks.push({exchange:0, ret:'depth', param:['GetDepth']})
  tasks.push({exchange:1, ret:'depth', param:['GetDepth']})
  tasks.push({exchange:0, ret:'sellID', param:['Buy', Info[0].depth.Asks[0].Price, 10]})
  tasks.push({exchange:1, ret:'buyID', param:['Sell', Info[1].depth.Bids[0].Price, 10]})
}
function worker(){
    var jobs = []
    for(var i=0;i<tasks.length;i++){
        var task = tasks[i]
        tasks.splice(i,1) // Delete executed tasks
        jobs.push(G(exchanges[task.exchange].Go.apply(this, task.param), task, function(v, task) {
                    Info[task.exchange][task.ret] = v // The v here is the return value of the concurrent Go function wait(), which can be experienced carefully.
                }))
    }
    _.each(jobs, function(t){
            t.run() // Execute all tasks concurrently here
        })
}
function main() {
    while(true){
        produce()         // Send trade orders
        worker()        // Concurrent execution
        Sleep(1000)
    }
}

Es scheint, dass nur eine einfache Funktion implementiert wurde, nachdem man in Kreisen herumgegangen ist. Tatsächlich wurde die Komplexität des Codes stark vereinfacht. Wir müssen uns nur darum kümmern, welche Aufgaben das Programm erzeugen muss. Das Worker() Programm wird sie automatisch gleichzeitig ausführen und die entsprechenden Ergebnisse zurückgeben. Die Flexibilität hat sich stark verbessert.