2012-01-20 19 views
6

मैं सिर्फ रेडिस और नोड.जेएस सीख रहा हूं मेरे पास दो प्रश्न हैं जिनके लिए मुझे कोई संतोषजनक उत्तर नहीं मिला।रेडिस और नोड.जेएस और सॉकेट.ओ प्रश्न

मेरा पहला सवाल node.js. के भीतर रेडिस क्लाइंट का पुन: उपयोग करने के बारे में है। मुझे यह प्रश्न और उत्तर मिला है: How to reuse redis connection in socket.io?, लेकिन यह मुझे पर्याप्त संतुष्ट नहीं किया।

अब, यदि मैं कनेक्शन ईवेंट के भीतर रेडिस क्लाइंट बना देता हूं, तो यह प्रत्येक कनेक्शन के लिए तैयार किया जाएगा। इसलिए, यदि मेरे पास 20k समवर्ती उपयोगकर्ता हैं, तो 20k रेडिस क्लाइंट होंगे।

यदि मैं इसे कनेक्शन ईवेंट से बाहर रखता हूं, तो यह केवल एक बार पैदा होगा।

उत्तर यह कह रहा है कि वह प्रत्येक समारोह के लिए कनेक्शन ईवेंट के बाहर तीन क्लाइंट बनाता है।

हालांकि, मैं माईएसक्यूएल को जानता हूं कि जब एक आवेदन लिखते हैं जो बाल प्रक्रियाओं को जन्म देता है और समानांतर में चलता है, तो आपको उस कार्य के भीतर अपना MySQL क्लाइंट बनाना होगा जिसमें आप बाल उदाहरण बना रहे हों। यदि आप इसे इसके बाहर बनाते हैं, तो MySQL "MySQL सर्वर चला गया है" की त्रुटि देगा क्योंकि बाल प्रक्रियाएं उसी कनेक्शन का उपयोग करने का प्रयास करेंगी। यह प्रत्येक बच्चे प्रक्रियाओं के लिए अलग से बनाया जाना चाहिए।

तो, यदि आप प्रत्येक समारोह के लिए तीन अलग-अलग रेडिस क्लाइंट बनाते हैं, तो यदि आपके पास 30k समवर्ती उपयोगकर्ता हैं जो एक साथ 2k संदेश भेजते हैं, तो आपको एक ही समस्या में भाग लेना चाहिए, है ना? इसलिए, प्रत्येक "उपयोगकर्ता" के पास कनेक्शन ईवेंट के भीतर अपना स्वयं का रेडिस क्लाइंट होना चाहिए। क्या मैं सही हू? यदि नहीं, तो node.js या redis कैसे MySQL से अलग समवर्ती अनुरोधों को संभालता है? यदि इसका अपना तंत्र है और रेडिस क्लाइंट के भीतर बाल प्रक्रियाओं की तरह कुछ बनाता है, तो हमें फिर तीन अलग-अलग रेडिस क्लाइंट बनाने की आवश्यकता क्यों है? एक पर्याप्त होना चाहिए।

मुझे आशा है कि प्रश्न स्पष्ट था।

- अद्यतन -

मैं निम्नलिखित प्रश्न के लिए एक जवाब मिल गया है। http://howtonode.org/control-flow उत्तर देने की कोई आवश्यकता नहीं है लेकिन मेरा पहला प्रश्न अभी भी मान्य है।

- अद्यतन -

मेरे दूसरे प्रश्न यह है। मैं जेएस और नोड.जे.एस. में भी अच्छा नहीं हूं तो, मुझे पता है कि, यदि आपको किसी ईवेंट की प्रतीक्षा करने की आवश्यकता है, तो आपको पहले फ़ंक्शन के भीतर दूसरे फ़ंक्शन को समाहित करने की आवश्यकता है। (मुझे अभी तक शब्दावली नहीं पता है)। मुझे एक उदाहरण देने दें;

socket.on('startGame', function() { 
    getUser(); 
    socket.get('game', function (gameErr, gameId) { 
     socket.get('channel', function (channelErr, channel) { 
      console.log(user); 
      client.get('games:' + channel + '::' + gameId + ':owner', function (err, owner) { //games:channel.32:game.14 
       if(owner === user.uid) { 
    //do something 
       } 
      }); 
     } 
    }); 
}); 

तो, अगर मैं इसे सही ढंग से सीख रहा हूँ, मैं समारोह के भीतर हर समारोह को चलाने के लिए अगर मैं प्रतीक्षा करने के लिए मैं/हे जवाब चाहिए की जरूरत है। अन्यथा, node.js की गैर-अवरुद्ध तंत्र पहले फ़ंक्शन को चलाने की अनुमति देगा, इस मामले में यह परिणाम समानांतर में प्राप्त होगा, लेकिन दूसरे फ़ंक्शन के परिणाम होने पर परिणाम नहीं हो सकता है। इसलिए, यदि आप उदाहरण के लिए रेडिस से परिणाम प्राप्त कर रहे हैं, और आप दूसरे फ़ंक्शन के भीतर परिणाम का उपयोग करेंगे, तो आपको इसे Redis फ़ंक्शन के भीतर encapsulate करना होगा। अन्यथा परिणाम प्राप्त किए बिना दूसरा फ़ंक्शन चलाएगा।

तो, इस मामले में, यदि मुझे 7 अलग-अलग कार्यों को चलाने की आवश्यकता है और 8. फ़ंक्शन को उन सभी के परिणाम की आवश्यकता होगी, तो क्या मुझे उन्हें इस तरह लिखना होगा, दोबारा? या क्या मैं कुछ न कुछ भूल रहा हूं।

मुझे आशा है कि यह भी स्पष्ट था।

धन्यवाद एक बहुत,

+1

वैसे, अपने दूसरे प्रश्न के अपने उत्तर को पूरा करने के लिए, आप फ्लो-कंट्रोल लाइब्रेरीज़ "एसिंक" और "चरण" को भी देख सकते हैं। –

उत्तर

2

तो, हर "उपयोगकर्ता" कनेक्शन घटना के भीतर अपनी खुद redis ग्राहक होना चाहिए। क्या मैं सही हूँ?

असल में, आप नहीं कर रहे हैं :)

बात यह है कि Node.js उदाहरण, पीएचपी के लिए, बहुत विपरीत है। node.js नए कनेक्शन पर बाल प्रक्रियाओं को जन्म नहीं देता है, जो मुख्य कारणों में से एक है जो आसानी से समेकित कनेक्शनों की बड़ी मात्रा में संभाल सकता है, जिसमें दीर्घकालिक कनेक्शन (धूमकेतु, वेबसाइट्स इत्यादि) शामिल हैं। node.js अनुक्रमिक रूप से एक एकल प्रक्रिया के भीतर एक ईवेंट कतार का उपयोग कर घटनाओं को संसाधित करता है। यदि आप बहु-कोर सर्वर या एकाधिक सर्वर का लाभ उठाने के लिए कई प्रक्रियाओं का उपयोग करना चाहते हैं, तो आपको इसे मैन्युअल रूप से करना होगा (हालांकि ऐसा करने के लिए इस सवाल के दायरे से बाहर है)।

इसलिए, यह बड़ी मात्रा में ग्राहकों की सेवा के लिए एक एकल रेडिस (या MySQL) कनेक्शन का उपयोग करने की पूरी तरह से वैध रणनीति है। यह प्रत्येक ग्राहक अनुरोध के लिए डेटाबेस कनेक्शन को तत्काल और समाप्त करने के ऊपरी हिस्से से बचाता है।

0

तो, प्रत्येक "उपयोगकर्ता" के पास कनेक्शन ईवेंट के भीतर अपना स्वयं का रेडिस क्लाइंट होना चाहिए। क्या मैं सही हू?

आपको प्रत्येक कनेक्टेड उपयोगकर्ता के लिए एक नया रेडिस क्लाइंट नहीं बनाना चाहिए, यह करने का उचित तरीका नहीं है। इसके बजाय बस 2-3 क्लाइंट अधिकतम बनाएं और उनका उपयोग करें।

अधिक जानकारी चेकआउट के लिए इस सवाल का:

How to reuse redis connection in socket.io?

0

पहला सवाल का सवाल है: "सही जवाब" आपको लगता है कि आप एक कनेक्शन के साथ अच्छा कर रहे हैं हो सकता है। हकीकत में, जब भी आप कुछ ऐसा कर रहे हैं जो आईओ, टाइमर इत्यादि पर इंतजार कर रहा है, तो आप वास्तव में कतार पर प्रतीक्षा विधि को नोड बना रहे हैं। इसलिए, यदि आप केवल 1 सिंगल कनेक्शन का उपयोग करते हैं, तो आप वास्तव में रेडिस की गति के लिए (एक सिंगल सीपीयू) पर काम कर रहे थ्रेड के प्रदर्शन को सीमित कर देंगे - जो शायद प्रति सेकंड कुछ सैकड़ों कॉलबैक हैं (गैर-रेडिस प्रतीक्षा कॉलबैक अभी भी चलते हैं) - जबकि यह खराब प्रदर्शन नहीं है, इस तरह की सीमा बनाने का कोई कारण नहीं है। इस मुद्दे को पूरी तरह से टालने के लिए कुछ (5-10) कनेक्शन बनाने की अनुशंसा की जाती है। यह संख्या धीमी डेटाबेस के लिए बढ़ जाती है, उदा। MySQL, लेकिन प्रश्नों के प्रकार और कोड विनिर्देशों पर निर्भर है।

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

संबंधित मुद्दे