මට විවිධ ක්‍රම මිණුම් සලකුණු කිරීමට සිදු විය. මගේ සොයාගැනීම් ගැන මම අදහස් දක්වන්නෙමි, නමුත් කෙටියෙන් කිවහොත්, වේගවත්ම ක්‍රමය වන්නේ ෆයිල් ඉන්පුට්ස්ට්රීම් හරහා පැරණි පැරණි බෆර්ඩ් ඉන්පුට්ස්ට්රීම් භාවිතා කිරීමයි. බොහෝ ලිපිගොනු කියවිය යුතු නම්, නූල් තුනක් මඟින් සම්පූර්ණ ක්‍රියාත්මක කිරීමේ කාලය දළ වශයෙන් අඩක් දක්වා අඩු කරනු ඇත, නමුත් තවත් නූල් එකතු කිරීමෙන් එක් නූල් එකකට වඩා නූල් විස්සකින් සම්පූර්ණ කිරීමට තුන් ගුණයක් ගත වන තෙක් ක්‍රමානුකූලව කාර්ය සාධනය පිරිහී යනු ඇත.
උපකල්පනය නම් ඔබ ගොනුවක් කියවා එහි අන්තර්ගතය සමඟ අර්ථවත් යමක් කළ යුතු බවයි. මෙහි නිදසුන් වල දැක්වෙන්නේ ලොගයකින් රේඛා කියවීම සහ යම් සීමාවක් ඉක්මවා යන අගයන් අඩංගු ඒවා ගණන් කිරීමයි. එබැවින් මම සිතන්නේ එක්-ලයිනර් ජාවා 8 Files.lines(Paths.get("/path/to/file.txt")).map(line -> line.split(";"))විකල්පයක් නොවන බවයි.
මම ජාවා 1.8, වින්ඩෝස් 7 සහ එස්එස්ඩී සහ එච්ඩීඩී ඩ්‍රයිව් දෙකෙහිම අත්හදා බැලුවෙමි.
මම වෙනස් ක්‍රියාත්මක කිරීම් හයක් ලිව්වා:
rawParse : FileInputStream හරහා BufferedInputStream භාවිතා කර බයිට් වලින් කියවන රේඛා කපන්න. මෙය වෙනත් ඕනෑම තනි නූල් ප්‍රවේශයක් අභිබවා ගිය නමුත් ASCII නොවන ලිපිගොනු සඳහා එය ඉතා අපහසු විය හැකිය.
lineReaderParse : FileReader හරහා බෆර්ඩ් රීඩරයක් භාවිතා කරන්න, පේළියෙන් රේඛාව කියවන්න, String.split () ඇමතීමෙන් රේඛා බෙදන්න. මෙය දළ වශයෙන් 20% ක් මන්දගාමී වේ.
lineReaderParseParallel : මෙය lineReaderParse හා සමාන වේ, නමුත් එය නූල් කිහිපයක් භාවිතා කරයි. සමස්තයක් ලෙස ගත් විට වේගවත්ම විකල්පය මෙයයි.
nioFilesParse : java.nio.files.Files.lines () භාවිතා කරන්න
nioAsyncParse : සම්පුර්ණ හසුරුවන්නෙකු සහ නූල් තටාකයක් සහිත අසමමුහුර්ත ෆයිල් චැනලයක් භාවිතා කරන්න.
nioMemoryMappedParse : මතක සිතියම් ගත ගොනුවක් භාවිතා කරන්න. මෙය සැබවින්ම නරක අදහසකි, වෙනත් ඕනෑම ක්‍රියාත්මක කිරීමකට වඩා අවම වශයෙන් තුන් ගුණයක් දිගු කාලයක් ක්‍රියාත්මක කිරීමේ කාලය ලබා දෙයි.
Quad-core i7 සහ SSD ධාවකය මත 4 MB බැගින් ලිපිගොනු 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
එස්එස්ඩී එකක් හෝ එච්ඩීඩී ඩ්‍රයිව් එකක් ධාවනය කිරීම අතර මා බලාපොරොත්තු වූවාට වඩා කුඩා වෙනසක් මට හමු විය. මෙයට හේතුව විය හැක්කේ ලිපිගොනු සකස් නොකළ HDD මත වන අතර ඒවා අනුපිළිවෙලින් කියවනු ලැබේ, එබැවින් භ්‍රමණය වන ධාවකය SSD ලෙස ක්‍රියා කළ හැකිය.
NioAsyncParse ක්‍රියාත්මක කිරීමේ අඩු ක්‍රියාකාරිත්වය ගැන මා පුදුමයට පත් විය. එක්කෝ මම වැරදි ආකාරයකින් යමක් ක්‍රියාවට නංවා හෝ NIO භාවිතා කරමින් බහු-නූල් ක්‍රියාත්මක කිරීම සහ සම්පුර්ණ හසුරුවන්නා java.io API සමඟ තනි නූල් ක්‍රියාත්මක කිරීමට වඩා සමාන (හෝ ඊටත් වඩා නරක) සිදු කරයි. තවද, සම්පුර්ණ හැන්ඩ්ලර් සමඟ ඇති අසමමුහුර්ත විග්‍රහය පැරණි ධාරාවන්හි සෘජුවම ක්‍රියාත්මක කිරීමට වඩා නිවැරදිව ක්‍රියාත්මක කිරීමට කේත රේඛා හා උපක්‍රමශීලී වේ.
දැන් ක්‍රියාත්මක කිරීම් හයෙන් පසුව ඒවා සියල්ලම අඩංගු පන්තියක් සහ පරාමිතිකකරණය කළ හැකි ප්‍රධාන () ක්‍රමයක් වන අතර එමඟින් ගොනු ගණන, ගොනු ප්‍රමාණය සහ සමගාමී උපාධිය සමඟ සෙල්ලම් කිරීමට ඉඩ ලබා දේ. ලිපිගොනු වල ප්‍රමාණය us ණ 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