IO 기본 1

참고자료

김영한의 실전 자바 - 고급 2편, I/O, 네트워크, 리플렉션 강의 | 김영한 - 인프런

 

Stream 시작

 

자바가 가진 데이터를 `hello.dat`라는 파일에 저장하려면 어떻게 해야할까?

자바 프로세스가 가지고 있는 데이터를 밖으로 보내려면 출력 스트림을 사용하면 되고, 반대로 외부 데이터를 자바 프로세스 안으로 가져오려면 입력 스트림을 사용하면 된다. 참고로 각 스트림은 단방향으로만 흐른다.

 

예제 코드를 통해 확인해보자.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamStartMain1 {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");

        fos.write(65);
        fos.write(66);
        fos.write(67);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
        System.out.println(fis.read());
    }
}

• 실행전에, 프로젝트 루트 경로에 `temp`라는 폴더 하나를 만들어야 한다!
• new FileOutputStream("temp/hello.dat") → 파일에 데이터를 출력하는 스트림이다. 파일이 없으면 자동으로 파일을 만들고, 데이터를 해당 파일에 저장한다. 폴더는 만들지 않기 때문에 폴더는 미리 만들어 두어야 한다.
• write() → byte 단위로 값을 출력한다. 여기서는 65, 66, 67을 출력했다. 참고로 ASCII 코드 집합에서 65는 'A', 66은 'B', 67은 'C"이다. 
• new FileInputStream("temp/hello.dat") → 파일에서 데이터를 읽어오는 스트림이다.
• read() → 파일에서 데이터를 byte 단위로 하나씩 읽어온다. 순서대로 65, 66, 67을 읽어온다. 파일의 끝에 도달해서 더는 읽을 내용이 없다면 -1을 반환한다. (파일의 끝, EOF, End of File)
• close() → 파일에 접근하는 것은 자바 입장에서 외부 자원을 사용하는 것이다. 자바에서 내부 객체는 자동으로 GC가 되지만, 외부 자원은 사용 후 반드시 닫아주어야 한다.

실행 결과

65
66
67
-1

• 입력한 순서대로 잘 출력되는 것을 확인할 수 있다. 마지막은 파일의 끝에 도달해서 -1이 출력된다.

실행 결과 - temp/hello.dat

ABC

• `hello.dat`에 분명 byte로 65, 66, 67을 저장했다. 그런데 왜 개발툴이나 텍스트 편집에서 열어보면 ABC라고 보이는 것일까?
• 앞서 자바에서 read()로 읽어서 출력한 경우에는 65, 66, 67이 정상 출력되었다.
• 우리가 사용하는 개발툴이나 텍스트 편집기는 UTF-8 또는 MS949 문자 집합을 사용해서 byte 단위의 데이터를 문자로 디코딩해서 보여준다. 따라서 65, 66, 67이라는 byte를 ASCII 문자인 A, B, C로 인식해서 출력한 것이다.

 

참고: 파일 append 옵션

FileOutputStream의 생성자에는 append라는 옵션이 있다.

• true → 기존 파일의 끝에 이어서 쓴다.
• false → 기존 파일의 데이터를 지우고 처음부터 다시 쓴다 (기본값)

 

파일의 데이터를 읽을 때, 파일 끝까지 읽어야 한다면 다음과 같이 반복문을 사용하면 된다.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class StreamStartMain2 {

    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");

        fos.write(65);
        fos.write(66);
        fos.write(67);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");

        int data;
        while ((data = fis.read())!= -1) {
            System.out.println(data);
        }
        fis.close();
    }
}

• 입력 스트림의 read()메서드는 파일의 끝에 도달하면 -1을 반환한다. 따라서 -1을 반환할 때 까지 반복문을 사용하면 파일의 데이터를 모두 읽을 수 있다.

실행 결과

65
66
67

 

 

한번에 읽어들이기

이번에는 byte를 하나씩 다루는 것이 아니라, byte[]을 사용해서 데이터를 원하는 크기만큼 더 편리하게 저장하고 읽는 방법을 알아보자.

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class StreamStartMain3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");
        byte[] input = {65, 66, 67};
        fos.write(input);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        byte[] buffer = new byte[10];
        int readCount = fis.read(buffer, 0, 10);
        System.out.println("readCount = " + readCount);
        System.out.println(Arrays.toString(buffer));
        fis.close();
    }
}

 

실행 결과

readCount = 3
[65, 66, 67, 0, 0, 0, 0, 0, 0, 0]

• 출력 스트림
  • write(byte[]): byte[]에 원하는 데이터를 담고, write()에 전달하면 해당 데이터를 한번에 출력할 수 있다.
• 입력 스트림
  • read(byte[], offset, length): byte[]을 미리 만들어두고, 만들어둔 byte[]에 한번에 데이터를 읽어올 수 있다.
  • byte[]: 데이터가 읽혀지는 버퍼
  • offset: 데이터 기록되는 byte[]의 인덱스 시작 위치
  • length: 읽어올 byte의 최대 길이
  • 반환값: 버퍼에 읽은 총 바이트 수 여기서는 3byte를 읽었으므로 3이 반환된다. 스트림의 끝에 도달하여 더이상 데이터가 없는 경우 -1을 반환

참고로, read(byte[])처럼 offset, length를 생략한 메서드도 있다. 이 메서드는 다음값을 가진다. offset(0), length(byte[].length).

 

모든 byte 한번에 읽기

package cwchoiit.io.start;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class StreamStartMain4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("temp/hello.dat");
        byte[] input = {65, 66, 67};
        fos.write(input);
        fos.close();

        FileInputStream fis = new FileInputStream("temp/hello.dat");
        byte[] readBytes = fis.readAllBytes();

        System.out.println(Arrays.toString(readBytes));
        fis.close();
    }
}

• readAllBytes()를 사용하면, 스트림이 끝날때까지(파일의 끝에 도달할 때까지)모든 데이터를 한번에 읽어올 수 있다.

실행 결과

[65, 66, 67]

 

그럼 이 두가지 방법 중 뭐가 더 좋나요?
- read(byte[], offset, length) → 스트림의 내용을 부분적으로 읽거나, 읽은 내용을 처리하면서 스트림을 계속해서 읽어야 할 경우에 적합하다. 또한, 메모리 사용량을 제어할 수 있기 때문에 너무너무 큰 파일같은 경우 이 방식이 더 적합할 수 있다. 예를 들어, 1TB 파일이 있다고 극단적으로 생각해보면, 이걸 한번에 읽어서 자바 메모리에 올리는 순간 OOM이 터질수도 있다. 

- readAllBytes() → 한번의 호출로 모든 데이터를 읽을 수 있어서 편리하다. 작은 파일이나 메모리에 모든 내용을 올려서 처리해야 하는 경우에 적합하다. 대신 메모리 사용량을 제어할 수 없기 때문에 큰 파일의 경우 OOM이 발생할 수도 있다.

결론적으로, 상황에 따라 적절한 것을 사용하면 된다.

 

 

InputStream, OutputStream

 

현대의 컴퓨터는 대부분 byte 단위로 데이터를 주고 받는다. 참고로 bit 단위는 너무 작기 때문에 byte 단위를 기본으로 사용한다. 이렇게 데이터를 주고 받는 것을 Input/Output(I/O)라고 한다. 자바 내부에 있는 데이터를 외부에 있는 파일에 저장하거나, 네트워크를 통해 전송하거나 콘솔에 출력할 때 모두 byte 단위로 데이터를 주고 받는다. 만약, 파일, 네트워크, 콘솔 각각 데이터를 주고 받는 방식이 다르다면 상당히 불편할 것이다. 또한 파일에 저장하던 내용을 네트워크에 전달하거나 콘솔에 출력하도록 변경할 때 너무 많은 코드를 변경해야 할 수 있다. 이런 문제를 해결하기 위해 자바는 InputStream, OutputStream 이라는 기본 추상 클래스를 제공한다.

 

 

• InputStream과 상속 클래스
• read(), read(byte[]), readAllBytes() 제공

• OutputStream과 상속 클래스
• write(int), write(byte[]) 제공

 

스트림을 사용하면, 파일을 사용하든, 소켓을 통해 네트워크를 사용하든, 모두 일관된 방식으로 데이터를 주고 받을 수 있다. 그리고 수많은 기본 구현 클래스들도 제공한다. 물론 각각의 구현 클래스들은 자신에게 맞는 추가 기능도 함께 제공한다. 파일에 사용하는 FileInputStream, FileOutputStream은 앞서 알아보았다. 네트워크 관련 스트림은 이후에 네트워클르 다룰 때 알아보자. 여기서는 메모리와 콘솔에 사용하는 스트림을 사용해보자.

 

메모리 스트림

package cwchoiit.io.start;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;

public class ByteArrayStreamMain {
    public static void main(String[] args) throws IOException {
        byte[] input = {65, 66, 67};

        // 메모리에 쓰기
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        bos.write(input);

        // 메모리에서 읽기
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bos.toByteArray());
        byte[] bytes = byteArrayInputStream.readAllBytes();
        System.out.println("bytes = " + Arrays.toString(bytes));
    }
}

실행 결과

bytes = [65, 66, 67]

ByteArrayOutputStream, ByteArrayInputStream을 사용하면 메모리에 스트림을 쓰고 읽을 수 있다. 이 클래스들은 OutputStream, InputStream을 상속받았기 때문에 부모의 기능을 모두 사용할 수 있다. 코드를 보면 파일 입출력과 매우 비슷한 것을 확인할 수 있다. 참고로 메모리에 어떤 데이터를 저장하고 읽을 때는 컬렉션이나 배열을 사용하면 되기 때문에, 이 기능은 잘 사용하지 않는다. 주로 스트림을 간단하게 테스트 하거나, 스트림의 데이터를 확인하는 용도로 사용한다.

 

콘솔 스트림

package cwchoiit.io.start;

import java.io.IOException;
import java.io.PrintStream;

import static java.nio.charset.StandardCharsets.UTF_8;

public class PrintStreamMain {
    public static void main(String[] args) throws IOException {
        PrintStream printStream = System.out;

        byte[] bytes = "Hello\n".getBytes(UTF_8);
        printStream.write(bytes);

        printStream.println("Hello, World!");
    }
}

실행 결과

Hello
Hello, World!

• 우리가 자주 사용했던 System.out이 사실은 PrintStream이다. 이 스트림은 OutputStream을 상속받는다. 이 스트림은 자바가 시작될 때 자동으로 만들어진다. 따라서 우리가 직접 생성하지 않는다. 
• write(byte[]): OutputStream 부모 클래스가 제공하는 기능이다.
• println(String): PrintStream이 자체적으로 제공하는 추가 기능이다. 

 

정리

InputStream과 OutputStream이 다양한 스트림들을 추상화하고, 기본 기능에 대한 표준을 잡아둔 덕분에 개발자는 편리하게 입출력 작업을 수행할 수 있다. 이러한 추상화의 장점은 다음과 같다.

• 일관성: 모든 종류의 입출력 작업에 대해 동일한 인터페이스(여기서는 부모의 메서드)를 사용할 수 있어, 코드의 일관성이 유지된다.
• 유연성: 실제 데이터 소스나 목적지가 무엇인지에 관계없이 동일한 방식으로 코드를 작성할 수 있다. 예를 들어, 파일, 네트워크, 메모리 등 다양한 소스에 대해 동일한 메서드를 사용할 수 있다.
• 확장성: 새로운 유형의 입출력 스트림을 쉽게 추가할 수 있다.
• 재사용성: 다양한 스트림 클래스들을 조합하여 복잡한 입출력 작업을 수행할 수 있다. 예를 들어, BufferedInputStream을 사용하여 성능을 향상시키거나, DataInputStream을 사용하여 기본 데이터 타입을 쉽게 읽을 수 있다. 이 부분은 뒤에서 설명한다.
• 에러처리: 표준화된 예외 매커니즘을 통해 일관된 방식으로 오류를 처리할 수 있다. 

참고로, InputStream, OutputStream은 추상 클래스이다. 자바 1.0부터 제공되고, 일부 작동하는 코드도 들어 있기 때문에 인터페이스가 아니라 추상 클래스로 제공된다.

 

 

파일 입출력과 성능 최적화1 - 하나씩 쓰고 읽기

파일을 효과적으로 더 빨리 읽고 쓰는 방법에 대해 알아보자. 먼저 예제에서 공통으로 사용할 상수들을 정의하자.

package cwchoiit.io.buffered;

public interface BufferedConst {
    String FILE_NAME = "temp/buffered.dat";
    int FILE_SIZE = 10 * 1024 * 1024; // 10MB
    int BUFFER_SIZE = 8 * 1024; // 8KB
}

• FILE_NAME: temp/buffered.dat 이라는 파일을 만들 예정이다.
• FILE_SIZE: 파일의 크기는 10MB이다.
• BUFFER_SIZE: 뒤에서 설명한다.

 

쓰기

먼저 가장 단순한 FileOutputStream의 write()을 사용해서 1byte씩 파일을 저장해보자.

그리고 10MB 파일을 만드는데 걸리는 시간을 확인해보자.

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;
import static cwchoiit.io.buffered.BufferedConst.FILE_SIZE;

public class CreateFileV1 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < FILE_SIZE; i++) {
            fos.write(1);
        }
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

• fos.write(1): 파일의 내용은 중요하지 않다. 단순히 1이라는 값을 반복하여 계속 저장한다. 한 번 호출에 1byte가 만들어진다.
• 이 메서드를 약 1000만번 호출하면 10MB의 파일이 만들어진다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 11092ms

• 실행 결과를 보면 알겠지만 상당히 오랜 시간이 걸렸다.

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV1 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        int data;
        int fileSize = 0;
        while ((data = fis.read()) != -1) {
            fileSize++;
        }
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

• fis.read()를 사용해서 앞서 만든 파일에서 1byte씩 데이터를 읽는다.
• 파일의 크기가 10MB이므로 fis.read() 메서드를 약 1000만번 호출한다. 

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 5003ms

• 실행하는데 상당히 오래걸린다.

 

정리

10MB 파일 하나를 쓰는데 11초, 읽는데 5초라는 매우 오랜 시간이 걸렸다. 이렇게 오래 걸린 이유는 자바에서 1byte씩 디스크에 데이터를 전달하기 때문이다. 디스크는 1byte의 데이터를 받아서 1byte의 데이터를 쓴다. 이 과정을 무려 1000만번 반복하는 것이다. 더 자세히 설명하자면 다음 2가지 이유로 느려진다.

 

• write()나 read()를 호출할 때마다 OS의 시스템 콜을 통해 파일을 읽거나 쓰는 명령어를 전달한다. 이러한 시스템 콜은 상대적으로 무거운 작업이다.
• HDD, SDD 같은 장치들도 하나의 데이터를 읽고 쓸 때마다 필요한 시간이 있다. HDD의 경우 더욱 느린데, 물리적으로 디스크의 회전이 필요하다.
• 이러한 무거운 작업을 무려 1000만번 반복한다.

비유를 하자면 창고에서 마트까지 상품을 전달해야 하는데 화물차에 한번에 하나의 물건만 가지고 이동하는 것이다. 화물차가 무려 1000만번 이동을 반복해야 10MB의 파일이 만들어진다. 물론 반대로 읽어 들일 때도 마찬가지다. 

이 문제를 해결하려면 한번에 화물차에 더 많은 상품을 담아서 보내면 된다.

 

참고로, 이렇게 자바에서 운영 체제를 통해 디스크에 1byte씩 전달하면, 운영 체제나 하드웨어 레벨에서 여러가지 최적화가 발생한다. 따라서 실제로 디스크에 1byte씩 계속 쓰는 것은 아니다. 그렇다면 훨씬 더 느렸을 것이다. 하지만, 자바에서 1byte씩 write()나 read()를 호출할 때마다 운영 체제로의 시스템 콜이 발생하고, 이 시스템 콜 자체가 상당한 오버헤드를 유발한다. 운영 체제와 하드웨어가 어느 정도 최적화를 제공하더라도, 자주 발생하는 시스템 콜로 인한 성능 저하는 피할 수 없다. 결국 자바에서 read(), write() 호출 횟수를 줄여서 시스템 콜 횟수도 줄여야 한다. 그래서 내부적으로 한번에 모아서 몇번씩 호출하기는 하지만 그럼에도 불구하고 그 횟수가 많다보니 이렇게 느리다.

 

 

파일 입출력과 성능 최적화2 - 버퍼 활용

이번에는 1byte씩 데이터를 하나씩 전달하는 것이 아니라 byte[]을 통해 배열에 담아서 한번에 여러 byte를 전달해보자.

 

쓰기

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.*;

public class CreateFileV2 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] buffer = new byte[BUFFER_SIZE];
        int bufferIndex = 0;

        for (int i = 0; i < FILE_SIZE; i++) {
            buffer[bufferIndex++] = 1;

            if (bufferIndex == BUFFER_SIZE) {
                fos.write(buffer, 0, BUFFER_SIZE);
                bufferIndex = 0;
            }
        }

        if (bufferIndex > 0) {
            fos.write(buffer, 0, bufferIndex);
        }
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

• 데이터를 먼저 buffer라는 byte[]에 담아둔다. 이렇게 데이터를 모아서 전달하거나 모아서 전달받는 용도로 사용하는 것을 버퍼라 한다.
• 여기서는 BUFFER_SIZE만큼 모아서, write()을 호출한다. 예를 들어, BUFFER_SIZE가 10이라면, 10만큼 모이면 write()를 호출해서 10byte를 한번에 스트림에 전달한다.
• 파일의 마지막 부분에는 얼마 남지 않았을 때 버퍼 사이즈만큼은 데이터가 없어서 bufferIndex == BUFFER_SIZE가 참을 반환하지 않지만, 어느정도는 데이터가 버퍼에 채워진 경우도 있을 수 있다. 그 경우를 생각해서 순회가 다 끝나고 bufferIndex가 0이 아닌지 체크한다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 14ms

• 실행 결과를 보면 이전에 걸렸던 시간보다 훨씬 빨라졌다. 거의 1000배 정도 빨라진 셈이다. 

 

그럼 여기서 질문, 지금은 버퍼 사이즈가 8KB라서 14ms 걸리면 더 키우면 키울수록 더 시간도 단축될까?

아쉽게도 그건 아니다. 왜냐하면, 직접 버퍼 사이즈를 더 늘려서 테스트 해보면 알겠지만 어느정도 크기부터는 시간이 단축되지 않고 그대로 유지된다. 그 이유는, 디스크나 파일 시스템에서 데이터를 읽고 쓰는 기본 단위가 보통 4KB 또는 8KB이기 떄문이다. 결국 버퍼에 많은 데이터를 담아서 보내도 디스크나 파일 시스템에서 해당 단위로 나누어 저장하기 때문에 효율에는 한계가 있다. 따라서 버퍼의 크기는 보통 4KB 또는 8KB 정도로 잡는것이 효율적이다.

 

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.BUFFER_SIZE;
import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] buffer = new byte[BUFFER_SIZE];
        int size;
        int fileSize = 0;
        while ((size = fis.read(buffer)) != -1) {
            fileSize += size;
        }
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 5ms

• 읽기의 경우에도 버퍼를 사용하면 약 1000배정도 성능 향상을 확인할 수 있따.

 

버퍼를 사용하면 큰 성능 향상이 있다. 그러니까 결론은 버퍼를 쓰는게 맞다. 그런데 이렇게 직접 버퍼를 만들고 관리해야 하는 번거로움이 있다. 항상 이럴땐 나대신 누가 더 좋은 것을 만들어 두었다. 그게 바로 BufferedStream인데 이 녀석을 알아보자.

 

파일 입출력과 성능 최적화3 - BufferedStream 쓰기 

BufferedOutputStream은 버퍼 기능을 내부에서 대신 처리해준다. 따라서 단순한 코드를 유지하면서 버퍼를 사용하는 이점도 함께 누릴 수 있다. BufferedOutputStream을 사용해서 코드를 작성해보자.

 

쓰기

package cwchoiit.io.buffered;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.*;

public class CreateFileV3 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);
        BufferedOutputStream bos = new BufferedOutputStream(fos, BUFFER_SIZE);

        long startTime = System.currentTimeMillis();

        for (int i = 0; i < FILE_SIZE; i++) {
            bos.write(1);
        }
        bos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

• BufferedOutputStream은 내부에서 단순히 버퍼 기능만 제공한다. 따라서 반드시 대상 OutputStream이 있어야 한다. 여기서는 FileOutputStream 객체를 생성자에 전달했다. 
• 추가로 사용할 버퍼의 크기도 함께 전달할 수 있다.
• 코드를 보면 버퍼를 위한 byte[]을 직접 다루지 않고 매우 단순하게 BufferedOutputStream 객체를 만들어서 write()호출만 하고 있다. BufferedOutputStream 내부적으로 byte[]을 만들어주고 다뤄주고 있는 것이다.

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 102ms

• 성능이 아주 뛰어나다. 처음에 직접 1byte씩 쓰는것보다 매우 빠르다.

• BufferedOutputStream은 OutputStream을 상속받는다. 따라서 개발자 입장에서 보면 OutputStream과 같은 기능을 그대로 사용할 수 있다. 예제에서는 write()를 사용했다.

 

BufferedOutputStream 실행 순서

• BufferedOutputStream은 내부에 byte[] buf라는 버퍼를 가지고 있다.
• 여기서 버퍼의 크기는 3이라고 가정하겠다.
• BufferedOutputStream에 write(byte)를 통해, byte 하나를 전달하면 byte[] buf에 보관된다. 참고로 실제로는 write(int)이다. 근데 내부적으로 그 값을 byte로 형변환해서 buf에 보관한다. 그래서 쉽게 설명하기 위해 write(byte)로 그려두었다.

• write(byte)를 2번 호출했다. 아직 버퍼가 가득차지 않았다.

• write(byte)를 3번 호출하면 버퍼가 가득찬다.
• 버퍼가 가득차면 FileOutputStream에 있는 write(byte[]) 메서드를 호출한다. 참고로 BufferedOutputStream의 생성자에서 FileOutputStream을 전달했다.
• FileOutputStream의 write(byte[])를 호출하면, 전달된 모든 byte[]을 시스템 콜로 OS에 전달한다.

• 버퍼의 데이터를 모두 전달했기 때문에 버퍼의 내용을 비운다.
• 이후에 write(byte)가 호출되면 다시 버퍼를 채우는 식으로 반복한다.

flush()

버퍼가 다 차지 않아도, 버퍼에 남아있는 데이터를 전달하려면 flush()라는 메서드를 호출할 수도 있다. 다음 예를 보자.

• 버퍼에 2개의 데이터가 남아 있다.

• flush() 호출
• 버퍼에 남은 데이터를 전달

• 데이터를 전달하고 버퍼를 비움

 

close()

만약, 버퍼에 데이터가 남아 있는 상태로 close()를 호출하면 어떻게 될까?

• BufferedOutputStream을 close()로 닫으면 먼저 내부에서 flush()를 호출한다. 따라서 버퍼에 남아 있는 데이터를 모두 전달하고 비운다.
• 따라서, close()를 호출해도 남은 데이터를 안전하게 저장할 수 있다.

• 버퍼가 비워지고 나면 close()로 BufferedOutputStream의 자원을 정리한다.
• 그리고 나서 다음 연결된 스트림의 close()를 호출한다. 여기서는 FileOutputStream의 자원이 정리된다.
• 여기서 핵심은 close()를 호출하면 close()가 연쇄적으로 호출된다는 점이다. 따라서 마지막에 연결한 BufferedOutputStream만 닫아주면 된다.

주의! - 반드시 마지막에 연결한 스트림을 닫아야 한다.

• 만약, BufferedOutputStream을 닫지 않고, FileOutputStream만 직접 닫으면 어떻게 될까?
• 이 경우 BufferedOutputStream의 flush()도 호출되지 않고, 자원도 정리되지 않는다. 따라서 남은 byte가 버퍼에 남아있게 되고, 파일에 저장되지 않는 심각한 문제가 발생한다.
• 따라서, 지금과 같이 스트림을 연결해서 사용하는 경우에는 마지막에 연결한 스트림을 반드시 닫아주어야 한다. 마지막에 연결한 스트림만 닫아주면, 연쇄적으로 close()가 호출된다.

 

기본 스트림, 보조 스트림

FileOutputStream과 같이 단독으로 사용할 수 있는 스트림을 기본 스트림이라고 한다.

BufferedOutputStream과 같이 단독으로 사용할 수 없고, 보조 기능을 제공하는 스트림을 보조 스트림이라 한다.

 

BufferedOutputStream은 FileOutputStream에 버퍼라는 보조 기능을 제공한다. BufferedOutputStream의 생성자를 보면 알겠지만, 반드시 FileOutputStream 같은 대상 OutputStream이 있어야 한다.

public BufferedOutputStream(OutputStream out) { ... }
public BufferedOutputStream(OutputStream out, int size) { ... }

• BufferedOutputStream은 버퍼라는 보조 기능을 제공한다. 그렇다면 누구에게 보조 기능을 제공할지 대상을 반드시 전달해야 한다.

정리

• BufferedOutputStream은 버퍼 기능을 제공하는 보조 스트림이다.
• BufferedOutputStream도 OutputStream의 자식이기 때문에 OutputStream의 기능을 그대로 사용할 수 있다. 물론 대부분의 기능은 재정의된다. write()의 경우 먼저 버퍼에 쌓도록 재정의된다.
• 버퍼의 크기만큼 데이터를 모아서 전달하기 때문에 빠른 속도로 데이터를 처리할 수 있다.

 

파일 입출력과 성능 최적화4 - BufferedSteram 읽기

읽기

package cwchoiit.io.buffered;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.BUFFER_SIZE;
import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);
        BufferedInputStream bis = new BufferedInputStream(fis, BUFFER_SIZE);

        long startTime = System.currentTimeMillis();

        int data;
        int fileSize = 0;
        while ((data = bis.read()) != -1) {
            fileSize++;
        }
        bis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + fileSize / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 94ms

• 1byte씩 직접 읽어들이는 것보다 훨씬 빠르다. 그런데, 쓰기도 마찬가지고 읽기도 마찬가지다. 직접 byte[]을 다루어 읽고 쓰는것보다는 조금 더 느린데 이유가 뭘까? 이후에 설명한다.

BufferedInputStream 실행순서

• BufferedInputStream은 InputStream을 상속받는다. 따라서 개발자 입장에서 보면, InputStream과 같은 기능을 그대로 사용할 수 있다. 예제에서는 read()를 사용했다.

• read() 호출 전
• 버퍼의 크기는 3이라고 가정

• read()는 1byte만 조회한다.
• BufferedInputStream은 먼저 버퍼를 확인한다. 버퍼에 데이터가 없으므로 데이터를 불러온다.
• BufferedInputStream은 FileInputStream에서 read(byte[])을 사용해서 버퍼의 크기가 3byte의 데이터를 불러온다.
• 불러온 데이터를 버퍼에 보관한다.

• 버퍼에 있는 데이터 중에 1byte를 반환한다.

• read()를 또 호출하면 버퍼에 있는 데이터 중에 1byte를 반환한다.

• read()를 또 호출하면 버퍼에 있는 데이터 중에 1byte를 반환한다.

• read()를 호출하는데, 이번에는 버퍼가 비어있다.
• FileInputStream에서 버퍼 크기만큼 조회하고 버퍼에 담아둔다.

• 버퍼에 있는 데이터를 하나 반환한다.
• 이런 방식을 반복한다.

정리

BufferedInputStream은 버퍼의 크기만큼 데이터를 미리 읽어서 버퍼에 보관해둔다. 따라서 read()를 통해 1byte씩 데이터를 조회해도, 성능이 최적화된다.

 

버퍼를 직접 다루는 것보다 BufferedXxx의 성능이 떨어지는 이유

• 예제1 쓰기: 14000ms (14초)
• 예제2 쓰기: 14ms (버퍼를 직접 다룸)
• 예제3 쓰기: 102ms (BufferedXxx)

예제2는 버퍼를 직접 다루는 것이고, 예제3은 BufferedXxx라는 클래스가 대신 버퍼를 처리해준다. 버퍼를 사용하는 것은 같기 때문에 결과적으로 예제2와 예제3은 비슷한 성능이 나와야한다. 그런데 왜 예제2가 더 빠를까? 그것도 10배정도나? 이 이유는 바로 동기화 때문이다.

 

BufferedOutputStream.write()

@Override
public synchronized void write(int b) throws IOException {
    if (count >= buf.length) {
        flushBuffer();
    }
    buf[count++] = (byte)b;
}

• 와우, synchronized가 걸려있다.
• BufferedOutputStream을 포함한 BufferedXxx 클래스는 모두 동기화 처리가 되어 있다.
• 이번 예제의 문제는 1byte씩 저장해서 총 10MB를 저장해야 하는데 이렇게 하려면 write()를 약 1000만번 호출해야 한다.
• 결과적으로 락을 걸고 푸는 것도 1000만번 호출된다는 뜻이다.

 

BufferedXxx 클래스의 특징

BufferedXxx 클래스는 자바 초창기에 만들어진 클래스인데, 처음부터 멀티 스레드를 고려해서 만든 클래스이다. 따라서 멀티 스레드에 안전하지만 락을 걸고 푸는 동기화 코드로 인해 성능이 약간 저하될 수 있다. 하지만, 싱글 스레드 상황에서는 동기화 락이 필요하지 않기 때문에 직접 버퍼를 다룰 때와 비교해서 성능이 떨어진다. 

 

일반적인 상황이라면, 이 정도 성능은 크게 문제가 되지 않기 때문에 싱글 스레드여도 BufferedXxx를 사용하면 충분하다. 물론, 매우 큰 데이터를 다루어야 하고, 성능 최적화가 중요하다면 직접 버퍼를 다루는 방법을 고려하자. 아쉽게도 동기화 락이 없는 BufferedXxx 클래스는 없다. 꼭 필요한 상황이라면 BufferedXxx를 참고해서 동기화 락 코드를 제거한 클래스를 직접 만들어 사용하면 된다. 

 

 

파일 입출력과 성능 최적화5 - 한번에 쓰고 읽기

파일 크기가 크지 않다면, 간단하게 한번에 쓰고 읽는것도 좋은 방법이다. 이 방법은 성능은 이론적으론 가장 빠르지만, 결과적으로 메모리를 한번에 많이 사용하기 때문에 파일의 크기가 작아야 한다. 그리고 사실, 이론적으로 성능이 가장 빠르긴해도 버퍼의 크기를 지정해서 읽고 쓰는거랑 크게 차이가 없다. 위에서 이 이유도 설명했다. 바로 기본적으로 디스크나 파일 시스템이 4KB, 8KB 크기정도를 기본으로 사용하기 때문에. 

 

쓰기

package cwchoiit.io.buffered;

import java.io.FileOutputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;
import static cwchoiit.io.buffered.BufferedConst.FILE_SIZE;

public class CreateFileV4 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();
        byte[] buffer = new byte[FILE_SIZE];

        for (int i = 0; i < FILE_SIZE; i++) {
            buffer[i] = 1;
        }
        fos.write(buffer);
        fos.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File created: " + FILE_NAME);
        System.out.println("File size: " + FILE_SIZE / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File created: temp/buffered.dat
File size: 10MB
Time taken: 15ms

• 실행 시간은 8KB의 버퍼를 직접 사용한 예제2와 오차 범위 정도로 비슷하다. 디스크나 파일 시스템에서 데이터를 읽고 쓰는 기본 단위가 보통 4KB 또는 8KB이기 때문에.

 

읽기

package cwchoiit.io.buffered;

import java.io.FileInputStream;
import java.io.IOException;

import static cwchoiit.io.buffered.BufferedConst.FILE_NAME;

public class ReadFileV4 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream(FILE_NAME);

        long startTime = System.currentTimeMillis();

        byte[] bytes = fis.readAllBytes();
        fis.close();

        long endTime = System.currentTimeMillis();

        System.out.println("File name: " + FILE_NAME);
        System.out.println("File size: " + bytes.length / 1024 / 1024 + " MB");
        System.out.println("Time taken: " + (endTime - startTime) + " ms");
    }
}

실행 결과

File name: temp/buffered.dat
File size: 10MB
Time taken: 3ms

• 실행 시간은 8KB의 버퍼를 사용한 예제2와 오차 범위 정도로 비슷하다.
• readAllBytes()를 사용하면 한번에 모든 데이터를 다 읽을 수 있다.

 

정리를 하자면

결국, 파일이나 네트워크나 콘솔 모두 대부분 byte 단위로 데이터를 주고 받는다. 이렇게 데이터를 주고 받는것을 Input/Output(I/O)라고 했다. 자바에서는 InputStream, OutputStream이라는 기본 추상 클래스를 제공해서 파일이든, 메모리든, 네트워크든, 콘솔이든 다 똑같은 방식으로 데이터를 읽고 쓸 수 있다. 그리고 읽고 쓸때 적절한 크기의 버퍼를 사용해서 읽고 쓰면 훨씬 더 효율적이고 성능이 좋아진다. 그리고 이때도 자바가 미리 만들어둔 BufferedXxx 클래스인 보조 스트림을 사용해서 간단하게 사용할 수가 있다. 다만, 이 BufferedXxx는 전부 다 멀티 스레드를 고려해서 만든 클래스이기 때문에 동기화 락을 걸고 풀고 하는 코드가 있다. 따라서, 싱글 스레드 상황에서는 성능이 직접 만든 byte[]을 사용하는것보단 떨어진다. 이 점은 상황에 맞게 적절히 판단하여 사용하면 될 것 같다.