मुझे अलग-अलग तरीकों से बेंचमार्क करना पड़ा। मैं अपने निष्कर्षों पर टिप्पणी करूंगा, लेकिन संक्षेप में, सबसे तेज़ तरीका एक FileInputstream पर एक सादे पुराने BufferedInputStream का उपयोग करना है। यदि कई फ़ाइलों को पढ़ा जाना चाहिए, तो तीन थ्रेड्स कुल निष्पादन समय को लगभग आधा कर देंगे, लेकिन अधिक थ्रेड जोड़ना उत्तरोत्तर नीचा दिखाना होगा, जब तक कि इसे केवल एक धागे की तुलना में बीस थ्रेड्स के साथ पूरा करने के लिए तीन गुना अधिक समय न हो।
धारणा यह है कि आपको एक फ़ाइल पढ़नी चाहिए और उसकी सामग्री के साथ कुछ सार्थक करना चाहिए। उदाहरणों में यहां एक लॉग से लाइनें पढ़ी जाती हैं और उन लोगों को गिनते हैं जिनमें ऐसे मान होते हैं जो एक निश्चित सीमा से अधिक होते हैं। इसलिए मैं मान रहा हूं कि वन-लाइनर जावा 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))एक विकल्प नहीं है।
मैंने जावा 1.8, विंडोज 7 और एसएसडी और एचडीडी दोनों ड्राइव पर परीक्षण किया।
मैंने छह अलग-अलग कार्यान्वयन लिखे:
rawParse : एक FileInputStream पर BufferedInputStream का उपयोग करें और फिर बाइट द्वारा पठन लाइनों को काटें। इसने किसी अन्य एकल-थ्रेड दृष्टिकोण को बेहतर बनाया, लेकिन यह गैर-एएससीआईआई फ़ाइलों के लिए बहुत असुविधाजनक हो सकता है।
lineReaderParse : एक FileReader पर एक बफ़र-राइडर का उपयोग करें, लाइन द्वारा लाइन पढ़ें, String.split () कॉल करके लाइनों को विभाजित करें। यह अनुमानित रूप से 20% धीमा है जो कच्चा है।
lineReaderParseParallel : यह lineReaderParse के समान है, लेकिन यह कई थ्रेड्स का उपयोग करता है। यह सभी मामलों में सबसे तेज विकल्प है।
nioFilesParse : java.nio.files.Files.lines () का उपयोग करें
nioAsyncParse : एक पूरा हैंडलर और एक थ्रेड पूल के साथ एक एसिंक्रोनस फ़ीलचैनलाइन का उपयोग करें।
nioMemoryMappedParse : मेमोरी-मैप की गई फ़ाइल का उपयोग करें। यह वास्तव में किसी भी अन्य कार्यान्वयन की तुलना में कम से कम तीन गुना अधिक समय के निष्पादन का समय लेने वाला एक बुरा विचार है।
क्वाड-कोर i7 और SSD ड्राइव पर प्रत्येक 4 एमबी की 204 फाइलें पढ़ने के लिए ये औसत समय हैं। डिस्क कैशिंग से बचने के लिए फ़ाइलें मक्खी पर उत्पन्न होती हैं।
rawParse 11.10 sec
lineReaderParse 13.86 sec
lineReaderParseParallel 6.00 sec
nioFilesParse 13.52 sec
nioAsyncParse 16.06 sec
nioMemoryMappedParse 37.68 sec
मुझे SSD या HDD ड्राइव पर SSD के लगभग 15% तेज गति से चलने के बीच एक अंतर मिला जो मैंने अपेक्षा से कम पाया। ऐसा इसलिए हो सकता है क्योंकि फाइलें एक अनियंत्रित एचडीडी पर उत्पन्न होती हैं और उन्हें क्रमिक रूप से पढ़ा जाता है, इसलिए कताई ड्राइव एसएसडी के रूप में लगभग प्रदर्शन कर सकता है।
मैं nioAsyncParse कार्यान्वयन के कम प्रदर्शन से हैरान था। या तो मैंने कुछ गलत तरीके से लागू किया है या NIO का उपयोग करके मल्टी-थ्रेड कार्यान्वयन और एक पूरा हैंडलर java.io एपीआई के साथ एकल-थ्रेड कार्यान्वयन की तुलना में एक ही (या इससे भी बदतर) करता है। इसके अलावा एसिंक्रोनस पार्स विथ अ कंप्लीशनहैंडलर पुरानी धाराओं पर सीधे क्रियान्वयन की तुलना में सही ढंग से लागू करने के लिए कोड और पेचीदा लाइनों में अधिक लंबा है।
अब छह कार्यान्वयन उन सभी को एक पैरामीरिजेबल मुख्य () पद्धति से युक्त एक वर्ग के बाद करते हैं जो फ़ाइलों की संख्या, फ़ाइल आकार और संगामिति डिग्री के साथ खेलने की अनुमति देता है। ध्यान दें कि फ़ाइलों का आकार प्लस माइनस 20% भिन्न होता है। यह सभी फाइलों के एक ही आकार के होने के कारण किसी भी प्रभाव से बचने के लिए है।
rawParse
public void rawParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
overrunCount = 0;
final int dl = (int) ';';
StringBuffer lineBuffer = new StringBuffer(1024);
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileInputStream fin = new FileInputStream(fl);
BufferedInputStream bin = new BufferedInputStream(fin);
int character;
while((character=bin.read())!=-1) {
if (character==dl) {
// Here is where something is done with each line
doSomethingWithRawLine(lineBuffer.toString());
lineBuffer.setLength(0);
}
else {
lineBuffer.append((char) character);
}
}
bin.close();
fin.close();
}
}
public final void doSomethingWithRawLine(String line) throws ParseException {
// What to do for each line
int fieldNumber = 0;
final int len = line.length();
StringBuffer fieldBuffer = new StringBuffer(256);
for (int charPos=0; charPos<len; charPos++) {
char c = line.charAt(charPos);
if (c==DL0) {
String fieldValue = fieldBuffer.toString();
if (fieldValue.length()>0) {
switch (fieldNumber) {
case 0:
Date dt = fmt.parse(fieldValue);
fieldNumber++;
break;
case 1:
double d = Double.parseDouble(fieldValue);
fieldNumber++;
break;
case 2:
int t = Integer.parseInt(fieldValue);
fieldNumber++;
break;
case 3:
if (fieldValue.equals("overrun"))
overrunCount++;
break;
}
}
fieldBuffer.setLength(0);
}
else {
fieldBuffer.append(c);
}
}
}
lineReaderParse
public void lineReaderParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
String line;
for (int f=0; f<numberOfFiles; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null)
doSomethingWithLine(line);
brd.close();
frd.close();
}
}
public final void doSomethingWithLine(String line) throws ParseException {
// Example of what to do for each line
String[] fields = line.split(";");
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
lineReaderParseParallel
public void lineReaderParseParallel(final String targetDir, final int numberOfFiles, final int degreeOfParalelism) throws IOException, ParseException, InterruptedException {
Thread[] pool = new Thread[degreeOfParalelism];
int batchSize = numberOfFiles / degreeOfParalelism;
for (int b=0; b<degreeOfParalelism; b++) {
pool[b] = new LineReaderParseThread(targetDir, b*batchSize, b*batchSize+b*batchSize);
pool[b].start();
}
for (int b=0; b<degreeOfParalelism; b++)
pool[b].join();
}
class LineReaderParseThread extends Thread {
private String targetDir;
private int fileFrom;
private int fileTo;
private DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
private int overrunCounter = 0;
public LineReaderParseThread(String targetDir, int fileFrom, int fileTo) {
this.targetDir = targetDir;
this.fileFrom = fileFrom;
this.fileTo = fileTo;
}
private void doSomethingWithTheLine(String line) throws ParseException {
String[] fields = line.split(DL);
Date dt = fmt.parse(fields[0]);
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCounter++;
}
@Override
public void run() {
String line;
for (int f=fileFrom; f<fileTo; f++) {
File fl = new File(targetDir+filenamePreffix+String.valueOf(f)+".txt");
try {
FileReader frd = new FileReader(fl);
BufferedReader brd = new BufferedReader(frd);
while ((line=brd.readLine())!=null) {
doSomethingWithTheLine(line);
}
brd.close();
frd.close();
} catch (IOException | ParseException ioe) { }
}
}
}
nioFilesParse
public void nioFilesParse(final String targetDir, final int numberOfFiles) throws IOException, ParseException {
for (int f=0; f<numberOfFiles; f++) {
Path ph = Paths.get(targetDir+filenamePreffix+String.valueOf(f)+".txt");
Consumer<String> action = new LineConsumer();
Stream<String> lines = Files.lines(ph);
lines.forEach(action);
lines.close();
}
}
class LineConsumer implements Consumer<String> {
@Override
public void accept(String line) {
// What to do for each line
String[] fields = line.split(DL);
if (fields.length>1) {
try {
Date dt = fmt.parse(fields[0]);
}
catch (ParseException e) {
}
double d = Double.parseDouble(fields[1]);
int t = Integer.parseInt(fields[2]);
if (fields[3].equals("overrun"))
overrunCount++;
}
}
}
nioAsyncParse
public void nioAsyncParse(final String targetDir, final int numberOfFiles, final int numberOfThreads, final int bufferSize) throws IOException, ParseException, InterruptedException {
ScheduledThreadPoolExecutor pool = new ScheduledThreadPoolExecutor(numberOfThreads);
ConcurrentLinkedQueue<ByteBuffer> byteBuffers = new ConcurrentLinkedQueue<ByteBuffer>();
for (int b=0; b<numberOfThreads; b++)
byteBuffers.add(ByteBuffer.allocate(bufferSize));
for (int f=0; f<numberOfFiles; f++) {
consumerThreads.acquire();
String fileName = targetDir+filenamePreffix+String.valueOf(f)+".txt";
AsynchronousFileChannel channel = AsynchronousFileChannel.open(Paths.get(fileName), EnumSet.of(StandardOpenOption.READ), pool);
BufferConsumer consumer = new BufferConsumer(byteBuffers, fileName, bufferSize);
channel.read(consumer.buffer(), 0l, channel, consumer);
}
consumerThreads.acquire(numberOfThreads);
}
class BufferConsumer implements CompletionHandler<Integer, AsynchronousFileChannel> {
private ConcurrentLinkedQueue<ByteBuffer> buffers;
private ByteBuffer bytes;
private String file;
private StringBuffer chars;
private int limit;
private long position;
private DateFormat frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
public BufferConsumer(ConcurrentLinkedQueue<ByteBuffer> byteBuffers, String fileName, int bufferSize) {
buffers = byteBuffers;
bytes = buffers.poll();
if (bytes==null)
bytes = ByteBuffer.allocate(bufferSize);
file = fileName;
chars = new StringBuffer(bufferSize);
frmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
limit = bufferSize;
position = 0l;
}
public ByteBuffer buffer() {
return bytes;
}
@Override
public synchronized void completed(Integer result, AsynchronousFileChannel channel) {
if (result!=-1) {
bytes.flip();
final int len = bytes.limit();
int i = 0;
try {
for (i = 0; i < len; i++) {
byte by = bytes.get();
if (by=='\n') {
// ***
// The code used to process the line goes here
chars.setLength(0);
}
else {
chars.append((char) by);
}
}
}
catch (Exception x) {
System.out.println(
"Caught exception " + x.getClass().getName() + " " + x.getMessage() +
" i=" + String.valueOf(i) + ", limit=" + String.valueOf(len) +
", position="+String.valueOf(position));
}
if (len==limit) {
bytes.clear();
position += len;
channel.read(bytes, position, channel, this);
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
else {
try {
channel.close();
}
catch (IOException e) {
}
consumerThreads.release();
bytes.clear();
buffers.add(bytes);
}
}
@Override
public void failed(Throwable e, AsynchronousFileChannel channel) {
}
};
सभी मामलों के पूर्ण परिवर्तनीय कार्यान्वयन
https://github.com/sergiomt/javaiobenchmark/blob/master/FileReadBenchmark.java