태그 보관물: LRU

BufferedWriter를 이용한 가장 좋은 성능 방안에 대해서..

파일에 로그를 남긴다거나 데이타를 쓰기위해서 java.io.File 객체를 써도 되지만, 성능을 위해서 BufferedWriter를 많이 이용하게 됩니다. 특히 로그 라이브러리나 로깅 유틸리티 클래스에서 거의 대부분 사용할 것으로 생각이 드네요..
그래서, 생각한 방법이 BufferedWriter를 캐싱하는 것입니다.

아래 코드의 shutdown() 메쏘드는 ShudownHooking으로 등록된 쓰레드가 프로세스가 종료되면 호출을 해서 버퍼에 남아있는 내용을 기록하도록 되어 있습니다.

BufferedWriterCacheUtility.java

package net.sjava.io.test;

import java.util.Map;
import java.util.LinkedHashMap;
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.util.Iterator;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BufferedWriterCacheUtility {
   
    /** max cache size */
    private static final int size = 10;
    /** lock */
    private static Lock lock = new ReentrantLock();
   
    /** initialized lru cache */
    private static Map<String, BufferedWriter> cache = new LinkedHashMap<String, BufferedWriter> (size, .75F, true) {
        private static final long serialVersionUID = 1L;
        protected boolean removeEldestEntry(Map.Entry<String, BufferedWriter> eldest) {
            if(size() > size) {
                try {
                    // flush and close before deleted
                    eldest.getValue().close();
                } catch(java.io.IOException e) {
                    // ignore
                }
            }
           
            return size() > size;  
        }
    };

   
    /**
     *
     * @param fileName
     * @return
     */
    public static BufferedWriter createBufferedWriter(String fileName) {
        lock.lock();
        try{
            if(cache.containsKey(fileName))
                return cache.get(fileName);
       
            return new BufferedWriter(new FileWriter(fileName, true), 1024);
        } catch(java.io.IOException e) {
            e.printStackTrace();
            return null;
        } finally {
            lock.unlock();
        }
    }
   
    /**
     *
     * @param fileName
     * @param writer
     */
    public static void close(String fileName, BufferedWriter writer) {
        lock.lock();
        try {
            cache.put(fileName, writer);
        } finally {
            lock.unlock();
        }
    }
   
    /** shutdown hooking thread call */
    public static void shutdown() {
        // 아래의 코드를 통해서 종료가 되더라도 다 flush 하고 종료한다.     
        Iterator<BufferedWriter> iter = null;
        try {
            iter = cache.values().iterator();
            while (iter.hasNext()){
                iter.next().close();
                //iter.next().close();
            }
           
        }catch(java.io.IOException e) {
            e.printStackTrace();
        }
    }
}


아래 코드는 BufferedWriter를 사용하는 방법에 대한 3가지의 예입니다.
물론 2번째(bwriter02)를 사용하는 예가 가장 빠르겠지만, 3번째 예는 여러개의 fileName을 가지고 file write를 하기에 가장 좋은 방법으로 생각이 듭니다.

BufferedWriterTest.java

package net.sjava.io.test;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BufferedWriterTest {

    private static SimpleDateFormat format = new SimpleDateFormat(“yyyy.MM.dd HH:mm:ss SSS”);

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //load();
               
        System.out.println(“s – ” + format.format(new Date()));
       
        BufferedWriter bwriter01 = null;
        try {
            for(int i=0; i < 100000; i++) {
                bwriter01 = new BufferedWriter(new FileWriter(“c:\\test01.txt”, true), 1024);
                bwriter01.write(“aaaaaaaaaaaaccccccccccccccccccaaa”);
                bwriter01.newLine();
                bwriter01.flush();
                bwriter01.close();
            }
        } catch(java.io.IOException e) {
            e.printStackTrace();
        }
        System.out.println(“e – ” + format.format(new Date()));
        
        System.out.println(“s – ” + format.format(new Date()));
        BufferedWriter bwriter02 = null;
        try {
            bwriter02 = new BufferedWriter(new FileWriter(“c:\\test02.txt”, true), 1024);
            for(int i=0; i < 100000; i++) {
                bwriter02.write(“aaaaaaaaaaaaccccccccccccccccccaaa”);
                bwriter02.newLine();
            }
            bwriter02.flush();
            bwriter02.close();
        } catch(java.io.IOException e) {
            e.printStackTrace();
        }
        System.out.println(“e – ” + format.format(new Date()));        
        
        // 날짜별 혹은 서비스별로 로깅을 해야 될경우
        System.out.println(“s – ” + format.format(new Date()));
        BufferedWriter bwriter03 = null;
        try {
            for(int i=0; i < 100000; i++) {
                bwriter03 = BufferedWriterCacheUtility.createBufferedWriter(“c:\\test03.txt”);   
                bwriter03.write(“aaaaaaaaaaaaccccccccccccccccccaaa”);
                bwriter03.newLine();
                BufferedWriterCacheUtility.close(“c:\\test03.txt”, bwriter03);
            }
        } catch(java.io.IOException e) {
            e.printStackTrace();
        }
       
        System.out.println(“e – ” + format.format(new Date()));
    }

}


여담이지만, java.io.BufferedWriter 소스를 보면, write시에 lock을 잡고 씁니다.
아래와 같은 코드를 많이 사용하지만요..

lock.lock();
try {
 bWriter.write(“000000000000000”);
}catch(java.io.IOException e) {
  e.printStackTrace();
} finally {
  lock.unlock();
}

위 코드보다는 아래코드를 사용하는게 맞겠습니다.

try {
 bWriter.write(“000000000000000”);
}catch(java.io.IOException e) {
  e.printStackTrace();
}

LinkedHashMap 기반으로 LRU(least-recently-used) 캐시하기

java 1.4 Collections API에 새롭게 첨가된 java.util.LinkedHashMap 클래스는 HashMap처럼 해쉬테이블에 기반을 둔 Map 클래스 입니다. LinkedHashMap이 다른 점은 맵 엔트리에서 실행되는 링크된 리스트를 관리할 수 있고 또한 그 엔트리에 대해서 예측할 수 있는 반복 작업을 수행할 수 있다는 것이다. 대부분 이 순서는 맵에 엔트리가 추가된 순서대로 되고 가끔씩 아주 유용한 특징으로 사용할 수 있는 상황도 있습니다. 

LinkedHashMap은 생성자의 세 번째 인자로 true 값을 넘겨줌으로써 가장 최근에 접근(즉 조회되거나 설정된) 순서에서 가장 오래 전에 접근된 순서로 엔트리 순서를 설정할 수 있다.

그리고, LinkedHashMap의 removeEldestEntry()를 새로운 Entry가 추가될 때 마다 호출을 하게되면, 이 메소드가 true를 반환하면 맵에서 ‘가장 오래된’ Entry, 즉 가장 오래 전에 입력되거나 사용된 것은 자동적으로 삭제된다. removeEldestEntry()의 기본값으로 항상 false를 반환하지만 맵이 정해진 어떤 최고 크기에 다다르면 true 값을 반환하도록 오버라이드 할 수 있다. 이와 같이 하면 LRU(least-recently-used) 캐시를 만들 수 있는 것입니다.

public class LRUCache extends java.util.LinkedHashMap {
    public LRUCache(int maxsize) {
        super(maxsize*4/3 + 1, 0.75f, true);
        this.maxsize = maxsize;
    }
    protected int maxsize;
    protected boolean removeEldestEntry() {
        return size() > maxsize;
    }
}