java प्रिंटिंग "बी" प्रिंटिंग की तुलना में नाटकीय रूप से धीमी क्यों है?




performance loops (2)

मैंने 1000 x 1000 दो मैट्रिक्स उत्पन्न किए:

पहला मैट्रिक्स: O और #
दूसरा मैट्रिक्स: O और B

निम्नलिखित कोड का उपयोग करके, पहले मैट्रिक्स को पूरा करने के लिए 8.52 सेकंड लग गए:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("#");
        }
    }

   System.out.println("");
 }

इस कोड के साथ, दूसरे मैट्रिक्स को पूरा करने के लिए 25 9 .152 सेकंड लग गए:

Random r = new Random();
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 1000; j++) {
        if(r.nextInt(4) == 0) {
            System.out.print("O");
        } else {
            System.out.print("B"); //only line changed
        }
    }

    System.out.println("");
}

नाटकीय रूप से अलग रन समय के पीछे क्या कारण है?

टिप्पणियों में सुझाव दिया गया है, केवल System.out.print("#"); प्रिंटिंग System.out.print("#"); 7.8871 सेकंड लेता है, जबकि System.out.print("B"); still printing... देता है still printing...

जैसा कि अन्य ने इंगित किया कि यह सामान्य रूप से उनके लिए काम करता है, उदाहरण के लिए मैंने Ideone.com को आजमाया, और कोड के दोनों टुकड़े एक ही गति से निष्पादित होते हैं।

परीक्षण की स्थितियाँ:

  • मैंने नेटबैंस 7.2 से इस परीक्षण को अपने कंसोल में आउटपुट के साथ चलाया
  • मैंने माप के लिए System.nanoTime() उपयोग किया

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

लेकिन यह शुद्ध अटकलें है।


मैंने एक्सेलिप बनाम नेटबीन्स 8.0.2 पर परीक्षण किया, दोनों जावा संस्करण 1.8 के साथ; मैंने माप के लिए System.nanoTime() उपयोग किया।

ग्रहण:

मुझे दोनों मामलों में एक ही समय मिला - लगभग 1.564 सेकंड

NetBeans:

  • "#" का प्रयोग करना: 1.536 सेकेंड
  • "बी" का प्रयोग: 44.164 सेकेंड

तो, ऐसा लगता है कि नेटबीन के प्रिंट पर कंसोल पर खराब प्रदर्शन है।

अधिक शोध के बाद मुझे एहसास हुआ कि समस्या Netbeans के अधिकतम बफर की line-wrapping है (यह System.out.println कमांड तक सीमित नहीं है), इस कोड द्वारा प्रदर्शित:

for (int i = 0; i < 1000; i++) {
    long t1 = System.nanoTime();
    System.out.print("BBB......BBB"); \\<-contain 1000 "B"
    long t2 = System.nanoTime();
    System.out.println(t2-t1);
    System.out.println("");
}

समय के परिणाम हर पांचवें पुनरावृत्ति को छोड़कर प्रत्येक पुनरावृत्ति के बाद 1 मिलीसेकंड कम होते हैं, जब समय का परिणाम लगभग 225 मिलीसेकंड होता है। कुछ ऐसा (नैनोसेकंड में):

BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
BBB...31744
BBB...31744
BBB...31744
BBB...31744
BBB...226365807
.
.
.

और इसी तरह..

सारांश:

  1. ग्रहण पूरी तरह से "बी" के साथ काम करता है
  2. नेटबीन्स में एक लाइन-रैपिंग समस्या होती है जिसे हल किया जा सकता है (क्योंकि समस्या ग्रहण में नहीं होती है) (बी ("बी") के बाद जगह जोड़ने के बिना)।




system.out