Saat menerapkan strategi kuantitatif, dalam banyak kasus, eksekusi bersamaan dapat mengurangi latensi dan meningkatkan efisiensi. Mengambil robot lindung nilai sebagai contoh, perlu untuk memperoleh kedalaman dua koin. Kode yang dieksekusi secara berurutan adalah sebagai berikut:

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

Ada penundaan dalam meminta API rest. Asumsikan 100 ms. Maka waktu untuk mendapatkan kedalaman dua kali sebenarnya berbeda. Jika diperlukan akses lebih banyak, masalah penundaan akan lebih menonjol, yang memengaruhi pelaksanaan strategi.

Karena JavaScript tidak memiliki multi-threading, fungsi Go yang mendasarinya dienkapsulasi untuk menyelesaikan masalah ini, tetapi karena mekanisme desainnya, implementasinya agak rumit.

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

Dalam kebanyakan kasus sederhana, tidak ada yang salah dengan penulisan kebijakan dengan cara ini. Namun perlu dicatat bahwa proses ini harus diulang setiap kali strategi berulang, dan variabel antara a dan b sebenarnya hanya bantuan sementara. Jika kita memiliki banyak tugas yang dilakukan secara bersamaan, kita perlu mencatat korespondensi antara a dan depthA, serta b dan depthB. Ketika tugas-tugas yang dilakukan secara bersamaan tidak pasti, situasinya menjadi lebih rumit. Oleh karena itu, kami ingin menerapkan fungsi: saat menulis Go concurrency, mengikat variabel pada saat yang sama, dan ketika hasil berjalan bersamaan dikembalikan, hasilnya secara otomatis ditetapkan ke variabel, sehingga menghilangkan variabel perantara dan membuat program lebih ringkas. Implementasi spesifiknya adalah sebagai berikut:

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

Kami mendefinisikan fungsi G, di mana parameter t adalah fungsi Go yang akan dieksekusi, ctx adalah konteks program, dan f adalah fungsi untuk penugasan tertentu. Kita akan segera melihat fungsi ini beraksi.

Pada titik ini, keseluruhan kerangka program dapat ditulis sebagai model “produsen-konsumen” (dengan beberapa perbedaan), di mana produsen terus-menerus mengeluarkan tugas dan konsumen menjalankannya secara bersamaan. Kode berikut hanya untuk demonstrasi dan tidak melibatkan program. Menjalankan logika.

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

Tampaknya kita baru saja mengimplementasikan fungsi sederhana setelah melalui banyak langkah, tetapi sebenarnya, kompleksitas kode telah sangat disederhanakan. Kita hanya perlu memperhatikan tugas apa yang perlu dihasilkan oleh program, dan pekerja( ) program akan secara otomatis mengeksekusinya secara bersamaan dan mengembalikan hasil yang sesuai. Fleksibilitas telah ditingkatkan pesat.