🛳️ 🎅🏾 👌 Log4j 1.x तुल्यकालिक और अतुल्यकालिक मोड में प्रदर्शन 👩🏾‍⚖️ 🍯 👩🏼‍🤝‍👨🏽

शुभ दिन, ह्रज़ितली!

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

इसने मुझे इस अध्ययन के लिए प्रेरित किया - क्या लॉगिंग प्रक्रिया को अनुकूलित करने का कोई तरीका है?

डिस्क्लेमर : इस लेख में डायग्राम की बहुतायत के कारण जो साइकेडेलिक एसोसिएशन का कारण बनता है (जैसे: यह तुल्यकालिक और अतुल्यकालिक लॉगिंग मोड की तुलना नहीं है, ड्रैगन यहां एक सांप को मारता है!), यह नाबालिगों के लिए अनुशंसित नहीं है, एक अस्थिर मानस और गर्भवती महिलाओं के लिए जिसका कोड पहले से ही है। उत्पादन और अगले पैच की रिलीज इस साल नहीं है।

कट के नीचे सावधानी, यातायात।

क्या कारण है?

हमेशा की तरह, कारण आम है - "प्रतिस्पर्धी पहुंच"। समानांतर थ्रेड्स की एक फ्लोटिंग संख्या के साथ कई प्रयोगों के बाद, यह स्पष्ट हो गया कि लॉगिंग कॉल का कार्य समय रैखिक नहीं है, इसलिए आउटपुट यह है कि हार्ड ड्राइव बहुत कुछ खो देता है।

यहाँ माप परिणाम हैं:

समाधान क्या है?

लॉगिंग के अन्य तरीकों की तलाश करें, पुस्तकालयों को अपग्रेड करें, आप यह सब कर सकते हैं, लेकिन कार्य न्यूनतम प्रयासों के साथ अधिकतम परिणाम प्राप्त करना है। मैं log4j 2 लाइब्रेरी के बारे में भी बता सकता हूं, लेकिन यह एक अलग लेख होगा। अब हम log4j 1.x में "बॉक्स से बाहर" प्रदान किए गए साधनों पर विचार करेंगे।

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

माप

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

हम इस तरह मापेंगे:
0) मैंने आपको पहले ही चेतावनी दी थी, "मैंने सुंदर डेटा नहीं बनाया है", कुछ जगहों पर यह स्पष्ट है कि प्रोसेसर दूसरे काम में बदल गया है, और मैंने इन स्थानों को छोड़ दिया जैसा कि यह था। यह सिस्टम के वास्तविक कार्य का भी हिस्सा है।
1) हम परीक्षणों को 3 समूहों में विभाजित करते हैं:
- 10 लॉगिंग इवेंट (1 से 10 की वेतन वृद्धि में)
- 550 लॉगिंग इवेंट (10 से 100 से 10 की वेतन वृद्धि में)
- 5500 लॉगिंग इवेंट्स (100 से 1000 की वेतन वृद्धि में)
2) प्रत्येक समूह में परीक्षणों के 3 उपसमूह होंगे - बफर के आकार के आधार पर (इष्टतम को खोजने का प्रयास करें):
- 500 इवेंट
- 1500 इवेंट
- 5000 इवेंट
3) टेस्ट को सिंक्रोनाइज़ और एसिंक्रोनस तरीके से किया जाएगा।

सिंक्रोनस लॉगर कॉन्फ़िगरेशन

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" > <log4j:configuration> <appender name="fileAppender" class="org.apache.log4j.FileAppender"> <param name="file" value="st.log"/> <layout class="org.apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%d{ABSOLUTE} %5p %t %c{1}:%M:%L - %m%n"/> </layout> </appender> <root> <priority value="info" /> <appender-ref ref="fileAppender"/> </root> </log4j:configuration>

अतुल्यकालिक लकड़हारा विन्यास

 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd" > <log4j:configuration> <appender name="fileAppender" class="org.apache.log4j.FileAppender"> <param name="file" value="st.log"/> <layout class="org.apache.log4j.PatternLayout"> <param name="ConversionPattern" value="%d{ABSOLUTE} %5p %t %c{1}:%M:%L - %m%n"/> </layout> </appender> <appender name="ASYNC" class="org.apache.log4j.AsyncAppender"> <param name="BufferSize" value="500"/> <appender-ref ref="fileAppender"/> </appender> <root> <priority value="info" /> <appender-ref ref="ASYNC"/> </root> </log4j:configuration>

4) परीक्षण स्वयं सरल लॉगिंग कॉल "रैंडम ऑपरेशन" (1 से 15 एमएस तक की अवधि, फ़ाइल को वैकल्पिक रूप से एक्सेस करने में सक्षम होने के लिए) के साथ इंटरप्रेट किए गए हैं।

स्रोत कोड का परीक्षण करें

 package com.ice.logger_test; import org.apache.commons.lang3.time.StopWatch; import org.apache.log4j.Logger; import java.util.Random; public class SimpleTest { private static Logger logger = Logger.getLogger(SimpleTest.class); private static double NANOS_TO_SEC = 1000000000.0d; private static String LOG_MESSAGE = "One hundred bytes log message for performing some tests using sync/async appenders of log4j library"; public static void main(String[] args) throws InterruptedException { //performTest("Single thread"); ThreadRunner t1 = new ThreadRunner(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); new Thread(t1).start(); } private static void performTest(String message) throws InterruptedException { logger.info("Warm-up..."); logger.info("Warm-up..."); logger.info("Warm-up..."); StopWatch timer = new StopWatch(); Random ran = new Random(); for(int i = 1; i <= 10000; i += getIncrementator(i)) { timer.reset(); timer.start(); int iterations = 0; for(int j = 1; j <= i; j++) { timer.suspend(); Thread.sleep(ran.nextInt(15)+1); // some work timer.resume(); logger.info(LOG_MESSAGE); timer.suspend(); Thread.sleep(ran.nextInt(15)+1); // some work timer.resume(); iterations = j; } timer.stop(); System.out.printf(message + " %d iteration(s) %f sec\n", iterations, (timer.getNanoTime() / NANOS_TO_SEC)); } } private static int getIncrementator(int i) { if(i >= 0 && i < 10) return 1; if(i >= 10 && i < 100) return 10; if(i >= 100 && i < 1000) return 100; if(i >= 1000 && i < 10000) return 1000; if(i >= 10000 && i <= 100000) return 10000; return 0; } static class ThreadRunner implements Runnable { @Override public void run() { try { performTest(Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } } } }

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

तुल्यकालिक शुरुआत, 2 धागे

पहले, आइए देखें कि लकड़हारा एक समकालिक विन्यास में कैसे व्यवहार करता है। 2 थ्रेड्स पर सभी स्क्रिप्ट चलाएँ।
यहाँ परिणाम हैं:

अतुल्यकालिक शुरुआत, 2 धागे

बफर = 500

अब एसिंक्रोनस मोड पर जाएं और उसी समय इष्टतम बफर खोजने की कोशिश करें, 500 से शुरू करें

बफर = 1500

बफ़र को 3 बार बढ़ाएं और समान परीक्षण करें:

बफर = 5000

चलो बफर को 10 गुना बढ़ाते हैं और एक ही परीक्षण करते हैं:

2 धागे के लिए कुल

अब स्पष्टता के लिए, मैं सभी अतुल्यकालिक (इष्टतम बफर को निर्धारित करने का प्रयास करने के लिए) और तुल्यकालिक (स्पष्टता के लिए, यह जीता गया दिलचस्प है) एक आरेख में परीक्षण एकत्र करेगा:

अब मुझे लगता है कि एसिंक्रोनस मोड में त्वरण स्पष्ट रूप से दिखाई देता है।
लेकिन निष्कर्ष निकालने से पहले, आइए 5 और 10 थ्रेड्स पर हमारे परीक्षण दोहराएं।

तुल्यकालिक शुरुआत, 5 धागे

अतुल्यकालिक शुरुआत, 5 धागे

बफर = 500

बफर = 1500

बफर = 5000

5 धागे के लिए कुल

तुल्यकालिक शुरुआत, 10 धागे

अतुल्यकालिक शुरुआत, 10 धागे

बफर = 500

बफर = 1500

बफर = 5000

10 धागे के लिए परिणाम

निष्कर्ष, जैसा कि वे कहते हैं, चेहरे पर।
चूंकि अब हम निश्चित रूप से लॉगिंग की अतुल्यकालिक विधि के लाभ के बारे में बात कर सकते हैं, तो आइए परीक्षणों की मात्रा 10 गुना बढ़ाने की कोशिश करें। 55,000 लॉगिंग इवेंट (1000 से 10000 से 1000 की वेतन वृद्धि में) के लिए एक परीक्षण जोड़ें। हम बफर को 500 के बराबर लेते हैं (क्योंकि यह पहली नज़र में है, और बाद में यह साबित हो जाएगा, हमारे परीक्षणों में सबसे इष्टतम है)।

तुल्यकालिक शुरुआत, डेटा के बड़े संस्करणों पर 10 धाराएं

अतुल्यकालिक शुरुआत, बड़ी मात्रा में डेटा पर 10 धागे

बड़ी मात्रा में डेटा पर 10 थ्रेड्स के लिए परिणाम

इष्टतम बफर

फिलहाल, हम पहले से ही काफी आंकड़े जमा कर चुके हैं, तो आइए उन सभी को औसत करें और देखें कि किस प्रकार का बफर सबसे उपयुक्त है।

2 धागे

5 धागे

10 धागे

10 थ्रेड्स, बड़ी मात्रा में परीक्षण

कुल - 500 घटनाओं , यह हमारा बफर है जो हमें अतुल्यकालिक मोड में सबसे कुशलता से काम करने की अनुमति देता है।
और अब यदि आप सभी परीक्षणों के कुल (या औसत) रनटाइम की तुलना भी करते हैं, तो आप एक स्थिर प्राप्त कर सकते हैं जो सिंक्रोनस से पहले अतुल्यकालिक मोड के जीतने का क्रम प्रदर्शित करता है, मेरे पास यह है - 8.9 (बार) ।

निष्कर्ष

उपरोक्त सामग्री यह स्पष्ट करती है कि अतुल्यकालिक लॉगिंग रणनीति एक प्रदर्शन लाभ देती है। फिर सवाल भीख माँगता है - हमेशा इसका उपयोग क्यों न करें? किसी विशेष विधि के पक्ष में एक विकल्प बनाने के लिए, आपको उन तंत्रों की कल्पना करने की आवश्यकता है जो अंदर छिपे हुए हैं। नीचे ऑफसाइट से कुछ सार लिया गया है:
1) AsyncAppender अपने स्वयं के थ्रेड से संचालित होता है (जबकि FileAppender स्वयं वर्तमान थ्रेड के संदर्भ में चलता है), इसलिए, इसका उपयोग करते समय, एप्लिकेशन सर्वर थ्रेड्स की सीमा को बढ़ाना वांछनीय है।
2) AsyncAppender का उपयोग करते समय, मेमोरी के लिए ओवरहेड होता है, क्योंकि लॉगिंग इवेंट्स को तुरंत फ़ाइल में डंप नहीं किया जाता है, लेकिन बफर भरने के बाद।
3) लॉग फ़ाइल का लॉक सिंक्रोनस दृष्टिकोण का उपयोग करते समय की तुलना में अधिक समय तक रहता है, क्योंकि संदेश बफर में रिकॉर्डिंग के लिए बहुत अधिक जानकारी होती है।
सिद्धांत रूप में, सब कुछ prosaic है, लेकिन यहां आपको यह समझने की आवश्यकता है कि सिंक्रोनाइज़ेशन स्वयं भी एक लॉक है, इसलिए इसे एक स्थान से दूसरे स्थान पर स्थानांतरित करना महत्वपूर्ण है, इससे यह बदतर नहीं होता है।

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

इस लेख का एक्सेल संस्करण:
docs.google.com/spreadsheet/ccc?key=0AkyN15vTZD-ddHV0Y3p4QVUxTXVZRldPcU0tNzNucWc&usp=sharing
docs.google.com/spreadsheet/ccc?key=0AkyN15vTZD-ddFhGakZsVWRjV1AxeGljdDczQjdNbnc&usp=sharing

आपका ध्यान देने के लिए धन्यवाद। मुझे उम्मीद है कि लेख आपके लिए उपयोगी होगा।
एक उत्पादक सप्ताह है!

Log4j 1.x तुल्यकालिक और अतुल्यकालिक मोड में प्रदर्शन

क्या कारण है?

समाधान क्या है?

माप

तुल्यकालिक शुरुआत, 2 धागे

अतुल्यकालिक शुरुआत, 2 धागे

बफर = 500

बफर = 1500

बफर = 5000

2 धागे के लिए कुल

तुल्यकालिक शुरुआत, 5 धागे

अतुल्यकालिक शुरुआत, 5 धागे

बफर = 500

बफर = 1500

बफर = 5000

5 धागे के लिए कुल

तुल्यकालिक शुरुआत, 10 धागे

अतुल्यकालिक शुरुआत, 10 धागे

बफर = 500

बफर = 1500

बफर = 5000

10 धागे के लिए परिणाम

तुल्यकालिक शुरुआत, डेटा के बड़े संस्करणों पर 10 धाराएं

अतुल्यकालिक शुरुआत, बड़ी मात्रा में डेटा पर 10 धागे

बड़ी मात्रा में डेटा पर 10 थ्रेड्स के लिए परिणाम

इष्टतम बफर

निष्कर्ष

More articles: