JS / C # / Rust में async / wait का उपयोग करने के लिए हम किस कीमत का भुगतान करते हैं

नमस्कार, हेब्र!

जावास्क्रिप्ट / टाइपस्क्रिप्ट के साथ काम करते समय, मैंने लंबे समय तक देखा कि अतुल्यकालिक एपीआई समान तुल्यकालिक एपीआई की तुलना में धीमा है, और यहां तक ​​कि यह भी पता था कि ऐसा होना चाहिए। लेकिन आखिरी परियोजना में, फ़ाइल सिस्टम के साथ अतुल्यकालिक काम एक अड़चन बन गया, और मैंने माप का ख्याल रखा।

यह ज्ञात है कि प्रतीक्षा का उपयोग केवल async फ़ंक्शन या ब्लॉक के अंदर ही किया जा सकता है, जिसका अर्थ है कि यदि हमारे पास न्यूनतम API स्तर अतुल्यकालिक है, तो आपको लगभग हर जगह async / प्रतीक्षा का उपयोग करना होगा, भले ही यह स्पष्ट रूप से आवश्यक न हो।

उदाहरण के लिए, हम एक सेवा फ़ंक्शन लिखते हैं जो कुंजी द्वारा स्टोरेज से ऑब्जेक्ट लेता है। भंडारण के रूप में, हम एक फ़ाइल, डेटाबेस, माइक्रोसैस सर्विस का उपयोग कर सकते हैं, जो कि एसिंक्रोनस इंटरफ़ेस के साथ एक धीमा स्रोत है। हमारे कार्य के अंदर प्रदर्शन को बेहतर बनाने के लिए, हम पहले निकाले गए ऑब्जेक्ट को कैश करते हैं (उन्हें मानचित्र में जोड़ें)। जैसे ही स्टोर पर वास्तविक पहुंच का कार्यक्रम छोटा होता है, वस्तुओं को तेजी से कैश से लौटा दिया जाता है, लेकिन फ़ंक्शन इंटरफ़ेस अतुल्यकालिक रहता है!

प्रत्येक अतुल्यकालिक कॉल के लिए मुझे क्या कीमत चुकानी होगी?
परीक्षा परिणाम निराशाजनक ...

एक साधारण फ़ंक्शन लें, इसे async चिह्नित करें, और हम इसे लूप में कहेंगे, कुल समय को मापेंगे, और एक समान तुल्यकालिक कोड के साथ तुलना करेंगे। वाक्य रचना की तुलना करने के लिए, मैं 3 भाषाओं में पूर्ण ग्रंथों को उद्धृत करता हूं।

टाइपस्क्रिप्ट ( Deno )

const b = Date.now() let j = 0.0 for (let i = 0; i < 1_000_000_000; i++) { j += f(i) } console.log(j + ', ' + (Date.now() - b)/1000 + 's') function f(i: number): number { return i / 3.1415926 } 

अतुल्यकालिक कोड:

 (async () => { const b = Date.now() let j = 0.0 for (let i = 0; i < 1_000_000_000; i++) { j += await f(i) } console.log(j + ', ' + (Date.now() - b)/1000 + 's') })() async function f(i: number): Promise<number> { return i / 3.1415926 } 

C # (.NET कोर)

 using System; class App { static void Main(string[] args) { var b = DateTime.Now; var j = 0.0; for (var i = 0L; i < 1_000_000_000L; i++) { j += f(i); } Console.WriteLine(j + ", " + (DateTime.Now - b).TotalMilliseconds / 1000 + "s"); } static double f(long i) { return i / 3.1415926; } } 

अतुल्यकालिक कोड:

 using System; using System.Threading.Tasks; class App { static async Task Main(string[] args) { var b = DateTime.Now; var j = 0.0; for (var i = 0L; i < 1_000_000_000L; i++) { j += await f(i); } Console.WriteLine(j + ", " + (DateTime.Now - b).TotalMilliseconds / 1000 + "s"); } static async Task<double> f(long i) { return i / 3.1415926; } } 

रतुआ

 fn main() { let tbegin = std::time::SystemTime::now(); let mut j = 0.0; for i in 0..1_000_000_000i64 { j += f(i); } println!("{:?}, {:?}", j, tbegin.elapsed().unwrap()); } fn f(i: i64) -> f64 { return i as f64 / 3.1415926 } 

अतुल्यकालिक कोड:

 //[dependencies] //futures = "0.3" use futures::executor::block_on; fn main() { block_on(async { let tbegin = std::time::SystemTime::now(); let mut j = 0.0; for i in 0..1_000_000_000i64 { j += f(i).await; } println!("{:?}, {:?}", j, tbegin.elapsed().unwrap()); }); } async fn f(i: i64) -> f64 { return i as f64 / 3.1415926 } 

परिणाम

हम देखते हैं कि सभी 3 भाषाओं में अंकगणित समान रूप से अच्छा है, लेकिन प्रतीक्षा के लिए ओवरहेड परिमाण के एक क्रम से भिन्न होता है। दिलचस्प बात यह है कि जहां एसिंक्रोनस / वेट का उपयोग सबसे आम (और यहां तक ​​कि प्रचारित) है, अतुल्यकालिक कॉल की लागत केवल निषेधात्मक है। रस्ट ने हमेशा की तरह रेस जीती, शायद यही मुख्य कारण है कि इस पर लिखे गए WEB- फ्रेमवर्क ने लगातार एक साल से अधिक समय तक बेंचमार्क जीता है।

सारांश

बिना किसी कारण के, जावा डेवलपर्स सीधे भाषा में एसिंक्रोनस सिंटैक्स जोड़ने की जल्दी में नहीं हैं, और हालांकि मेरा मानना ​​है कि एसिंक्स / वेट एक महान अमूर्तता है, हमें इसका उपयोग करते समय ओवरहेड के पैमाने को समझना चाहिए।

पुनश्च
उन सभी के लिए धन्यवाद, जिन्होंने कोडिंग कार्य / वादों (परिणामों के कैशिंग के बजाय) के साथ-साथ कोड को गति देने की संभावना को इंगित किया, साथ ही साथ एक महान उपकरण के C # में उपस्थिति जो सिर्फ मेरी समस्या को हल करता है।