Penjelasan terperinci pustaka gentian (fiber) dalam nodejs_node.js

serat/serat

Dalam sistem operasi, selain proses dan benang, terdapat juga jenis serat (fiber, juga dipanggil coroutine) yang jarang digunakan. Gentian sering dibandingkan dengan benang Untuk sistem pengendalian, kedua-duanya adalah keadaan berjalan ringan. Gentian biasanya dianggap lebih ringan dan mempunyai overhed kurang daripada benang. Perbezaannya ialah gentian dicipta oleh benang atau gentian, dan penjadualan gentian dikawal sepenuhnya oleh kod sistem, ia adalah kaedah penjadualan tanpa preemptif. Benang dan proses berjadual kernel dan melaksanakan multitasking preemptive mengikut keutamaan. Di samping itu, kernel sistem tidak mengetahui status larian gentian tertentu, dan penggunaan gentian sebenarnya agak bebas daripada sistem pengendalian.

Dalam nod, utas tunggal hanya untuk javascript, dan lapisan bawahnya sebenarnya penuh dengan berbilang benang. Jika anda perlu melaksanakan multi-threading dalam JavaScript, pendekatan biasa ialah menulis addon C untuk memintas mekanisme single-threading JavaScript. Walau bagaimanapun, kaedah ini meningkatkan kesukaran dan kos pembangunan dan penyahpepijatan. Seperti kebanyakan bahasa skrip lain, kami juga boleh memperkenalkan konsep gentian ke dalam nod.

gentian nod

Pustaka gentian nod menyediakan fungsi gentian untuk nod. Ujian berbilang benang tidak menghasilkan keputusan yang ideal, tetapi ia mempunyai kesan yang ketara dalam menukar tak segerak kepada segerak, dan mungkin juga bernilai dalam mengurangkan susunan panggilan nod dan rekursi tak terhingga. Dokumen ini terutamanya memperkenalkan cara menggunakan perpustakaan gentian nod dan penukaran tak segerak kepada segerak.

Pasang

serat nod ditulis dalam bahasa C Muat turun kod sumber secara langsung memerlukan kompilasi Biasanya, anda boleh memasangnya secara langsung dengan npm:

Salin kod Kod adalah seperti berikut:

npm memasang gentian

Penggunaan perpustakaan gentian

API

1.Fiber(fn)/ Fiber(fn baharu):

Buat gentian, yang boleh digunakan sebagai pembina atau dipanggil sebagai fungsi biasa. Contohnya:

Salin kod Kod adalah seperti berikut:

fungsi fibo(n) {
Kembalikan n > 1 ? }
Gentian(fungsi () {
console.log(fibo(40));
});

Apabila run() dipanggil, gentian bermula dan memperuntukkan tindanan baharu untuk fn fn akan dijalankan pada tindanan baharu ini sehingga fn mempunyai nilai pulangan atau hasil() dipanggil. Selepas fn mengembalikan atau memanggil hasil(), tindanan ditetapkan semula Apabila run() dipanggil semula, gentian akan dimulakan semula dan fn berjalan dalam tindanan yang diperuntukkan buat kali pertama.

2.Serat.arus:

Dapatkan gentian semasa dan beroperasi padanya. Jika anda menentukan pembolehubah untuk dikaitkan dengannya, pastikan anda memastikan gentian ini boleh dilepaskan, jika tidak, mekanisme kutipan sampah V8 akan sentiasa mengabaikan bahagian memori ini, menyebabkan kebocoran memori.

3.Serat.hasil(param):

Fungsi ini telah disebut dalam penerangan sebelumnya. Kaedah yield() digunakan untuk mengganggu gentian, sama seperti kembali ke tahap tertentu. Setelah yield() dilaksanakan, kod berikutnya dalam Fiber ini tidak akan mempunyai peluang untuk melaksanakan, contohnya:

Salin kod Kod adalah seperti berikut:

gentian var = Gentian(fungsi () {
console.log("Fiber Start");
Fiber.yield();
console.log("Fiber Stop");
}).run();
// Output: "Fiber Start"

Selepas pelaksanaan, hanya "Fiber Start" akan dikeluarkan, dan arahan output yang terakhir tidak akan dilaksanakan. Jika parameter dihantar kepada yield(), maka parameter ini digunakan sebagai nilai pulangan run().

Salin kod Kod adalah seperti berikut:

gentian var = Gentian(fungsi () {
Fiber.yield("kejayaan");
}).run();
console.log(fiber); // -> "berjaya"

4.Fiber.prototype.run(param):

Kaedah ini sudah sangat biasa. Terdapat dua tenses untuk memanggil run() yang dinyatakan sebelum ini, satu ialah apabila Fiber tidak dimulakan, dan satu lagi ialah apabila Fiber dihasilkan. Tingkah laku run() tidak sama dalam kedua-dua kala ini.
Apabila Fiber tidak dimulakan, run() menerima hujah dan menyerahkannya kepada fn sebagai hujahnya. Apabila Fiber mengendalikan keadaan hasil, run() menerima parameter dan menggunakannya sebagai nilai pulangan hasil( fn tidak akan berjalan dari awal, tetapi akan terus berjalan dari titik gangguan. Hubungan antara parameter dan nilai pulangan fn, hasil dan larian boleh dijelaskan melalui contoh kecil berikut:

Salin kod Kod adalah seperti berikut:

var Fiber = memerlukan('fibers');
gentian var = Gentian(fungsi (a) {
console.log("Larian panggilan pertama:");
console.log("parameter fn ialah: " a);
var b = Fiber.yield("hasil");
console.log("Larian panggilan kedua:");
console.log("parameter fn ialah: " a);
console.log("nilai pulangan hasil ialah: " b);
Kembalikan "kembali";
});
// Larian pertama ()
var c=fiber.run("Satu");
//Run run()
untuk kali kedua var d=fiber.run("Dua");
console.log("Panggilan hasil, jalankan kembali: " c);
console.log("operasi fn selesai, jalankan kembali: " d);

Output adalah seperti berikut:

Salin kod Kod adalah seperti berikut:

/*
Kali pertama anda memanggil run:
Parameter fn ialah: Satu
Larian panggilan:
untuk kali kedua Parameter fn ialah: Satu
Nilai pulangan hasil ialah: Dua
Panggilan hasil, jalankan pulangan: hasil
fn selesai dan jalankan pengembalian: return
*/

Daripada contoh di atas, adalah jelas bahawa penggunaan hasil agak berbeza daripada sintaks JavaScript semasa. Kata kunci hasil telah dilaksanakan dalam bahasa lain (C#, Python, dll.) sebagai gangguan untuk iterator. Anda juga boleh melaksanakan iterator pada nod dan mengalami penggunaan hasil secara terperinci. Mari kita ambil jujukan Fibonacci pada permulaan sebagai contoh:

Salin kod Kod adalah seperti berikut:

var fiboGenerator = fungsi () {
var a = 0, b = 0;
manakala (benar) {
Jika (a == 0) {
            a = 1;
Fiber.yield(a);
         } lain {
              b = a;
                b == a ? a = 1 : a = b - a;
Gentian.hasil(b);
}
}
}
var f = Gentian baharu(fiboGenerator);
f.next = f.run;
untuk (var i = 0; i console.log(f.next());
}

Outputnya ialah:

Salin kod Kod adalah seperti berikut:

/*
1
1
2
3
5
8
13
21
34
55
*/

Terdapat dua isu yang perlu diberi perhatian Pertama, hasil dikatakan kaedah, lebih seperti kata kunci Tidak seperti run, hasil tidak perlu bergantung pada contoh Fiber. Jika anda memanggil run di dalam Fiber, anda mesti menggunakan: Fiber.current.run(); kedua, hasil itu sendiri adalah kata kunci terpelihara bagi JavaScript. Ia tidak pasti jika dan bila ia akan didayakan, jadi kod itu mungkin menghadapi perubahan dalam masa depan.

5.Fiber.prototype.reset():

Kita sudah tahu bahawa Fiber mungkin mempunyai tenses yang berbeza, yang juga akan mempengaruhi tingkah laku larian. Kaedah set semula kembali kepada keadaan awal tidak kira apa keadaan proses Fiber. Pelaksanaan larian seterusnya akan dijalankan semula fn.

6.Fiber.prototype.throwInto(Exception):

Pada asasnya, throwInto akan membuang pengecualian yang dihantar kepadanya dan menggunakan maklumat pengecualian sebagai nilai pulangan larian. Jika pengecualian yang dilemparkan tidak dikendalikan dalam Fiber, pengecualian akan terus berbuih. Tidak kira sama ada pengecualian dikendalikan atau tidak, ia akan memaksa hasil dan mengganggu Fiber.

Penggunaan perpustakaan masa hadapan

Tidak selalu munasabah untuk menggunakan Fiber secara langsung dalam nod, kerana API Fiber adalah sangat mudah Dalam penggunaan sebenar, ia pasti akan menghasilkan kod berulang dan panjang, yang tidak sesuai untuk penyelenggaraan. Adalah disyorkan untuk menambah lapisan abstraksi antara nod dan Fiber untuk membolehkan Fiber berfungsi dengan lebih baik. Perpustakaan masa depan menyediakan abstraksi sedemikian. Perpustakaan masa depan atau mana-mana tahap abstrak mungkin tidak sempurna. Tiada siapa yang betul atau salah, hanya yang berkenaan atau tidak. Sebagai contoh, pustaka masa hadapan memberikan kami API ringkas yang boleh menyelesaikan kerja tak segerak kepada segerak, tetapi ia tidak boleh melakukan apa-apa untuk merangkum penjana (serupa dengan penjana jujukan Fibonacci di atas).

Pustaka masa hadapan tidak perlu dimuat turun dan dipasang secara berasingan Ia sudah disertakan dalam perpustakaan gentian Apabila menggunakannya, anda hanya perlu var future=require('fibers/future').

API

1.Function.prototype.future():

Menambah kaedah masa hadapan pada jenis Fungsi, menukar fungsi menjadi "fungsi-funture".

Salin kod Kod adalah seperti berikut:

var futureFun = kuasa fungsi(a) {
Kembalikan * a;
}.masa hadapan();
console.log(futureFun(10).tunggu());

Sebenarnya kaedah kuasa dilaksanakan dalam Fibel. Walau bagaimanapun, versi masa hadapan yang sedia ada mempunyai pepijat, dan tiada penjelasan rasmi rasmi Jika anda perlu menggunakan fungsi ini, sila padamkan baris 339 dan 350 future.js.

2.new Future()

Pembina objek Masa Depan, terperinci di bawah.

3.Future.wrap(fn, idx)

Kaedah bungkus merangkum operasi tak segerak kepada segerak dan merupakan kaedah paling berharga kepada kami di perpustakaan masa hadapan. fn mewakili fungsi yang perlu ditukar, idx mewakili bilangan parameter yang diterima oleh fn, dan kaedah panggil baliknya dianggap sebagai parameter terakhir (rumusan API di sini agak kontroversi. Sesetengah orang cenderung untuk melepasi kedudukan di mana panggilan balik sepatutnya. Nasib baik, kaedah bungkus adalah agak mudah dan boleh menjadi Lebih mudah untuk mengubah suai kod). Anda boleh memahami penggunaan bungkus dengan melihat contoh:

Salin kod Kod adalah seperti berikut:

var readFileSync = Future.wrap(require("fs").readFile);
Gentian(fungsi () {
var html = readFileSync("./1.txt").wait().toString();
console.log(html);
}).run();

Daripada contoh ini, kita dapat melihat bahawa penukaran tak segerak kepada gentian Serat sememangnya sangat berkesan Kecuali untuk langkah tambahan .wait() dalam sintaks, kaedah fs.readFileSync yang lain yang telah disediakan oleh fs adalah sama.

4.Future.wait(futures):

Kaedah ini telah dilihat banyak kali sebelum ini. Seperti namanya, fungsinya adalah untuk menunggu keputusan. Jika anda ingin menunggu keputusan contoh masa hadapan, hubungi terus futureInstance.wait() jika anda perlu menunggu hasil siri kejadian masa hadapan, hubungi Future.wait(futuresArray). Perlu diingatkan bahawa dalam penggunaan kedua, jika ralat berlaku apabila contoh masa hadapan sedang berjalan, kaedah tunggu tidak akan membuang ralat, tetapi kita boleh menggunakan kaedah get() untuk mendapatkan hasil yang sedang dijalankan.

5.Future.prototype.get():

Penggunaan get() sangat serupa dengan kaedah tunggu() pertama. Perbezaannya ialah get() mengembalikan hasilnya dengan segera. Jika data tidak sedia, get() akan membuang ralat.

6.Future.prototype.resolve(param1,param2):

Kaedah bungkus di atas sentiasa memberi orang tanggapan bahawa masa depan sebenarnya menelan fungsi panggil balik kaedah tak segerak dan secara langsung mengembalikan hasil tak segerak. Malah, masa depan juga menyediakan penyelesaian untuk menetapkan fungsi panggil balik melalui kaedah penyelesaian. menyelesaikan menerima sehingga dua parameter Jika hanya satu parameter yang dihantar, masa hadapan akan berfikir bahawa fungsi panggil balik gaya nod diluluskan, seperti contoh berikut:

Salin kod Kod adalah seperti berikut:

futureInstance.resolve(function (err, data) {
Wenn (irrt) {
           throw err;
} sonst {
console.log(data.toString());
}
});

Wenn zwei Parameter übergeben werden, bedeutet dies, dass der Fehler und die Daten getrennt verarbeitet werden. Das Beispiel sieht wie folgt aus:

Code kopieren Der Code lautet wie folgt:

futureInstance.resolve(function (err) {
Fehler werfen;
}, Funktion (Daten) {
console.log(data.toString());
});

Zusätzlich unterscheidet Future den Aufrufzeitpunkt der Auflösung nicht. Wenn die Daten nicht bereit sind, wird die Rückruffunktion in die Warteschlange verschoben und von der Resolver()-Methode einheitlich geplant und die Callback-Funktion wird sofort ausgeführt.

7.Future.prototype.isResolved():

Gibt einen booleschen Wert zurück, der angibt, ob der Vorgang ausgeführt wurde.

8.Future.prototype.proxy(futureInstance):

Die Proxy-Methode stellt einen Proxy für zukünftige Instanzen bereit, der im Wesentlichen ein Wrapper für die Auflösungsmethode ist. Tatsächlich verwendet sie die Callback-Methode einer Instanz als Callback-Executor einer anderen Instanz. Zum Beispiel:

Code kopieren Der Code lautet wie folgt:

var target = neue Zukunft;
target.resolve(function (err, data) {
console.log(data)
});
var ProxyFun = Funktion (num, cb) {
cb(null, num * num);
};
Fiber(function () {
var Proxy = Future.wrap(proxyFun)(10);
Proxy.proxy(Ziel);
}).run(); // Ausgabe 100

Obwohl der Proxy ausgeführt wird, wird schließlich die Rückruffunktion des Ziels ausgeführt, und das Ausführungsergebnis des Proxys steuert die Rückruffunktion des Ziels. Diese Proxy-Methode mag in unseren praktischen Anwendungen eine große Rolle spielen, aber ich habe noch nicht eingehend darüber nachgedacht.

9.Future.prototype.return(value):

10.Future.prototype.throw(error):

11.Future.prototype.resolver():

12.Future.prototype.detach():

Was die oben genannten vier APIs betrifft, bin ich der Meinung, dass die tatsächlichen Nutzungsszenarien oder Funktionen im Vergleich zu anderen APIs relativ durchschnittlich sind. Sowohl Return als auch Throw werden von der Resolver-Methode geplant. Diese drei Methoden sind sehr wichtig und funktionieren im normalen zukünftigen Verwendungsprozess. Ich habe jedoch kein spezifisches Szenario für ihre separate Verwendung herausgefunden, daher gibt es keine Möglichkeit, sie einzuführen ausführlich. Die Trennmethode kann nur als vereinfachte Version der Auflösungsmethode betrachtet werden und muss nicht eingeführt werden.