Implementar políticas de cuantificación con JavaScript para ejecutar simultáneamente la función Go de envase de galón

En la implementación de estrategias de cuantificación, en muchos casos, la ejecución simultánea puede reducir la eficiencia de la mejora de la demora. En el caso de los robots de cobertura, por ejemplo, se requiere obtener la profundidad de dos monedas, y el código ejecutado en orden es el siguiente:

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

Una vez que se solicita una API rest, hay un retraso, suponiendo que sea de 100 ms, entonces el tiempo de obtención de profundidad en dos ocasiones es realmente diferente, y si se requieren más visitas, el problema de retraso será más prominente y afectará la ejecución de la política.

JavaScript no tiene muchos hilos, por lo que la función Go envuelta en la parte inferior resuelve este problema, pero es más complicado de implementar debido al mecanismo de diseño.

var a = exchanges[0].Go("GetDepth")
var b = exchanges[1].Go("GetDepth")
var depthA = a.wait() //调用wait方法等待返回异步获取depth结果 
var depthB = b.wait()

En la mayoría de los casos sencillos, escribir una política así no es un problema. Sin embargo, tenga en cuenta que cada ciclo de política debe repetir este proceso, y las variables intermedias a, b son en realidad solo auxiliares temporales. Si tenemos muchas tareas simultáneas, también se debe registrar la relación de correspondencia entre a y depthA, b y depthB, lo que hace que la situación sea más compleja cuando nuestras tareas simultáneas no están determinadas. Por lo tanto, queremos implementar una función: cuando se escribe Go simultáneamente, se une una variable al mismo tiempo, y cuando se devuelve el resultado de la ejecución simultánea, el resultado se asigna automáticamente a la variable, lo que elimina las variables intermedias y hace que el programa sea más sencillo.

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

Definimos una función G, donde el parámetro t es la función Go a ejecutar, ctx es el contexto del programa de registro, y f es la función con la asignación específica.

En este caso, el marco de programación general puede escribirse de manera similar al modelo de programación productor-consumidor (con algunas diferencias), donde el productor emite continuamente tareas y el consumidor las ejecuta simultáneamente, mientras que el código es solo una demostración y no involucra la lógica de ejecución del programa.

var Info = [{depth:null, account:null}, {depth:null, account:null}] //加入我们需要获取两个交易所的深度和账户，跟多的信息也可以放入，如订单Id，状态等。
var tasks = [ ] //全局的任务列表

function produce(){ //下发各种并发任务
  //这里省略了任务产生的逻辑，仅为演示
  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) //删掉已执行的任务
        jobs.push(G(exchanges[task.exchange].Go.apply(this, task.param), task, function(v, task) {
                    Info[task.exchange][task.ret] = v //这里的v就是并发Go函数wait()的返回值，可以仔细体会下
                }))
    }
    _.each(jobs, function(t){
            t.run() //在这里并发执行所有任务
        })
}
function main() {
    while(true){
        produce()         // 发出交易指令
        worker()        // 并发执行
        Sleep(1000)
    }
}

Lo que parece ser una vuelta de tuerca es la realización de una función simple, que en realidad simplifica mucho la complejidad del código, ya que solo tenemos que preocuparnos por qué tareas necesita producir el programa, y el programa worker () los ejecuta automáticamente en paralelo y devuelve los resultados correspondientes.