एक बार में एकल बाइट बनाम कई पढ़ते समय प्रदर्शन?

Question

मैं प्रदर्शन के संदर्भ में InputStream.read() बनाम InputStream.read(byte[] b) की तुलना करने की कोशिश कर रहा हूं।

InputStream.read(byte[] b) किसी भी तरह से तेजी से read(b, off, len) कक्षा InputStream के लिए विधि को विधि read() बार-बार विधि कहता है?

Answer 1

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

इनपुटस्ट्रीम से - पढ़ें (बाइट []) कॉल बार-बार पढ़ते हैं।

public int read(byte b[], int off, int len) throws IOException { 
    // code removed 

     for (; i < len ; i++) { 
      c = read(); 

    // code removed 
} 

BufferedInputStream से - पढ़ें (बाइट []) पढ़ा नहीं जाता है()।

public synchronized int read(byte b[], int off, int len) throws IOException { 
    // code removed 
     int nread = read1(b, off + n, len - n); 
    // code removed 
} 

private int read1(byte[] b, int off, int len) throws IOException { 
    // code removed 
      return getInIfOpen().read(b, off, len); 
    // code removed 
} 

FileInputStream से - पढ़ें (बाइट []) को पढ़ने के फोन नहीं करता है()।

public int read(byte b[], int off, int len) throws IOException { 
    return readBytes(b, off, len); 
} 

private native int readBytes(byte b[], int off, int len) throws IOException; 

InputStream अंतर्निहित धारा में एक ही विधि के लिए एक समय में एक बाइट, लगभग सभी कार्यान्वयन पढ़ पारित करेंगे (बाइट []) पढ़ा जाएगा।

नोट: पढ़ने के लिए कार्यान्वयन (बाइट [], int, int) तीनों मामलों में अलग हैं।

मेरा मतलब अधिक स्पष्ट रूप से पूछना है: मान लीजिए कि मैं 20 बाइट्स पढ़ना चाहता हूं, एक बार में एक बाइट पढ़ना लूप में हर बार अंतर्निहित धारा (जैसे फ़ाइल सिस्टम) को मार देगा जिसका मतलब 20 गुना है .. ठीक है अब एक बार में 20 बाइट्स की सरणी पढ़ना, यानी पढ़ना (बाइट [] 20) का उपयोग करना, अब वह अंतर्निहित धारा (जैसे फाइल सिस्टम) को एक बार या 20 बार मारा जाएगा .. ?? (जैसा कि यह दिया गया है: पढ़ें (बाइट [] बी) विधि विधि को पढ़ने के लिए भी जा रही है() बार-बार 20 बार) ??

चाहे आप BufferedInputStream या FileInputStream का उपयोग करते हैं, एक पढ़ा (बाइट []) परिणाम बाइट [] में पढ़ने के लिए लगभग एक सिस्टम कॉल में परिणाम देता है।

Answer 2

जो भी आपको अपने मामले में सबसे सुविधाजनक लगता है उसका उपयोग करें, लेकिन के साथ अपने InputStream को लपेटना याद रखें।

एकल read() बफर किए बिना प्रत्येक बार जब आप पढ़ते हैं तो अंतर्निहित धारा (जैसे फ़ाइल सिस्टम) दबाएंगे। बफरिंग के साथ read() एक खंड (उदा। 4KiB) लोड करता है और इसे बफर करता है। जाहिर है डिस्क से पढ़ना (भले ही कुछ लोअर-लीवर ओएस/हार्ड डिस्क कैशिंग मौजूद है) बहुत धीमी है।

इसलिए read(byte[] b) केवल तभी बेहतर होता है जब आपकी स्ट्रीम बफर्ड न हो - या यदि आप वास्तव में एक से अधिक बाइट पढ़ना चाहते हैं।