আমাকে বিভিন্নভাবে বেনমার্ক করতে হয়েছিল। আমি আমার অনুসন্ধানগুলিতে মন্তব্য করব তবে সংক্ষেপে, সবচেয়ে দ্রুততম উপায় হল একটি ফাইলআইপুট স্ট্রিমের মাধ্যমে একটি সরল পুরাতন বাফারডাইনপুট স্ট্রিম ব্যবহার করা। যদি অনেকগুলি ফাইল অবশ্যই পড়তে হয় তবে তিনটি থ্রেড মোট কার্যকরকরণের সময়কে প্রায় অর্ধেকে কমিয়ে দেবে, তবে আরও থ্রেড যুক্ত করা ক্রমশ কর্মক্ষমতা হ্রাস করবে যতক্ষণ না এটি কেবল একটি থ্রেডের চেয়ে বিশ থ্রেডের সাথে শেষ হতে তিনগুণ বেশি সময় নেয়।
অনুমানটি হ'ল আপনাকে অবশ্যই একটি ফাইল পড়তে হবে এবং এর বিষয়বস্তুগুলির সাথে অর্থপূর্ণ কিছু করতে হবে। এখানে উদাহরণগুলিতে একটি লগ থেকে লাইনগুলি পড়া এবং একটি নির্দিষ্ট প্রান্তিকের বেশি হওয়া মানগুলিকে গণনা করা হয়। সুতরাং আমি ধরে নিচ্ছি যে ওয়ান-লাইনার জাভা 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))কোনও বিকল্প নয়।
আমি জাভা 1.8, উইন্ডোজ 7 এবং এসএসডি এবং এইচডিডি ড্রাইভ উভয়ই পরীক্ষা করেছিলাম।
আমি ছয়টি পৃথক বাস্তবায়ন লিখেছি:
কাঁচা পার্স : একটি ফাইলআইপুট স্ট্রিমের উপরে বাফারডিনপুট স্ট্রিম ব্যবহার করুন এবং তারপরে বাইট দ্বারা পাঠ্য লাইনগুলি কেটে দিন। এটি অন্য কোনও একক থ্রেড পদ্ধতির চেয়ে বেশি কার্যকর হয়েছে তবে এটি ASCII নন ফাইলের জন্য খুব অসুবিধাগ্রস্থ হতে পারে।
LineReaderParse : একটি ফাইলরেডার উপর একটি বাফারড্রিডার ব্যবহার করুন, স্ট্রিং.স্প্লিট () কল করে লাইন দ্বারা রেখা, বিভক্ত লাইন পড়ুন। এটি কাঁচা পার্সের আনুমানিক 20% ধীর।
লাইনরেডারপারসপ্যারালাল : এটি লাইনরেডারপার্সের সমান, তবে এটি বেশ কয়েকটি থ্রেড ব্যবহার করে। এটি সব ক্ষেত্রেই দ্রুততম বিকল্প।
nioFilesParse : java.nio.files.Files.lines ব্যবহার করুন ()
nioAsyncParse : একটি সমাপ্তি হ্যান্ডলার এবং একটি থ্রেড পুল সহ একটি অ্যাসিনক্রোনাসফিল চ্যানেল ব্যবহার করুন।
nioMemoryMappedParse : একটি মেমরি- ম্যাপযুক্ত ফাইল ব্যবহার করুন। অন্য বাস্তবায়নের চেয়ে কমপক্ষে তিনগুণ বেশি সময় কার্যকর করার ফলস্বরূপ এটি একটি খারাপ ধারণা।
কোয়াড-কোর আই 7 এবং এসএসডি ড্রাইভে প্রতিটি 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
এসএসডি বা একটি এইচডিডি ড্রাইভের এসএসডি হয়ে প্রায় 15% দ্রুত গতিতে চলার মধ্যে আমার যে প্রত্যাশা ছিল তার চেয়ে কম পার্থক্য পেয়েছি। এটি হতে পারে কারণ ফাইলগুলি একটি অবিবাহিত এইচডিডি-তে উত্পন্ন এবং সেগুলি যথাক্রমে পড়া হয়, সুতরাং স্পিনিং ড্রাইভটি প্রায় এসএসডি হিসাবে সম্পাদন করতে পারে।
NioAsyncParse বাস্তবায়নের নিম্ন ਪ੍ਰਦਰਸ਼ਨ দ্বারা আমি অবাক হয়েছি। হয় আমি ভুল উপায়ে কিছু প্রয়োগ করেছি বা এনআইও ব্যবহার করে মাল্টি-থ্রেড প্রয়োগকরণ এবং একটি পরিসমাপ্তি হ্যান্ডলার জাভা.আইপিআইপি দিয়ে একক থ্রেড প্রয়োগের চেয়ে একই (বা আরও খারাপ) সম্পাদন করে। তবুও কমপ্লিটহ্যান্ডলার সহ অ্যাসিঙ্ক্রোনাস পার্স পুরানো স্ট্রিমগুলির উপর সরাসরি প্রয়োগের চেয়ে সঠিকভাবে প্রয়োগ করার কোডের লাইনে অনেক বেশি দীর্ঘ এবং জটিল।
এখন ছয়টি বাস্তবায়নের পরে একটি শ্রেণি রয়েছে যার মধ্যে রয়েছে সেগুলি একটি প্লাস একটি প্যারামিট্রাইজেবল মেইন () পদ্ধতি যা ফাইলের সংখ্যা, ফাইলের আকার এবং সম্মতি ডিগ্রি নিয়ে খেলতে দেয়। নোট করুন যে ফাইলগুলির আকারের সাথে মাইনাস 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