Use JavaScript para implementar a execução simultânea da estratégia quantitativa - encapsular a função Go

Use JavaScript para implementar a execução simultânea da estratégia quantitativa - encapsular a função Go

Ao implementar a estratégia quantitativa, a execução simultânea pode reduzir a latência e melhorar a eficiência em muitos casos.

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

Há um atraso na solicitação de uma API de repouso. Supondo que seja de 100 ms, o tempo para obter a profundidade é realmente diferente. Se for necessário mais acesso, o problema do atraso se tornará mais proeminente e afetará a implementação da estratégia.

O JavaScript não possui multithreading, então a função Go é encapsulada na parte inferior para resolver este problema.

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()

Em casos mais simples, não há nada de errado em escrever a estratégia dessa maneira. No entanto, note-se que este processo deve ser repetido para cada loop de estratégia. As variáveis intermediárias a e b são apenas auxiliares temporários. Se tivermos muitas tarefas simultâneas, precisamos registrar a relação correspondente entre a e profundidadeA e b e profundidadeB. Quando nossas tarefas simultâneas são incertas, a situação se torna mais complexa. Portanto, queremos implementar uma função: ao escrever Go simultaneamente, vincule uma variável ao mesmo tempo, e quando o resultado da operação simultânea retornar, o resultado será automaticamente atribuído à variável, eliminando a variável intermediária e, assim, tornando o programa mais conciso. A implementação específica é a seguinte:

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

Definimos uma função G, onde o parâmetro t é a função Go a ser executada, ctx é o contexto do programa de gravação e f é a função de atribuição específica.

Neste momento, a estrutura geral do programa pode ser escrita como semelhante ao modelo produtor-consumidor (com algumas diferenças). O produtor continua enviando tarefas e o consumidor as executa simultaneamente.

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

Parece que apenas uma função simples foi implementada depois de circular em círculos. Na verdade, a complexidade do código foi simplificada muito. Só precisamos nos preocupar com as tarefas que o programa precisa gerar. O programa worker() as executará automaticamente simultaneamente e retornará os resultados correspondentes. A flexibilidade melhorou muito.