Menggunakan JavaScript untuk melaksanakan dasar kuantiti secara serentak untuk menjalankan fungsi Go yang dibungkus dengan keran

Dalam banyak kes, pelaksanaan serentak boleh mengurangkan kelewatan untuk meningkatkan kecekapan dalam melaksanakan strategi kuantitatif. Sebagai contoh, robot lindung nilai memerlukan kedalaman dua sen, kod yang dilaksanakan mengikut urutan adalah sebagai berikut:

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

Permintaan sekali rest API mempunyai kelewatan, andaikan 100ms, maka masa untuk mendapatkan kedalaman dua kali sebenarnya tidak sama, jika memerlukan lebih banyak lawatan, masalah kelewatan akan menjadi lebih menonjol dan mempengaruhi pelaksanaan dasar.

Javascript tidak mempunyai banyak utas, jadi fungsi Go yang terbungkus di bawah menyelesaikan masalah ini, tetapi ia agak rumit untuk dilaksanakan kerana mekanisme reka bentuk.

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

Dalam kebanyakan kes yang mudah, menulis dasar seperti ini tidak masalah. Tetapi perhatikan bahawa setiap putaran dasar mengulangi proses ini, dan pembolehubah tengah a, b sebenarnya hanya bantuan sementara. Jika kita mempunyai banyak tugas serentak, kita juga perlu merakam hubungan antara a dan kedalaman A, b dan kedalaman B, dan keadaan lebih rumit apabila tugas serentak kita tidak pasti. Oleh itu, kita ingin melaksanakan fungsi: apabila menulis Go serentak, mengikat satu pembolehubah pada masa yang sama, dan apabila hasil pelaksanaan serentak dikembalikan, hasilnya akan memberi nilai kepada pembolehubah secara automatik, dengan itu menghilangkan pembolehubah tengah, untuk menjadikan program lebih ringkas. Secara khusus, dilaksanakan seperti:

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

Kami mentakrifkan fungsi G, di mana parameter t adalah fungsi Go yang akan dijalankan, ctx adalah konteks dalam program yang dicatatkan, dan f adalah fungsi yang diberikan nilai tertentu.

Dalam kes ini, kerangka kerja program secara keseluruhan boleh ditulis sebagai serupa dengan model kerangka pengeluar-pengguna kerangka kerja (dengan beberapa perbezaan), di mana pengeluar terus mengeluarkan tugas, pengguna melaksanakan mereka secara serentak, dan kod hanya untuk demonstrasi, tidak melibatkan logika pelaksanaan program.

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

Ia kelihatan seperti pusingan yang hanya mencapai satu fungsi yang mudah, sebenarnya sangat memudahkan kerumitan kod, kita hanya perlu mengambil berat tentang apa tugas yang perlu dihasilkan oleh program, yang secara automatik dijalankan secara serentak oleh program worker dan mengembalikan hasil yang sesuai. Kelembapan meningkat banyak.