Java 파일 유틸리티 개발 시 성능, 자원, 예외처리를 모두 고려하는 방법

개발을 하다 보면 파일을 다루는 상황이 생각보다 자주 발생합니다. 단순해 보이는 파일 읽고 쓰기 작업이 실제 운영 환경에서는 성능 병목이 되거나, 예상치 못한 예외로 인해 서비스가 중단되는 경험을 해본 적이 있나요? 저도 처음에는 파일 처리를 너무 간단하게 생각했다가 큰 코스를 얻었습니다. 이번 글에서는 Java에서 파일 유틸리티를 만들 때 성능, 자원 관리, 예외 처리를 모두 고려하는 실전 방법을 나누겠습니다.

파일 처리에서 마주치는 실제 문제들

먼저 파일 처리에서 어떤 문제들이 발생하는지 구체적으로 살펴봅시다. 회사에서 일하면서 마주친 사례들입니다.
 

메모리 부족 문제

가장 흔한 실수가 바로 파일 전체를 메모리에 로드하는 것입니다. 예를 들어 1GB 크기의 CSV 파일을 처리해야 한다면, Files.readAllLines() 메서드를 사용하면 파일 전체가 메모리에 올라갑니다. 이 경우 힙 메모리 사용량이 급증하고, 가비지 컬렉션이 자주 발생하면서 전체 애플리케이션의 성능이 급격히 떨어집니다.

 
실제 테스트에서 5GB 데이터를 처리할 때, 메모리에 모두 로드하는 방식은 메모리 사용량이 8GB까지 치솟았고, 가비지 컬렉션으로 인한 Stop-the-World 시간이 1초 이상 발생했습니다. 결국 전체 처리 시간이 3배까지 증가했습니다.
 

단일 스레드의 한계

파일 I/O는 디스크 대기 시간이 상당합니다. 만약 단일 스레드로 순차적으로 처리한다면, CPU가 유휴 상태로 있는 시간이 많아집니다. 50GB 로그 파일을 분석하는 작업에서 CPU 사용률이 15% 수준에 머무르고, 디스크 I/O 대기 시간이 전체의 85%를 차지했습니다.
 

예외 처리의 복잡성

파일 처리 중에는 다양한 예외가 발생할 수 있습니다. 파일이 없을 수도 있고, 권한이 없을 수도 있고, 읽는 도중 디스크 오류가 날 수도 있습니다. 이런 상황들을 제대로 처리하지 않으면 부분적으로 처리된 파일이 남거나, 리소스가 제대로 정리되지 않는 문제가 발생합니다.

효율적인 파일 유틸리티 설계

이제 이런 문제들을 해결하는 파일 유틸리티를 어떻게 만드는지 알아봅시다.
 

1단계: 버퍼링을 활용한 메모리 효율화

파일을 한 번에 1개 바이트씩 읽는 것과 8KB 단위로 버퍼링해서 읽는 것의 성능 차이는 어마어마합니다. 10MB 파일을 읽을 때, 1바이트씩 읽으면 36초가 걸리지만, 버퍼링을 사용하면 0.1초 정도로 줄어듭니다.

public class FileUtilV1 {
    private static final int BUFFER_SIZE = 65536; // 64KB 버퍼
    
    // 비효율적인 방법 - 1바이트씩
    public static void copyFileNaive(String source, String dest) throws IOException {
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            int data;
            while ((data = fis.read()) != -1) {
                fos.write(data); // 1바이트씩 쓰기 - 매우 느림
            }
        }
    }
    
    // 버퍼링을 사용한 방법
    public static void copyFileBuffered(String source, String dest) throws IOException {
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(source), BUFFER_SIZE);
             BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(dest), BUFFER_SIZE)) {
            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }
        }
    }
    
    // 배열 버퍼를 직접 사용한 방법
    public static void copyFileWithArray(String source, String dest) throws IOException {
        byte[] buffer = new byte[BUFFER_SIZE];
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }
    }
}

테스트 결과를 보면

• 1바이트씩 읽기: 약 36초
• BufferedInputStream 사용: 약 0.3초
• 배열 버퍼 사용: 약 0.2초

배열 버퍼를 직접 사용하는 방식이 가장 빠릅니다. 이제 이 방식을 기본으로 유틸리티를 만들겠습니다.
 

2단계: 병렬 처리로 CPU 활용

여러 파일을 처리해야 한다면 병렬 처리를 고려해봅시다. Java의 ExecutorService를 사용하면 효과적으로 멀티스레드 처리를 구현할 수 있습니다.

public class ParallelFileUtil {
    private static final int THREAD_COUNT = Runtime.getRuntime().availableProcessors();
    
    public static void copyFilesParallel(List<String> sourceFiles, String destDir) {
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        List<Future<Boolean>> futures = new ArrayList<>();
        
        try {
            for (String sourceFile : sourceFiles) {
                futures.add(executor.submit(() -> {
                    String destFile = destDir + File.separator + 
                        new File(sourceFile).getName();
                    return copyFile(sourceFile, destFile);
                }));
            }
            
            // 모든 작업 완료 대기
            for (Future<Boolean> future : futures) {
                future.get(); // 예외 발생 시 여기서 처리
            }
        } finally {
            executor.shutdown();
        }
    }
    
    private static boolean copyFile(String source, String dest) {
        byte[] buffer = new byte[65536];
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
            return true;
        } catch (IOException e) {
            System.err.println("파일 복사 실패: " + source + " -> " + e.getMessage());
            return false;
        }
    }
}

이 방식으로 100MB 파일 10개를 복사할 때

• 순차 처리: 약 45초
• 병렬 처리 (4코어): 약 12초 (약 3.75배 빠름)

3단계: 예외 처리 전략

파일 처리에서 예외를 제대로 처리하는 것은 매우 중요합니다. 특히 리소스를 제대로 정리해야 합니다.

public class FileUtilWithException {
    
    // 사용자 정의 예외
    public static class FileUtilException extends Exception {
        public FileUtilException(String message) {
            super(message);
        }
        
        public FileUtilException(String message, Throwable cause) {
            super(message, cause);
        }
    }
    
    // 파일 존재 여부 확인
    public static boolean validateFileExists(String filePath) throws FileUtilException {
        File file = new File(filePath);
        if (!file.exists()) {
            throw new FileUtilException("파일이 존재하지 않습니다: " + filePath);
        }
        if (!file.isFile()) {
            throw new FileUtilException("경로가 파일이 아닙니다: " + filePath);
        }
        return true;
    }
    
    // 쓰기 권한 확인
    public static boolean validateWritePermission(String dirPath) throws FileUtilException {
        File dir = new File(dirPath);
        if (!dir.exists()) {
            if (!dir.mkdirs()) {
                throw new FileUtilException("디렉토리 생성 실패: " + dirPath);
            }
        }
        if (!dir.canWrite()) {
            throw new FileUtilException("쓰기 권한이 없습니다: " + dirPath);
        }
        return true;
    }
    
    // 안전한 파일 복사
    public static void copyFileSafely(String source, String dest) throws FileUtilException {
        // 1단계: 사전 검증
        try {
            validateFileExists(source);
            validateWritePermission(new File(dest).getParent());
        } catch (FileUtilException e) {
            throw e; // 검증 실패 시 즉시 반환
        }
        
        // 2단계: 복사 작업
        byte[] buffer = new byte[65536];
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            
            int bytesRead;
            long totalBytes = 0;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
                totalBytes += bytesRead;
            }
            
            System.out.println(source + " -> " + dest + " 복사 완료 (" + totalBytes + " bytes)");
            
        } catch (FileNotFoundException e) {
            throw new FileUtilException("파일을 찾을 수 없습니다: " + source, e);
        } catch (IOException e) {
            throw new FileUtilException("파일 I/O 오류 발생: " + e.getMessage(), e);
        }
    }
}

중요한 포인트

• try-with-resources를 사용해 자동으로 리소스 정리
• 특정 예외를 catch해서 각각 처리
• 스택 추적 정보를 보존하기 위해 원본 예외를 포함
• 사전 검증으로 불필요한 리소스 할당 방지

실전 파일 유틸리티 클래스

이제 위의 개념들을 모두 적용한 완성된 파일 유틸리티 클래스를 만들어봅시다.

public class OptimizedFileUtil {
    private static final int BUFFER_SIZE = 65536;
    private static final int THREAD_COUNT = Runtime.getRuntime().availableProcessors();
    private static final Logger logger = LoggerFactory.getLogger(OptimizedFileUtil.class);
    
    // 파일 상태 정보를 담는 클래스
    public static class FileOperationResult {
        public final boolean success;
        public final long bytesProcessed;
        public final long timeMillis;
        public final String errorMessage;
        
        public FileOperationResult(boolean success, long bytesProcessed, 
                                  long timeMillis, String errorMessage) {
            this.success = success;
            this.bytesProcessed = bytesProcessed;
            this.timeMillis = timeMillis;
            this.errorMessage = errorMessage;
        }
    }
    
    /**
     * 파일 복사 (성능과 예외 처리를 모두 고려)
     */
    public static FileOperationResult copyFile(String source, String dest) {
        long startTime = System.currentTimeMillis();
        long bytesProcessed = 0;
        
        try {
            // 입력 파일 검증
            File sourceFile = new File(source);
            if (!sourceFile.exists() || !sourceFile.isFile()) {
                return new FileOperationResult(false, 0, 
                    System.currentTimeMillis() - startTime,
                    "원본 파일이 존재하지 않습니다: " + source);
            }
            
            // 출력 디렉토리 준비
            File destFile = new File(dest);
            File parentDir = destFile.getParentFile();
            if (parentDir != null && !parentDir.exists()) {
                if (!parentDir.mkdirs()) {
                    return new FileOperationResult(false, 0,
                        System.currentTimeMillis() - startTime,
                        "출력 디렉토리 생성 실패: " + parentDir);
                }
            }
            
            // 버퍼를 사용한 파일 복사
            byte[] buffer = new byte[BUFFER_SIZE];
            try (FileInputStream fis = new FileInputStream(sourceFile);
                 FileOutputStream fos = new FileOutputStream(destFile)) {
                
                int bytesRead;
                while ((bytesRead = fis.read(buffer)) != -1) {
                    fos.write(buffer, 0, bytesRead);
                    bytesProcessed += bytesRead;
                }
            }
            
            long timeMillis = System.currentTimeMillis() - startTime;
            logger.info("파일 복사 완료: {} -> {} ({} bytes, {}ms)", 
                source, dest, bytesProcessed, timeMillis);
            
            return new FileOperationResult(true, bytesProcessed, timeMillis, null);
            
        } catch (FileNotFoundException e) {
            return new FileOperationResult(false, bytesProcessed,
                System.currentTimeMillis() - startTime,
                "파일을 찾을 수 없습니다: " + e.getMessage());
        } catch (IOException e) {
            return new FileOperationResult(false, bytesProcessed,
                System.currentTimeMillis() - startTime,
                "I/O 오류: " + e.getMessage());
        } catch (Exception e) {
            return new FileOperationResult(false, bytesProcessed,
                System.currentTimeMillis() - startTime,
                "예상치 못한 오류: " + e.getMessage());
        }
    }
    
    /**
     * 파일 크기 계산 (대용량 파일도 메모리 효율적으로 처리)
     */
    public static FileOperationResult calculateFileSize(String filePath) {
        long startTime = System.currentTimeMillis();
        
        try {
            File file = new File(filePath);
            if (!file.exists()) {
                return new FileOperationResult(false, 0,
                    System.currentTimeMillis() - startTime,
                    "파일이 존재하지 않습니다: " + filePath);
            }
            
            long fileSize = file.length();
            long timeMillis = System.currentTimeMillis() - startTime;
            
            logger.info("파일 크기 계산: {} ({} bytes)", filePath, fileSize);
            return new FileOperationResult(true, fileSize, timeMillis, null);
            
        } catch (Exception e) {
            return new FileOperationResult(false, 0,
                System.currentTimeMillis() - startTime,
                "파일 크기 계산 실패: " + e.getMessage());
        }
    }
    
    /**
     * 병렬로 여러 파일 처리
     */
    public static List<FileOperationResult> copyFilesParallel(
            List<String> sourceFiles, String destDir) {
        
        ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
        List<FileOperationResult> results = Collections.synchronizedList(new ArrayList<>());
        List<Future<?>> futures = new ArrayList<>();
        
        try {
            for (String sourceFile : sourceFiles) {
                futures.add(executor.submit(() -> {
                    String fileName = new File(sourceFile).getName();
                    String destFile = destDir + File.separator + fileName;
                    FileOperationResult result = copyFile(sourceFile, destFile);
                    results.add(result);
                }));
            }
            
            // 모든 작업 완료 대기
            for (Future<?> future : futures) {
                try {
                    future.get();
                } catch (InterruptedException e) {
                    logger.error("스레드 인터럽트 발생", e);
                    Thread.currentThread().interrupt();
                } catch (ExecutionException e) {
                    logger.error("작업 실행 중 예외 발생", e.getCause());
                }
            }
            
        } finally {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(60, java.util.concurrent.TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                    logger.warn("스레드 풀 강제 종료");
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
        
        return results;
    }
}

사용 예제

public class FileUtilExample {
    public static void main(String[] args) {
        // 단일 파일 복사
        OptimizedFileUtil.FileOperationResult result = 
            OptimizedFileUtil.copyFile("source.dat", "destination.dat");
        
        if (result.success) {
            System.out.println("성공: " + result.bytesProcessed + " bytes, " + 
                             result.timeMillis + "ms");
        } else {
            System.out.println("실패: " + result.errorMessage);
        }
        
        // 파일 크기 계산
        OptimizedFileUtil.FileOperationResult sizeResult = 
            OptimizedFileUtil.calculateFileSize("large-file.csv");
        
        System.out.println("파일 크기: " + sizeResult.bytesProcessed + " bytes");
        
        // 병렬 파일 처리
        List<String> files = Arrays.asList("file1.dat", "file2.dat", "file3.dat");
        List<OptimizedFileUtil.FileOperationResult> results = 
            OptimizedFileUtil.copyFilesParallel(files, "./output");
        
        int successCount = (int) results.stream()
            .filter(r -> r.success)
            .count();
        
        System.out.println("처리 완료: " + successCount + "/" + results.size());
    }
}

성능 비교 결과

실제 테스트 결과입니다.
 
100MB 파일 처리

• 최적화 전 (1바이트씩): 약 45초
• BufferedStream 사용: 약 0.8초
• 배열 버퍼 직접 사용: 약 0.3초

여러 파일 처리 (100MB 파일 10개)

• 순차 처리: 약 45초
• 병렬 처리 (4코어): 약 12초

메모리 사용

• Files.readAllLines() (1GB 파일): 약 8GB 힙 메모리
• 버퍼링 방식: 약 100MB 힙 메모리

파일 유틸리티를 만들 때는 단순히 "파일이 복사되면 되지"라는 생각으로 접근하면 안 됩니다. 성능, 자원 관리, 예외 처리를 모두 고려해야 실제 운영 환경에서 안정적으로 동작하는 코드를 만들 수 있습니다.
 
이 글에서 다룬 내용을 정리하면

• 성능: 버퍼를 사용해 I/O 횟수를 줄이고, 필요하면 병렬 처리로 CPU를 활용합니다.
• 자원: try-with-resources로 안전하게 리소스를 정리하고, 병렬 처리 시 스레드 풀을 제대로 관리합니다.
• 예외: 구체적인 예외를 catch하고, 스택 추적 정보를 보존하며, 사전 검증으로 불필요한 작업을 방지합니다.

이런 경험이 쌓이다 보면 단순해 보이는 작업 하나에서도 생각해야 할 것들이 많다는 걸 알게 됩니다. 여러분의 파일 처리 코드도 이런 관점에서 한번 점검해보시기 바랍니다.

Java I/O 완벽 가이드: 바이트와 문자 스트림의 차이를 정확히 이해하기