많은 작은 파일을 메모리에 읽는 가장 빠른 방법은 무엇입니까?
https://stackoverflow.com/questions/625420
-
05-07-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian문제
모든 서버 시작에서 ~ 50 파일을 읽고 각 텍스트 파일의 표현을 메모리에 배치해야합니다. 각 텍스트 파일에는 자체 문자열이 있습니다 (문자열 홀더에 사용하기에 가장 적합한 유형).
파일을 메모리로 읽는 가장 빠른 방법은 무엇이며, 메모리에서 조작 할 수 있도록 텍스트를 보유하는 최상의 데이터 구조/유형은 무엇입니까 (주로 검색 및 대체)?
감사
해결책
메모리 매핑 된 파일이 가장 빠릅니다 ... 이와 같은 것 :
final File file;
final FileChannel channel;
final MappedByteBuffer buffer;
file = new File(fileName);
fin = new FileInputStream(file);
channel = fin.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
그런 다음 바이트 버퍼에서 읽으십시오.
이것은보다 훨씬 빠릅니다 FileInputStream 또는 FileReader.
편집하다:
이것에 대해 약간의 조사를 한 후에는 OS에 따라 새로운 것을 사용하는 것이 좋습니다. BufferedInputStream(new FileInputStream(file)) 대신에. 그러나 모든 것을 한 번에 모두 읽는 것은 파일의 크기가 최악의 방식처럼 들립니다.
그래서 BufferedInputStream 모든 플랫폼에서 대략 일관된 성능을 제공해야하며 메모리 매핑 된 파일은 기본 OS에 따라 느리거나 빠를 수 있습니다. 성능이 중요한 모든 것과 마찬가지로 코드를 테스트하고 가장 잘 작동하는 것을 확인해야합니다.
편집하다:
OK 여기에 일부 테스트가 있습니다 (첫 번째 테스트는 파일을 디스크 캐시에 가져 오기 위해 두 번 수행됩니다).
하드 드라이브로 추출한 Rt.jar 클래스 파일에서 실행했습니다. 이것은 Windows 7 Beta X64 아래에 있습니다. 이는 총 94,706,637 바이트의 16784 파일입니다.
먼저 결과 ...
(첫 번째는 디스크 캐시 설정을 얻기 위해 반복되었음을 기억하십시오)
배열
- 시간 = 83016
- 바이트 = 118641472
배열
- 시간 = 46570
- 바이트 = 118641472
DatainputByTeAtAtime
- 시간 = 74735
- 바이트 = 118641472
datainputReadly
- 시간 = 8953
- 바이트 = 118641472
메모리 맵
- 시간 = 2320
- 바이트 = 118641472
여기 코드가 있습니다 ...
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashSet;
import java.util.Set;
public class Main
{
public static void main(final String[] argv)
{
ArrayTest.main(argv);
ArrayTest.main(argv);
DataInputByteAtATime.main(argv);
DataInputReadFully.main(argv);
MemoryMapped.main(argv);
}
}
abstract class Test
{
public final void run(final File root)
{
final Set<File> files;
final long size;
final long start;
final long end;
final long total;
files = new HashSet<File>();
getFiles(root, files);
start = System.currentTimeMillis();
size = readFiles(files);
end = System.currentTimeMillis();
total = end - start;
System.out.println(getClass().getName());
System.out.println("time = " + total);
System.out.println("bytes = " + size);
}
private void getFiles(final File dir,
final Set<File> files)
{
final File[] childeren;
childeren = dir.listFiles();
for(final File child : childeren)
{
if(child.isFile())
{
files.add(child);
}
else
{
getFiles(child, files);
}
}
}
private long readFiles(final Set<File> files)
{
long size;
size = 0;
for(final File file : files)
{
size += readFile(file);
}
return (size);
}
protected abstract long readFile(File file);
}
class ArrayTest
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new ArrayTest();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
InputStream stream;
stream = null;
try
{
final byte[] data;
int soFar;
int sum;
stream = new BufferedInputStream(new FileInputStream(file));
data = new byte[(int)file.length()];
soFar = 0;
do
{
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data)
{
sum += b;
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputByteAtATime
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputByteAtATime();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++)
{
sum += stream.readByte();
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadFully
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputReadFully();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final byte[] data;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
data = new byte[(int)file.length()];
stream.readFully(data);
sum = 0;
for(final byte b : data)
{
sum += b;
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadInChunks
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new DataInputReadInChunks();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
DataInputStream stream;
stream = null;
try
{
final byte[] data;
int size;
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
data = new byte[512];
size = 0;
sum = 0;
do
{
size += stream.read(data);
sum = 0;
for(int i = 0; i < size; i++)
{
sum += data[i];
}
}
while(size != fileSize);
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
class MemoryMapped
extends Test
{
public static void main(final String[] argv)
{
final Test test;
test = new MemoryMapped();
test.run(new File(argv[0]));
}
protected long readFile(final File file)
{
FileInputStream stream;
stream = null;
try
{
final FileChannel channel;
final MappedByteBuffer buffer;
final int fileSize;
int sum;
stream = new FileInputStream(file);
channel = stream.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++)
{
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex)
{
ex.printStackTrace();
}
finally
{
if(stream != null)
{
try
{
stream.close();
}
catch(final IOException ex)
{
ex.printStackTrace();
}
}
}
return (0);
}
}
다른 팁
가장 효율적인 방법은 다음과 같습니다.
- 파일의 길이를 결정합니다 (
File.length()) - 같은 크기 (또는 약간 더 큰)로 숯 버퍼를 만듭니다.
- 결정 부호화 파일의
- 사용
new InputStreamReader (new FileInputStream(file), encoding)읽다 - read ()을 위해 한 번의 호출로 버퍼에 whend 파일을 읽으십시오 (). read ()는 일찍 돌아올 수 있습니다 (전체 파일을 읽지 않음). 이 경우 다음 배치를 읽기 위해 오프셋으로 다시 호출하십시오.
- 문자열 만들기 :
new String(buffer)
시작시 검색 및 교체가 필요한 경우 String.replaceall ()을 사용하십시오.
반복적으로 수행 해야하는 경우 StringBuilder 사용을 고려할 수 있습니다. replaceall ()은 없지만이를 사용하여 문자 배열을 제자리에 조작 할 수 있습니다 (-> 메모리 할당 없음).
그 말 :
- 코드를 최대한 짧고 단순하게 만드십시오.
- 성능을 측정하십시오
- 너무 느립니다. 고치십시오.
이 코드가 실행하는 데 0.1 초만 걸리면 빠르게 실행하는 데 많은 시간을 낭비 할 이유가 없습니다.
여전히 성능 문제가있는 경우 모든 텍스트 파일을 항아리에 넣고 클래스 경로에 추가하고 클래스를 사용하여 파일을 읽으십시오. Java ClassPath에서 물건을로드하는 것은 최적화되어 있습니다.
그것은 당신의 텍스트 파일의 내부 구조와 당신이 그들과 함께하고자하는 것에 달려 있습니다.
파일 키 값 사전 (예 : "속성"파일)입니까? XML? JSON? 당신은 그것들을위한 표준 구조를 가지고 있습니다.
공식 구조가있는 경우 Javacc를 사용하여 파일의 객체 표현을 작성할 수도 있습니다.
그렇지 않으면, 그들이 단지 데이터의 덩어리라면, 파일을 읽고 문자열에 넣습니다.
편집하다: 검색 및 교체 사용 정보 문자열의 교체 기능.
Java의 IO 속도에 대한 기존 테스트를 Google에서 검색 한 후 Tofubear의 테스트 케이스가 내 눈을 완전히 열었다 고 말해야합니다. 가장 빠른 것이 무엇인지 확인하려면 자신의 플랫폼에서 테스트를 실행해야합니다.
테스트를 실행하고 내 자신의 몇 가지를 추가 한 후 (원래 코드를 게시하기위한 Tofubear에 크레딧), 자신의 사용자 정의 버퍼를 사용하여 BufferedInputStream을 사용하여 더 빠른 속도를 얻을 수 있습니다.
내 실망에 NIO 바이트 버퍼는 성능이 좋지 않았습니다.
참고 : 정적 바이트 [] 버퍼는 몇ms에서 면도되었지만 정적 바이트 버퍼는 실제로 처리 시간을 증가 시켰습니다! 코드에 문제가 있습니까 ??
몇 가지 테스트를 추가했습니다.
ArrayTest_Custombuffering (내 자신의 버퍼에 직접 데이터를 읽으십시오)
ArrayTest_custombuffering_staticBuffer (처음에 한 번만 생성되는 정적 버퍼로 데이터를 읽습니다)
FilechannelArrayByTeBuffer (NIO 바이트 버퍼 사용 및 자신의 바이트를 포장하여 [] 배열)
filechannelAllocateByTeBuffer (.allocate와 함께 NIO 바이트 버퍼 사용)
filechannelAllocateByTeBuffer_StaticBuffer (4와 동일하지만 정적 버퍼 포함)
FilechannelAllocatedirectByteBuffer (allocatedirect와 함께 NIO 바이트 버퍼 사용)
FilechannelAllocatedIrectByTeBuffer_StaticBuffer (6과 동일하지만 정적 버퍼가 있음)
내 결과는 다음과 같습니다. 추출 된 rt.jar : arraytest에서 Windows Vista 및 JDK1.6.0_13 사용
시간 = 2075
바이트 = 2120336424
배열
시간 = 2044
바이트 = 2120336424
ArrayTest_custombuffering
시간 = 1903
바이트 = 2120336424
ArrayTest_custombuffering_staticBuffer
시간 = 1872
바이트 = 2120336424
DatainputByTeAtAtime
시간 = 2668
바이트 = 2120336424
datainputReadly
시간 = 2028
바이트 = 2120336424
메모리 맵
시간 = 2901
바이트 = 2120336424
FilechannelArrayByTeBuffer
시간 = 2371
바이트 = 2120336424
filechannelAllocationByTeBuffer
시간 = 2356
바이트 = 2120336424
filechannelAllocateByTeBuffer_StaticBuffer
시간 = 2668
바이트 = 2120336424
FilechannelAllocatedIrectByTeBuffer
시간 = 2512
바이트 = 2120336424
FilechannelAllocatedIrectByTeBuffer_StaticBuffer
시간 = 2590
바이트 = 2120336424
Tofubear 코드의 해킹 된 버전 :
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.MappedByteBuffer;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.HashSet;
import java.util.Set;
public class Main {
public static void main(final String[] argv) {
ArrayTest.mainx(argv);
ArrayTest.mainx(argv);
ArrayTest_CustomBuffering.mainx(argv);
ArrayTest_CustomBuffering_StaticBuffer.mainx(argv);
DataInputByteAtATime.mainx(argv);
DataInputReadFully.mainx(argv);
MemoryMapped.mainx(argv);
FileChannelArrayByteBuffer.mainx(argv);
FileChannelAllocateByteBuffer.mainx(argv);
FileChannelAllocateByteBuffer_StaticBuffer.mainx(argv);
FileChannelAllocateDirectByteBuffer.mainx(argv);
FileChannelAllocateDirectByteBuffer_StaticBuffer.mainx(argv);
}
}
abstract class Test {
static final int BUFF_SIZE = 20971520;
static final byte[] StaticData = new byte[BUFF_SIZE];
static final ByteBuffer StaticBuffer =ByteBuffer.allocate(BUFF_SIZE);
static final ByteBuffer StaticDirectBuffer = ByteBuffer.allocateDirect(BUFF_SIZE);
public final void run(final File root) {
final Set<File> files;
final long size;
final long start;
final long end;
final long total;
files = new HashSet<File>();
getFiles(root, files);
start = System.currentTimeMillis();
size = readFiles(files);
end = System.currentTimeMillis();
total = end - start;
System.out.println(getClass().getName());
System.out.println("time = " + total);
System.out.println("bytes = " + size);
}
private void getFiles(final File dir,final Set<File> files) {
final File[] childeren;
childeren = dir.listFiles();
for(final File child : childeren) {
if(child.isFile()) {
files.add(child);
}
else {
getFiles(child, files);
}
}
}
private long readFiles(final Set<File> files) {
long size;
size = 0;
for(final File file : files) {
size += readFile(file);
}
return (size);
}
protected abstract long readFile(File file);
}
class ArrayTest extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
final byte[] data;
int soFar;
int sum;
stream = new BufferedInputStream(new FileInputStream(file));
data = new byte[(int)file.length()];
soFar = 0;
do {
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class ArrayTest_CustomBuffering extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest_CustomBuffering();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
final byte[] data;
int soFar;
int sum;
stream = new FileInputStream(file);
data = new byte[(int)file.length()];
soFar = 0;
do {
soFar += stream.read(data, soFar, data.length - soFar);
}
while(soFar != data.length);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class ArrayTest_CustomBuffering_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new ArrayTest_CustomBuffering_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
InputStream stream;
stream = null;
try {
int soFar;
int sum;
final int fileSize;
stream = new FileInputStream(file);
fileSize = (int)file.length();
soFar = 0;
do {
soFar += stream.read(StaticData, soFar, fileSize - soFar);
}
while(soFar != fileSize);
sum = 0;
for(int i=0;i<fileSize;i++) {
sum += StaticData[i];
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputByteAtATime extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputByteAtATime();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += stream.readByte();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadFully extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputReadFully();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final byte[] data;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
data = new byte[(int)file.length()];
stream.readFully(data);
sum = 0;
for(final byte b : data) {
sum += b;
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class DataInputReadInChunks extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new DataInputReadInChunks();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
DataInputStream stream;
stream = null;
try {
final byte[] data;
int size;
final int fileSize;
int sum;
stream = new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
fileSize = (int)file.length();
data = new byte[512];
size = 0;
sum = 0;
do {
size += stream.read(data);
sum = 0;
for(int i = 0;
i < size;
i++) {
sum += data[i];
}
}
while(size != fileSize);
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class MemoryMapped extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new MemoryMapped();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final FileChannel channel;
final MappedByteBuffer buffer;
final int fileSize;
int sum;
stream = new FileInputStream(file);
channel = stream.getChannel();
buffer = channel.map(MapMode.READ_ONLY, 0, file.length());
fileSize = (int)file.length();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelArrayByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelArrayByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
data = new byte[(int)file.length()];
buffer = ByteBuffer.wrap(data);
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
buffer = ByteBuffer.allocate((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateDirectByteBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateDirectByteBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
final ByteBuffer buffer;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
buffer = ByteBuffer.allocateDirect((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(buffer);
buffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += buffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateByteBuffer_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateByteBuffer_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
StaticBuffer.clear();
StaticBuffer.limit((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(StaticBuffer);
StaticBuffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += StaticBuffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
class FileChannelAllocateDirectByteBuffer_StaticBuffer extends Test {
public static void mainx(final String[] argv) {
final Test test;
test = new FileChannelAllocateDirectByteBuffer_StaticBuffer();
test.run(new File(argv[0]));
}
protected long readFile(final File file) {
FileInputStream stream;
stream = null;
try {
final byte[] data;
final FileChannel channel;
int nRead=0;
final int fileSize;
int sum;
stream = new FileInputStream(file);
//data = new byte[(int)file.length()];
StaticDirectBuffer.clear();
StaticDirectBuffer.limit((int)file.length());
channel = stream.getChannel();
fileSize = (int)file.length();
nRead += channel.read(StaticDirectBuffer);
StaticDirectBuffer.rewind();
sum = 0;
for(int i = 0; i < fileSize; i++) {
sum += StaticDirectBuffer.get();
}
return (sum);
}
catch(final IOException ex) {
ex.printStackTrace();
}
finally {
if(stream != null) {
try {
stream.close();
}
catch(final IOException ex) {
ex.printStackTrace();
}
}
}
return (0);
}
}
모든 기존의 접근 방식은 속도가 제한 될 것입니다. 나는 당신이 다음 접근법과 다음 접근 방식과 크게 차이를 볼지 확신하지 못합니다.
나는 전체 운영을 더 빨리 만들 수있는 비즈니스 트릭에 집중할 것입니다.
예를 들어, 모든 파일을 읽고 원래 파일 각각의 타임 스탬프와 함께 단일 파일에 저장되면 파일이 실제로 열리지 않고 변경되었는지 확인할 수 있습니다. (즉, 간단한 캐시).
문제가 GUI를 빠르게 끌어 올리면 첫 번째 화면이 표시된 후 배경 스레드에서 파일을 열 수있는 방법을 찾을 수 있습니다.
OS는 파일에 꽤 좋을 수 있습니다. 이것이 배치 프로세스 (사용자 I/O 없음)의 일부인 경우 다음과 같은 것을 사용하여 Java를 시작하기 전에 모든 파일을 하나의 큰 파일에 추가하는 배치 파일로 시작할 수 있습니다.
echo "file1" > file.all
type "file1" >> file.all
echo "file2" >> file.all
type "file2" >> file.all
그런 다음 파일을 열었습니다.
나는 단지 종종 속도 문제에 대한 솔루션이 종종 새로운 매개 변수를 사용하여 솔루션을 약간 확장하고 완전히 다시 생각해야한다고 말합니다. 기존 알고리즘의 수정은 일반적으로 가독성 비용으로 약간의 속도 향상 만 제공합니다.
Commons IO FileUtils.ReadFileToString (파일)과 같은 표준 도구를 사용하여 1 초 미만의 모든 파일을 읽을 수 있어야합니다.
WritestringTofile (파일, 문자열)을 사용하여 수정 된 파일도 저장할 수 있습니다.
http://commons.apache.org/io/api-release/index.html?org/apache/commons/io/fileutils.html
BTW : 50은 많은 파일이 아닙니다. 일반적인 PC에는 100k 파일 이상이있을 수 있습니다.
제휴하지 않습니다 StackOverflow
