Node.js
Eventloop

परिचय

इवेंट लूप की अवधारणा कैसे विकसित हुई।

छद्म कोड में Eventloop

एक ईवेंट लूप एक लूप है जो घटनाओं की प्रतीक्षा करता है और फिर उन घटनाओं पर प्रतिक्रिया करता है

while true:
    wait for something to happen
    react to whatever happened

बिना इवेंट लूप वाले एकल-थ्रेडेड HTTP सर्वर का उदाहरण

    while true:
    socket = wait for the next TCP connection
    read the HTTP request headers from (socket)
    file_contents = fetch the requested file from disk
    write the HTTP response headers to (socket)
    write the (file_contents) to (socket)
    close(socket)

यहाँ एक HTTP सर्वर का एक सरल रूप है जो एक एकल थ्रेडेड है लेकिन कोई ईवेंट लूप नहीं है। यहां समस्या यह है कि यह तब तक इंतजार करता है जब तक कि अगले अनुरोध को शुरू करने से पहले प्रत्येक अनुरोध समाप्त न हो जाए। यदि HTTP अनुरोध हेडर पढ़ने या डिस्क से फ़ाइल लाने में कुछ समय लगता है, तो हमें अगले अनुरोध को संसाधित करने में सक्षम होना चाहिए, जबकि हम समाप्त होने का इंतजार करते हैं।

सबसे आम समाधान कार्यक्रम को बहु-थ्रेडेड बनाना है।

बिना इवेंट लूप वाले बहु-थ्रेडेड HTTP सर्वर का उदाहरण

function handle_connection(socket):
    read the HTTP request headers from (socket)
    file_contents = fetch the requested file from disk
    write the HTTP response headers to (socket)
    write the (file_contents) to (socket)
    close(socket)
while true:
    socket = wait for the next TCP connection
    spawn a new thread doing handle_connection(socket)

अब हमने अपना थोड़ा HTTP सर्वर मल्टी थ्रेडेड बना लिया है। इस तरह, हम तुरंत अगले अनुरोध पर आगे बढ़ सकते हैं क्योंकि वर्तमान अनुरोध पृष्ठभूमि थ्रेड में चल रहा है। Apache सहित कई सर्वर इस दृष्टिकोण का उपयोग करते हैं।

लेकिन यह सही नहीं है। एक सीमा यह है कि आप केवल इतने सारे धागे पैदा कर सकते हैं। वर्कलोड के लिए जहां आपके पास भारी संख्या में कनेक्शन हैं, लेकिन प्रत्येक कनेक्शन को केवल एक बार हर बार ध्यान देने की आवश्यकता होती है, बहु-थ्रेडेड मॉडल बहुत अच्छा प्रदर्शन नहीं करेगा। उन मामलों के लिए समाधान एक घटना लूप का उपयोग करना है:

इवेंट लूप के साथ एक HTTP सर्वर का उदाहरण

while true:
    event = wait for the next event to happen
    if (event.type == NEW_TCP_CONNECTION):
        conn = new Connection
        conn.socket = event.socket
        start reading HTTP request headers from (conn.socket) with userdata = (conn)
    else if (event.type == FINISHED_READING_FROM_SOCKET):
        conn = event.userdata
        start fetching the requested file from disk with userdata = (conn)
    else if (event.type == FINISHED_READING_FROM_DISK):
        conn = event.userdata
        conn.file_contents = the data we fetched from disk
        conn.current_state = "writing headers"
        start writing the HTTP response headers to (conn.socket) with userdata = (conn)
    else if (event.type == FINISHED_WRITING_TO_SOCKET):
        conn = event.userdata
        if (conn.current_state == "writing headers"):
            conn.current_state = "writing file contents"
            start writing (conn.file_contents) to (conn.socket) with userdata = (conn)
        else if (conn.current_state == "writing file contents"):
            close(conn.socket)

उम्मीद है कि यह छद्मकोड समझदार है। यहाँ क्या हो रहा है: हम चीजों के होने की प्रतीक्षा करते हैं। जब भी कोई नया कनेक्शन बनाया जाता है या किसी मौजूदा कनेक्शन को हमारे ध्यान की आवश्यकता होती है, तो हम उससे निपटते हैं, फिर प्रतीक्षा करने के लिए वापस जाते हैं। इस तरह, हम बहुत अच्छा प्रदर्शन करते हैं जब कई कनेक्शन होते हैं और प्रत्येक को शायद ही कभी ध्यान देने की आवश्यकता होती है।

लिनक्स पर चलने वाले एक वास्तविक एप्लिकेशन (pseudocode) में, पोल () या एपोल () सिस्टम कॉल को कॉल करके "अगले घटना होने की प्रतीक्षा करें" भाग को लागू किया जाएगा। "सॉकेट के लिए कुछ पढ़ना / लिखना शुरू करें" भागों को आरईवी () या नॉन-ब्लॉकिंग मोड में सिस्टम कॉल को कॉल करके लागू किया जाएगा।

संदर्भ:

[1]। "इवेंट लूप कैसे काम करता है?" [ऑनलाइन]। उपलब्ध: https://www.quora.com/How-does-an-event-loop-work