एक फ़ाइल के समवर्ती पढ़ने (जावा preffered)

Question

मेरे पास एक बड़ी फाइल है जो प्रक्रिया के लिए कई घंटे लगती है। तो मैं भाग का अनुमान लगाने और समानांतर में भाग पढ़ने की कोशिश करने के बारे में सोच रहा हूं। क्या एक फ़ाइल पर समवर्ती पढ़ना संभव है? मैंने RandomAccessFile के साथ-साथ nio.FileChannel दोनों को देखा है लेकिन अन्य पोस्टों के आधार पर यह सुनिश्चित नहीं है कि यह दृष्टिकोण काम करेगा या नहीं। सुझाव !!

Answer 1

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

अब यदि यह प्रसंस्करण समय लेता है, तो इससे डेटा के अलग-अलग हिस्सों को संसाधित करने वाले कई धागे होने से लाभ हो सकता है, लेकिन इसका कोई संबंध नहीं है कि आप फ़ाइल को कैसे पढ़ रहे हैं।

Answer 2

आप एक बड़ी फ़ाइल पढ़ने के समानांतर कर सकते हैं बशर्ते आपके पास कई स्वतंत्र स्पिंडल हों। जैसे यदि आपके पास RAID 0 + 1 स्ट्रिपेड फ़ाइल सिस्टम है, तो आप एक ही फ़ाइल में एकाधिक समवर्ती पढ़ने को ट्रिगर करके प्रदर्शन सुधार देख सकते हैं।

यदि आपके पास RAID 5 या 6 या सादा एकल डिस्क जैसी संयुक्त फ़ाइल सिस्टम है। यह अत्यधिक संभावना है कि फ़ाइल को क्रमशः पढ़ने से उस डिस्क से पढ़ने का सबसे तेज़ तरीका है। नोट: ओएस पढ़ने के लिए पर्याप्त स्मार्ट है जब यह देखता है कि आप अनुक्रमिक रूप से पढ़ रहे हैं तो ऐसा करने के लिए अतिरिक्त थ्रेड का उपयोग करने में मदद करने की संभावना नहीं है।

यानी एकाधिक धागे का उपयोग करके आप डिस्क को तेज़ी से नहीं बना पाएंगे।

यदि आप डिस्क से तेज़ी से पढ़ना चाहते हैं, तो एक तेज ड्राइव का उपयोग करें। एक सामान्य सैटा एचडीडी लगभग 60 एमबी/सेकेंड पढ़ सकता है और 120 आईओपीएस प्रदर्शन कर सकता है। एक सामान्य सैटा एसएसडी ड्राइव लगभग 400 एमबी/एस पर पढ़ सकती है और 80,000 आईओपीएस कर सकती है और एक सामान्य पीसीआई एसएसडी 900 एमबी/एस पर पढ़ सकता है और 230,000 आईओपीएस प्रदर्शन कर सकता है।

Answer 3

आप समानांतर में संसाधित कर सकते हैं, हालांकि आपकी हार्ड ड्राइव एक समय में डेटा का एक टुकड़ा पढ़ सकती है। यदि आप एक थ्रेड के साथ फ़ाइल में पढ़ते हैं, तो आप डेटा को कई धागे से संसाधित कर सकते हैं।

Answer 4

सबसे महत्वपूर्ण सवाल यहां है आपके मामले में में बाधा क्या है।

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

टोंटी प्रसंस्करण शक्ति है, और आप कई सीपीयू कोर है, तो आप फ़ाइल के विभिन्न भागों पर काम करने के लिए एक से अधिक थ्रेड शुरू करने का एक लाभ ले सकते हैं। फ़ाइल के विभिन्न हिस्सों को समानांतर में पढ़ने के लिए आप सुरक्षित रूप से कई InputStream s या Reader s बना सकते हैं (जब तक आप खुली फ़ाइलों की संख्या के लिए अपने ऑपरेटिंग सिस्टम की सीमा पर नहीं जाते)। आप काम को कार्यों में अलग कर सकते हैं और उन्हें समानांतर में चला सकते हैं, जैसे कि इस उदाहरण में:

import java.io.*; 
import java.util.*; 
import java.util.concurrent.*; 

public class Split { 
    private File file; 

    public Split(File file) { 
     this.file = file; 
    } 

    // Processes the given portion of the file. 
    // Called simultaneously from several threads. 
    // Use your custom return type as needed, I used String just to give an example. 
    public String processPart(long start, long end) 
     throws Exception 
    { 
     InputStream is = new FileInputStream(file); 
     is.skip(start); 
     // do a computation using the input stream, 
     // checking that we don't read more than (end-start) bytes 
     System.out.println("Computing the part from " + start + " to " + end); 
     Thread.sleep(1000); 
     System.out.println("Finished the part from " + start + " to " + end); 

     is.close(); 
     return "Some result"; 
    } 

    // Creates a task that will process the given portion of the file, 
    // when executed. 
    public Callable<String> processPartTask(final long start, final long end) { 
     return new Callable<String>() { 
      public String call() 
       throws Exception 
      { 
       return processPart(start, end); 
      } 
     }; 
    } 

    // Splits the computation into chunks of the given size, 
    // creates appropriate tasks and runs them using a 
    // given number of threads. 
    public void processAll(int noOfThreads, int chunkSize) 
     throws Exception 
    { 
     int count = (int)((file.length() + chunkSize - 1)/chunkSize); 
     java.util.List<Callable<String>> tasks = new ArrayList<Callable<String>>(count); 
     for(int i = 0; i < count; i++) 
      tasks.add(processPartTask(i * chunkSize, Math.min(file.length(), (i+1) * chunkSize))); 
     ExecutorService es = Executors.newFixedThreadPool(noOfThreads); 

     java.util.List<Future<String>> results = es.invokeAll(tasks); 
     es.shutdown(); 

     // use the results for something 
     for(Future<String> result : results) 
      System.out.println(result.get()); 
    } 

    public static void main(String argv[]) 
     throws Exception 
    { 
     Split s = new Split(new File(argv[0])); 
     s.processAll(8, 1000); 
    } 
}