कनेक्शन पूलिंग का उपयोग करके PostgreSQL में स्केलिंग कनेक्शन

डेटाबेस कनेक्शन खोलना एक महंगा ऑपरेशन है, और कनेक्शन पूलिंग का उपयोग डेटाबेस कनेक्शन को खुला रखने के लिए किया जाता है ताकि उनका पुन:उपयोग किया जा सके। यह बार-बार नेटवर्क सत्र खोलने, प्रमाणित करने और प्राधिकरण की जांच करने से बचता है। पूलिंग कनेक्शन को सक्रिय रखता है ताकि, जब बाद में किसी कनेक्शन का अनुरोध किया जाता है, तो एक सक्रिय कनेक्शन का उपयोग शुरू से एक बनाने के बजाय किया जाता है।

कनेक्शन पूलिंग

कनेक्शन पूलिंग एक क्वेरी अनुरोध से पहले डेटाबेस कनेक्शन को संभालने के सबसे सामान्य तरीकों में से एक बन गया है। हम आम तौर पर सोचते हैं कि डेटाबेस से कनेक्शन तेज़ है, लेकिन ऐसा नहीं है, खासकर जब बड़ी संख्या में क्लाइंट कनेक्ट हो रहे हों। कनेक्शन पूलिंग के बिना, एक अनुरोध को कनेक्ट होने में 35-50 ms तक का समय लगेगा लेकिन यदि कनेक्शन पूलिंग कार्यरत है तो 1-2ms तक। इसलिए कनेक्शन पूलिंग डेटाबेस कनेक्शनों को पूर्व-आवंटित कर रहा है, और फिर नए क्लाइंट कनेक्ट होने पर उन्हें पुनर्चक्रित कर रहा है

कनेक्शन पूलिंग के कारण

1. अपने सर्वर को क्रैश होने से बचाने के लिए। PostgreSQL सर्वर मेमोरी पैरामीटर के आधार पर एक समय में कई क्लाइंट तक सीमित होते हैं। यदि यह संख्या पार हो जाती है, तो आप सर्वर को क्रैश कर देंगे। कनेक्शन पूलिंग के साथ, क्लाइंट कनेक्शन की एक निश्चित संख्या का उपयोग करते हैं।
2. क्वेरी प्रोसेसिंग को आसान बनाएं। आम तौर पर, डेटाबेस अनुरोधों को पहले-पहले-पहले के मानदंड के साथ क्रमबद्ध तरीके से निष्पादित किया जाता है। ग्राहकों के एक बड़े समूह के साथ, इस प्रक्रिया को प्राप्त करने में उम्र लग जाएगी। इसलिए दृष्टिकोण पाइपलाइन किए गए अनुरोधों के साथ एकल कनेक्शन बनाने का होना चाहिए जिसे एक समय में प्रत्येक के बजाय एक साथ निष्पादित किया जा सकता है।
3. सुरक्षा में सुधार करें। अक्सर एक कनेक्शन में एक हैंडशेक शामिल होता है जिसमें औसत 25-35 एमएस लग सकता है जिस पर एक एसएसएल स्थापित होता है, पासवर्ड की जांच की जाती है और कॉन्फ़िगरेशन जानकारी साझा की जाती है। प्रत्येक जुड़े हुए उपयोगकर्ता के लिए यह सभी कार्य स्मृति के व्यापक उपयोग में परिणत होंगे। हालांकि, कनेक्शन पूलिंग के साथ, कनेक्शन की संख्या कम हो जाती है इसलिए मेमोरी की बचत होती है।

कनेक्शन पूलिंग के प्रकार

मूल रूप से दो प्रकार के कनेक्शन पूलिंग होते हैं, हालांकि, एक तीसरे प्रकार का कार्य-आसपास है जो एक कनेक्शन पूलिंग रणनीति की तरह कार्य करता है जिसे लगातार कनेक्शन के रूप में जाना जाता है।

लगातार कनेक्शन पूलिंग

यह दृष्टिकोण प्रारंभिक कनेक्शन को प्रारंभ होने के समय से सक्रिय रखने का इरादा रखता है। यह पूरी तरह से कनेक्शन पूलिंग सुविधाओं को नहीं रखता है, लेकिन कुछ निरंतर कनेक्शन प्रदान करने के लिए पर्याप्त है। यह क्लाइंट कनेक्शन के एक छोटे से सेट के लिए काफी मददगार है, जिसका ओवरहेड 25-50 ms के बीच हो सकता है। इस दृष्टिकोण के साथ एक सीमा यह है कि यह डीबी के कई कनेक्शनों तक सीमित है, सामान्य रूप से सर्वर में प्रति प्रविष्टि एक कनेक्शन के साथ।

फ्रेमवर्क कनेक्शन पूलिंग

फ्रेमवर्क कनेक्शन पूलिंग एक एप्लिकेशन स्तर पर होता है जिससे, जब भी आपकी सर्वर स्क्रिप्ट शुरू होती है, तो बाद में आने वाले क्वेरी अनुरोधों को संभालने के लिए कनेक्शन का एक पूल स्थापित किया जाता है।

स्टैंडअलोन कनेक्शन पूलिंग

डेटाबेस से प्रत्येक कनेक्शन के लिए, 5 से 10 एमबी के बीच एक ओवरहेड मेमोरी का उपयोग क्वेरी अनुरोध को पूरा करने के लिए किया जाता है। यह बड़ी संख्या में कनेक्शन के लिए काफी अच्छा नहीं है। फ्रेमवर्क कनेक्शन पूलिंग का उपयोग कनेक्शन की इस संख्या से सीमित किया जा सकता है क्योंकि यह एक बड़े मेमोरी आकार के उपयोग का सामना कर सकता है। इस प्रकार हम स्टैंडअलोन कनेक्शन पूलिंग का उपयोग करने का विकल्प चुनते हैं जो पोस्टग्रेज सत्र, विवरण और लेनदेन के अनुसार कॉन्फ़िगर किया गया है। इस दृष्टिकोण से जुड़ा मुख्य लाभ यह है:प्रत्येक कनेक्शन के लिए लगभग 2kb की न्यूनतम ओवरहेड लागत।

जब आप एक कनेक्शन पूलिंग क्लास बनाते हैं, तो उसे बढ़े हुए डेटाबेस प्रदर्शन के लिए निम्नलिखित कारकों को पूरा करना चाहिए:

1. कनेक्शन पूर्व-आवंटित करें
2. उपलब्ध कनेक्शनों की निगरानी करें
3. नए कनेक्शन असाइन करें
4. कनेक्शन के उपलब्ध होने की प्रतीक्षा करें
5. कनेक्शन बंद करें

कनेक्शंस को पूर्व-आवंटित करना

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

availableConnections = new Vector(connections); 
busyConnections = new Vector();
for(int i=0; i<connections; i++) {
availableConnections.addElement(makeNewConnection()); 
}

उपलब्ध कनेक्शनों की निगरानी करना

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

public synchronized Connection getConnection() throws SQLException {
if (!availableConnections.isEmpty()) { Connection existingConnection =
(Connection)availableConnections.lastElement(); int lastIndex = availableConnections.size() - 1; availableConnections.removeElementAt(lastIndex); if (existingConnection.isClosed()) {
notifyAll(); // Freed up a spot for anybody waiting.
return(getConnection()); // Repeat process. } else {
busyConnections.addElement(existingConnection);
return(existingConnection); }
} }

नया कनेक्शन असाइन करना

यदि उपलब्ध पर कोई निष्क्रिय नहीं है और यदि कनेक्शन सीमा लगभग पूरी हो रही है, तो आपको एक नया कनेक्शन असाइन करने के लिए पृष्ठभूमि थ्रेड प्रारंभ करने में सक्षम होना चाहिए।

if ((totalConnections() < maxConnections) && !connectionPending) { // Pending = connecting in bg
makeBackgroundConnection(); }
try {
wait(); // Give up lock and suspend self.
} catch(InterruptedException ie) {} return(getConnection()); // Try again.

नए कनेक्शन की प्रतीक्षा में

जब कोई निष्क्रिय कनेक्शन नहीं होता है और कनेक्शन की सीमा पूरी हो जाती है, तो कॉन्फ़िगरेशन को निरंतर पूलिंग के बिना नए कनेक्शन के उपलब्ध होने की प्रतीक्षा करने में सक्षम होना चाहिए। हम प्रतीक्षा पद्धति का उपयोग करके ऐसा कर सकते हैं जो एक थ्रेड सिंक्रोनाइज़ेशन लॉक प्रदान करता है और एक अधिसूचना प्रदान किए जाने तक थ्रेड को निलंबित करता है।

try {
     wait();
} catch(InterruptedException ie) {} 
return(getConnection());

अच्छी एप्लिकेशन नैतिकता के लिए, क्लाइंट को कनेक्शन के लिए वास्तविक समय में प्रतीक्षा नहीं करनी चाहिए, बल्कि नीचे दिए गए कोड के साथ कनेक्शन अनुपस्थित होने पर आप एक अपवाद फेंक देंगे:

throw new SQLException("Connection limit reached");

कनेक्शन बंद करना

जब कनेक्शन कचरा एकत्र किया जाता है, तो आपको इसे स्पष्ट रूप से करने के बजाय बंद कर देना चाहिए। हालांकि, यदि आप किसी कनेक्शन को बंद करने के लिए एक स्पष्ट दृष्टिकोण चाहते हैं तो आप इसका उपयोग कर सकते हैं:

public synchronized void closeAllConnections() {
// The closeConnections method loops down Vector, calling // close and ignoring any exceptions thrown. closeConnections(availableConnections); availableConnections = new Vector(); closeConnections(busyConnections);
busyConnections = new Vector();
}

निष्कर्ष

PostgreSQL के लिए कनेक्शन पूलिंग हमें डेटाबेस से कनेक्ट करने के लिए आवश्यक संसाधनों की संख्या को कम करने में मदद करती है और डेटाबेस से कनेक्टिविटी की गति में सुधार करती है। यह डीबी से कनेक्शनों को पूल करके, इन कनेक्शनों को बनाए रखने और परिणामस्वरूप खोले जाने वाले कनेक्शनों की संख्या को कम करके हासिल किया जाता है।