डेटाबेस के लिए कनेक्शन के पूल - क्यों और क्यों

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

सिद्धांत

एक बेहतर समझ के लिए, विचार करें कि जब एप्लिकेशन डेटाबेस से क्वेरी करता है, तो उदाहरण के लिए, क्वेरी क्या है:

1. डेटाबेस के लिए एक कनेक्शन खोलना और सर्वर के लिए एक अनुरोध भेजना।
2. सर्वर SQL क्वेरी को पार्स करता है।
3. सर्वर नियमों के आधार पर क्वेरी का अनुकूलन करता है, साथ ही साथ तालिकाओं पर आंकड़े भी। नतीजतन, एक क्वेरी निष्पादन योजना बनाई गई है।
4. सर्वर पहले से बनाई गई योजना के अनुसार अनुरोध को निष्पादित करता है और उपयोगकर्ता को परिणाम भेजता है।

आप समय कैसे बचा सकते हैं?
सर्वर से कनेक्शन खोलने का पहला चरण काफी लंबा है और हम इसे पहले से खुले कनेक्शनों का एक पूल तैयार करके और आवेदन से आवश्यकतानुसार कनेक्शन प्रदान कर सकते हैं।

यदि हम प्रश्न लिखते समय संबंधित चर का उपयोग करते हैं और चरण तीन का परिणाम कैश करते हैं जो हमें सर्वर से मिलता है, तो चरण दो और तीन के निष्पादन से बचना भी संभव है।

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

मापने की विधि

परीक्षणों के लिए, हम निशुल्क PostgreSQL DBMS का उपयोग करते हैं, और हम क्लाइंट को जावा में लिखेंगे। डेटाबेस में, प्राथमिक कुंजी आईडी और स्ट्रिंग मान मान से मिलकर एक छोटी तालिका test.test_table (लगभग 10 पंक्तियाँ) बनाएँ। हमारे ग्राहक समानांतर में डेटाबेस पर प्रश्नों को निष्पादित करते हैं, इसके लिए हम थ्रेड बनाएंगे जो इस तालिका में प्राथमिक कुंजी के लिए सरल खोज करेंगे। धागे बनाते समय, हम कनेक्शन पूल के विभिन्न कार्यान्वयन को इंगित करेंगे, जो हमें प्रदर्शन की तुलना करने की अनुमति देगा, क्योंकि थ्रेड 100 अनुरोधों को निष्पादित करने पर खर्च किए गए कुल समय पर विचार करेगा।

class TestThread extends Thread { private DBPool pool; private long workTime = 0; private long foundStr = 0; @Override public void run() { workTime = System.currentTimeMillis(); //   Connection con = null; PreparedStatement st = null; ResultSet rs = null; Random rnd = new Random();//        for (int i = 0; i < 100; i++) { try { con = pool.getConnection();//     //         st = con.prepareStatement("SELECT a.* FROM test.test_table a WHERE id =?"); st.setObject(1, rnd.nextInt(10)); rs = st.executeQuery();//   if (rs.next()) { String tmp = (rs.getString(2)); //   if (tmp != null) { foundStr++; } } } catch (SQLException ex) { //  ,    System.out.println("Pool " + pool + " exeption " + ex); } finally { //   ,       try { if (rs != null) rs.close(); } catch (SQLException e) { //ignore } try { if (st != null) st.close(); } catch (SQLException e) { //ignore } try { if (con != null) pool.putConnection(con); //      } catch (SQLException e) { //ignore } } } workTime = System.currentTimeMillis() - workTime; //    } } 

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

  class DBPool { private String url, user, password; DBPool(String url, String user, String password) throws ClassNotFoundException { this.url = url; this.user = user; this.password = password; Class.forName("org.postgresql.Driver"); } public Connection getConnection() throws SQLException { return DriverManager.getConnection(url, user, password); } public void putConnection(Connection connection) throws SQLException { connection.close(); } } 

दूसरा JDBC ड्राइवर से PostgreSQL - PGPoolingDataSource तक एक विशेष कैशिंग डेटा स्रोत वर्ग का उपयोग किया जाएगा। जो आपको कनेक्शन पूल का आकार, साथ ही कनेक्शन की प्रारंभिक संख्या निर्धारित करने की अनुमति देता है। इसके अलावा, सेटिंग्स में, ReadyedStatement में एक सेटप्रीपरथ्रेशोल्ड सेटिंग होती है - जो अनुरोध निष्पादित होने की संख्या के लिए जिम्मेदार होती है, जिसके बाद अनुरोध को कैश किया जाता है और निष्पादन योजना बनाने या पार्स करने की आवश्यकता नहीं होती है।

  class DBPoolCache extends DBPool { private PGPoolingDataSource source; DBPoolCache(String host, String database, String user, String password) { source = new PGPoolingDataSource(); source.setDataSourceName("A Data Source"); source.setServerName(host); source.setDatabaseName(database); source.setUser(user); source.setPassword(password); source.setMaxConnections(20);//  source.setInitialConnections(20);//     } public Connection getConnection() throws SQLException { return source.getConnection(); } public void putConnection(Connection connection) throws SQLException { connection.close(); } } 

खैर, अंत में, पूल के हमारे कार्यान्वयन, जब हम खुद को डेटाबेस से कनेक्शन के साथ-साथ SQL क्वेरी (रेडीस्टेमेंट) पार्स करने के परिणाम कैश करते हैं।

  class DBPoolCacheMy extends DBPool { private String url, user, password; private PGSimpleDataSource source; private BlockingQueue<Connection> connections = new ArrayBlockingQueue<Connection>(20); DBPoolCacheMy(String host, String database, String user, String password) throws SQLException { source = new PGSimpleDataSource(); source.setServerName(host); source.setDatabaseName(database); source.setUser(user); source.setPassword(password); for (int i = 0; i < 20; i++) {//  connections.add(new MyConnection(source.getConnection())); } } public Connection getConnection() throws SQLException { try { //     return connections.poll(2, TimeUnit.SECONDS); } catch (InterruptedException e) { return null; } } public void putConnection(Connection connection) throws SQLException { connections.add(connection); } } 

आपको अपने स्वयं के डेटाबेस कनेक्शन वर्ग को भी लागू करना होगा, जो कि रेडीस्टेडमेंट कैशिंग लागू करेगा।

  class MyConnection implements Connection { private Connection connection; protected MyConnection(Connection connection) { this.connection = connection; } private ConcurrentHashMap<String, PreparedStatement> statements = new ConcurrentHashMap<String, PreparedStatement>(); public PreparedStatement prepareStatement(String sql) throws SQLException { PreparedStatement statement = statements.get(sql); if (statement == null) { statement = new MyStatement(connection.prepareStatement(sql)); statements.put(sql, statement); } return statement; } ..... } 

इसके अलावा, इसका वर्ग रेडीस्टेडमेंट इंटरफ़ेस को लागू करता है, और बंद होने पर प्रतिक्रिया नहीं देता है

  class MyStatement implements PreparedStatement { private PreparedStatement statement; MyStatement(PreparedStatement statement) throws SQLException { this.statement = statement; ((PGStatement) statement).setPrepareThreshold(1); } public void close() throws SQLException { //ignore } ..... } 

निष्कर्ष

और अंत में, हम तीन अलग-अलग कनेक्शन पूल के प्रदर्शन की तुलना करते हैं, परीक्षणों को उनके कार्यान्वयन के लिए 1 से 10 तक समानांतर थ्रेड्स की संख्या के साथ चलाते हैं। परिणामस्वरूप, थ्रेड्स की संख्या पर कुल कार्य निष्पादन समय की निम्न निर्भरता प्राप्त की गई थी।



ग्राफ़ दर्शाता है कि डेटाबेस कनेक्शन को कैश करना स्पष्ट रूप से आवश्यक है, इससे सिस्टम के प्रदर्शन में उल्लेखनीय वृद्धि होती है। लेकिन कनेक्शन कैशिंग और रेडीस्टेडमेंट के स्व-लिखित कार्यान्वयन को मूर्त लाभ नहीं देता है।