Java 프로세스 메모리 덤프 및 분석하기

jmap을 이용하여 지정한 Java 프로세스의 메모리를 덤프할 수 있다.

사용법: jmap [option] <pid>

서버 내 실행 중은 Java 프로세스의 pid (Process ID)를 지정. Core dump나 저멀리 있는 서버 내 프로세스의 메모리도 덤프할 수 있다. (jmap 설명서 참고)

[option]에는 다음과 같은 것들이 들어감.

• -heap : Heap 요약 정보를 표시함.
• -histo[:live] : 메모리를 할당 받은 java object를 히스토그램으로 표시함. 부가 옵션 live가 지정되면 살아있는 object만 counting 함.
• -permstat : GC 설명할 때 나오는 Permanent 영역에 대한 통계 정보를 출력함.
• -finalizerinfo : GC가 되기를 기다리고 있는 object의 정보를 출력.
• -dump:[live,]format=b,file=<file> : hprof 바이너리 형태의 메모리 덤프 파일을 생성함. live를 넣으면 실제 활동(?) 중인 obejct에 대한 것만 덤프됨.

jmap -dump:format=b,file=a.dump 123 와 같이 실행하면 (123은 PID) 123에 해당하는 java process의 메모리 덤프가 a.dump 파일로 생성된다. 문제는 a.dump는 바이너리 파일이라 그냥 볼 수 없다. 하지만 Eclipse에서 제공하는 메모리 분석 툴로 이 파일을 읽으면 메모리 상태 및 다양한 분석을 할 수 있다. http://www.eclipse.org/mat/ 참고.

추가로 jmap 실행 시 다음과 같이
Error attaching to process: sun.jvm.hotspot.debugger.DebuggerException: Can't attach to the process
연결할 수 없다는 메시지가 나오면 root 권한으로 실행하면 된다.

HttpURLConnection에서 301, 302 오류 발생 시

Redirection Exception

java.net 패키지 내 HttpURLConnection 클래스를 이용하여 HTTP로 데이터를 받을 때 HTTP_OK (200)가 아닌 HTTP_MOVED_TEMP (302), HTTP_MOVED_PERM (301) 예외가 발생할 때가 있다. 두 가지 형태로 처리할 수 있을 거 같은데 하나는 Exception을 던져 더 이상 진행하지 못하게 하는 것이고 다른 하나는 Redirect된 URL을 새로 받아 처리하는 방식이다.

Redirected URL 수용하기

Redirect된 URL을 새로 받아 처리하려면 HttpURLConnection의 헤더에서 "Location" 정보를 받아 다시 Connect 한다.

public InputStream GetHTTPInputStream(URL url) throws Exception
{
    int redirectedCount = 0;
    while( redirectedCount <= 1 )    // Redirection 1번 허용
    {
        HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
            
        httpConn.setConnectTimeout(10000);    //< 연결 제한시간(단위 : msec, 0은 무한)
        httpConn.setReadTimeout(0);           //< 읽기 제한시간(단위 : msec, 0은 무한)
        httpConn.setUseCaches(false);         //< 캐시 사용 여부 설정(기본 설정: true)

        // URL을 요청하는 방법 설정 (GET|POST|HEAD|OPTIONS|PUT|DELETE|TRACE, 기본 설정: GET)
        httpConn.setRequestMethod("GET");
        
        int resCode = httpConn.getResponseCode();

        if( resCode == HttpsURLConnection.HTTP_OK )
        {
            return httpConn.getInputStream();
        }
        // Redirection 발생하는 경우
        else if( resCode == HttpsURLConnection.HTTP_MOVED_TEMP
              || resCode == HttpsURLConnection.HTTP_MOVED_PERM )
        {
            // Redirected URL 받아오기
            String redirectedUrl = httpConn.getHeaderField("Location");
            url = new URL(redirectedUrl);
        }
        // 이외의 오류는 Exception 처리
        else
            throw new MalformedURLException("can not connect to the url [" + url.toString() + "] Code: " + resCode);
        
        ++redirectedCount;
    }
}

Java Swing Example

Java Swing Component를 이용하여 GUI를 만들려면 다음 사이트 참고!
Component 별로 Example이 잘 정리되어 있음.

Using Swing Components: Examples

Java enum의 실체

들어가기

enum! 키워드가 같기에 C++에서와 같이 생각했었다. 지난번 글에서도 이 생각이 깔려 있기에 Java의 enum type도 단순한 줄만 알았다. 기능이 조금 더 붙어서 설명과 같은 부가적인 정보를 추가로 정의해 쓸 수 있는 줄 알았다. 그런데 샘플 코드들을 보면 여기서 끝이 아닌 것 같다는 생각이 뽀록뽀록 든다...

Effective C++ 시리즈 정말 좋은 책이다. 다른 많은 사람들도 그렇게 생각하는지 Effective 시리즈는 언어별로 있는 듯 하다. 물론 저자는 다 틀리다. 예전에 Effective C# 이란 책도 있었는데 Java에도 Effective Java란 책이 있어 구입했다. Joshua Bloch가 지었으니 내용은 뭐 말할 필요 없겠지.

아직 다 보진 못했지만, 이 책 세 번째 항목에 enum으로 구현한 싱글톤 패턴에 대한 내용이 나온다. "enum으로 싱글톤을 구현하다니 말이되나?" 라고 생각했었는데 이 부분을 보고 Java의 enum에 대한 실체를 다시 생각하게 됐다.

Java의 enum

다음과 같이 정의된 enum이 있다고 하자.

public enum ValueType
{
      Unknown
    , Text
    , Number
    , DateTime
    ;
}

switch문에서 사용할 때는 차이가 있지만, 위 정의는 다음과 같이 동작하지 않나 싶다.

public class ValueType
{
    public final static Unknown = new ValueType();
    public final static Text = new ValueType();
    public final static Number = new ValueType();
    public final static DateTime = new ValueType();
}

컴파일러가 위와 같이 유일한 객체를 만드는 것이다. 위 예에서는 별도의 생성자가 없으므로 기본 생성자를 이용하고 있다(정의된 생성자가 없으면 Java 컴파일러가 기본 생성자는 만듬). 만약, 생성자가 다른 형태로 구현되어 있다면 그 형태를 맞춰야 한다. 다음의 예를 보자.

public enum ValueType2
{
      Unknown("unknown")
    , Text("string")
    , Real("real")
    , DateTime("datetime")
    ;
 
    private final String _description; 

    private ValueType(String description)
    {
        this._description = description;
    }
 
    public String getDescription()
    {
        return this._description;
    }
}

문자열 하나를 인수로 받는 생성자가 정의되어 있다. 이런 경우 다음과 같이 정의하면 컴파일러가 불만을 토로한다.

public enum ValueType2
{
      Unknown
    , Text
    , Number
    , DateTime
    ;
    ... (후략) ...
}

이런 현상을 종합해 보면, Java의 enum은 컴파일러가 만드는 유일 객체의 집합이란 것이다.

enum을 이용한 싱글톤 클래스

enum만 보면 굉장히 어색해 보이지만 Java 컴파일러가 enum을 처리하는 것을 생각해 보면 enum을 이용하여 싱글톤 클래스를 만드는 것이 전혀 어색하지 않다. 오히려 언어적으로 객체가 유일하도록 보장하는 것이니 가장 확실한 싱글톤 클래스를 만드는 것이 아닌가 싶다.

다음은 enum을 이용하여 만든 싱글톤 클래스의 예이다.

public enum ProgramSetting
{
    Instance;   //< 유일 객체

    /// 속성 저장 멤버
    private final HashMap<String, String>     _properties;

    private ProgramSetting()
    {
        _properties = new private HashMap<String, String>();
    }

    public String getProperty(String key) { ... }

    public void setProperty(String key, String value) { ... }

    ...
}

사용법은

    ...
    ProgramSetting.Instance.getProperty(...);
    ProgramSetting.Instance.setProperty(...);
    ...

Java, 참~ 재밌다.

Java enum Type

Enumeration Type

이뉴머레이션 타입. 우리나라 말로 열거형이다. C++로 작업할 때 많이 사용했었는데 다음과 같은 장점이 있다.

의미 있는 값 표시

#define을 이용하면 정의된 값으로 치환되기 때문에 디버깅할 때 힘들다. 이 때 enum을 이용하면, 정수로 변환되어 사용되긴 하지만 enum에서 정의한 단어 즉, 의미있는 단어가 그대로 나오기 때문에 직관적으로 알 수 있다.

형태에 안전한 코드

형태에 안전하도록 제약조건을 둘 수 있다. 어떤 함수(내지는 메소드)를 someFunc(int valueType)와 같이 정의했는데 인수로 들어가는 값이 0: Unknown, 1: String, 2: Number, 3: DateTime 이라고 해 보자. 인수를 정수형태로 받기 때문에 0 ~ 3 이외의 값을 입력받을 수 있다. 5가 입력되면 어떻게 처리한단 말인가...

자~ 다음과 같이 enum 타입을 정의하고

enum ValueType
{
      eUnknown = 0
    , eString = 1
    , eNnumber = 2
    , eDateTime = 3
    ;
}

someFunc(ValueType valueType) 으로 정의하면 받을 수 있는 인수값이 enum에 정의한 값으로 제한된다. 즉, 형태와 값에 안전한 코드를 생성할 수 있다.

enum in Java

지금까지는 C++ 얘기였고, Java 얘기를 해보자.

JDK 1.5부터 enum 형태를 지원하기 시작했단다. Java의 enum도 C++에서와 마찬가지 효과를 얻을 수 있으며, 정의는 다음과 같이 한다.

public enum ValueType
{
      Unknown
    , String
    , Number
    , DateTime
};

C++와 비슷하다... 여기서 끝나면 뭔가 허전하다. 뭔가 조금이라도 좋아진 것이 있을텐데... 그렇다. Java의 enum은 값을 정수 이외의 다른 형태의 값도 가질 수 있다. 즉, 다음과 같이 정의할 수 있다.

public enum ValueType
{
      Unknown("unknown")
    , Text("string")
    , Integer("integer")
    , Real("real")
    , DateTime("datetime")
    ;
 
    private String _description; 


    private ValueType(String description)
    {
        this._description = description;
    }
 
    public String getDescription()
    {
        return this._description;
    }
}

ValueType.Text.getDescription()와 같이 하면 지정된 enum 값에 할당된 값을 얻을 수 있다.

값을 가져올 수 있으면 값에서 enum 정의를 가져 올 수도 있을 것이다.

public enum ValueType
{
      Unknown("unknown")
    , Text("string")
    , Integer("integer")
    , Real("real")
    , DateTime("datetime")
    ;
 
    private String _description; 


    private ValueType(String description)
    {
        this._description = description;
    }
 
    public String getDescription()
    {
        return this._description;
    }

    public static ValueType getTypeFromString(String description)
    {
        for(ValueType valueType : ValueType.values())
        {
            if( description.equalsIgnoreCase(valueType._description) )
                return valueType;
        }

        return Unknown;
    }
}

위와 같이 정의된 getTypeFromString()을 이용하면, 설정파일에서 값을 읽어 바로 enum으로 변환하여 사용할 수 있다.

Expression Parser in Java #1

우연히

C/C++로 데이터마이닝 툴 만들다가 적(跡)이 바뀌는 바람에 Java로 작업을 하고 있다. 12~3년 전에 잠깐 써보고 다시 하는 건데 아쉬운 부분도 있지만, 신경 쓸 부분이 많이 줄어 꽤 편하게 작업하고 있다. 하지만 어떤 클래스가 무슨 기능을 하고 어떤 메소드를 이용해야 하는 지 잘 모르니 많이 뒤져 보면서 필요한 것들을 찾고 있다.

그러던 중, Shunting-Yard Algorithm을 우연히 알게 되었다. 예전에 C/C++로 수식파서 만든다고 있는 머리 없는 머리 굴려가며 고생한 적이 있었는데 그때 이걸 알았다면 많이 쉽게 하지 않았을까 싶다. 수식파싱할 때 어려운 게 연산의 순서를 계산하는 것인데 이 알고리즘을 이용하면 쉽게 할 수 있기 때문이다.

데이터를 가공 / 처리할 때 수식을 통하여 새로운 의미의 변수를 만드는 작업을 굉장히 많이 한다. 이런 파생변수를 만들 때 필요한 것이 수식파싱 후 값을 계산하는 모듈이다. 공부도 할 겸 Java로도 이 모듈을 만들어 놓으면 여기 저기 쓸 데가 있지 않을까 싶다.

잠깐만 시간을~

그렇다면, 날 다시 수식 파싱의 세계로 밀어 넣은 Shunting-Yard Algorithm은 뭔지 잠깐만 시간을 내 보자.

출처: Wikipedia

1에 2를 더하는 수식을 우리는 보통 "1 + 2"로 표시한다. 이와 같이, 보통 우리가 쓰는 수식은 infix notation 방식을 취하고 있다. 무슨 말인고 하니 연산자가 가운데(in) 있다는 얘기다.

Shunting-Yard Algorithm은 infix notation 형태의 수식을 Reverse Polish Notation (RPN) 형태로 바꾸는 데 사용할 수 있는 알고리즘이다. RPN은 연산자를 뒤에 위치시키는 표현법으로 "1 + 2"를 "1 2 +"와 같이 표시한다.

사람이 보기에는 "1 더하기 2"나 "1과 2를 더해"나 별 차이 없어 보이지만 컴퓨터가 보기엔 천지차이다. RPN 형태로 되어 있으면 루프 돌면서 쭉 계산해 나가면 되는데 infix 형태로는 그렇게 하기가 힘들다. 그래서 RPN 형태로 변경해야 하고 Shunting-Yard와 같은 알고리즘을 이용하는 것이다.

Shunting-Yard Algorithm은 이름에서 알 수 있듯이 차량기지(Shunting yard)에서 기차를들 정렬하기 위하여 사용하는 방식과 비슷하게 로직이 수행된다. 자세한 내용은 Wikipedia 참고.

Pseudocode

이야기를 풀어 나가기 위하여 Shunting-Yard Algorithm의 처리 과정을 정리해 보았다.

for each token in expression
{
    if token == 'number'
        token --> output queue

    if token == 'function'
        token --> stack

    if token == 'function argument separator' (e.g. a comma)
    {
        while( stack not empty and top of stack != '(' )
            pop stack onto output queue
        if top of stack != '('
            mismatched parentheses error.
        else
            pop '(' off stack, ignore it.
    }

    if token == 'operator'
    {
        while( stack not empty and stack top token == 'operator' )
        {
            if token precedence < stack top token or (token == left-associative and precedence <= stack top token)
                pop stack onto output queue
            else
                break
        }
        token --> stack
    }

    if token == '('
        token --> stack

    if token == ')'
    {
        while( stack not empty and stack top token != '(' )
            pop stack onto output queue
        if stack is empty
            mismatched parentheses error.
        pop '(' off stack, ignore it.

        if top of stack == 'function'
            pop stack onto output queue
    }
}

while( stack not empty )
    pop stack onto ouput queue

만들어 보자

알고리즘만 간단히 구현할 거라면 필요 없겠지만, 확장성 있는 수식파서를 만들기 위해 Psedocode를 보면서 우리가 알 수 있는 것들을 정리해 보자.

1. 우선, 수식을 한땀 한땀 이태리 장인처럼 따서 Token을 추출할 무언가가 필요하다.
2. 추출된 Token에 따라 처리할 내용이 달라지는 것을 보아 Token은 특정 형태를 가지고 있다.
3. 형태는 수식에 사용되는 연산자(Operator), 숫자(Operand), 함수(Function)와 괄호, 쉼표 등이 있다.
4. 연산자는 left-associative, right-associative의 형태를 가진다.
5. 알고리즘을 구현하기 위하여 Stack 한개와 Queue 한개가 필요하며,
6. 수행완료 후 결과는 Queue가 남는다.
7. 수식을 계산을 위한 것이므로 이 Queue에는 계산 순서에 맞게 Token이 위치할 것이다.
8. Queue와 Stack에는 Token이 들어 간다. 다양한 Token을 넣기 위한 인터페이스가 필요하다.
9. 수행 중 괄호가 맞지 않는 경우 등 사용자 오류를 처리하기 윈한 Exception 클래스가 필요하다.

정리된 내용을 수용하려면 다음과 같은 것들을 만들어야 할 것 같다.

만들 애 이름	기능/역할	비고
ExprParser	수식파서 메인 클래스	-
ExprTokenizer	수식을 잘 잘라서 Token을 뽑아 줄 클래스	1번
ExprTokenType	Token의 형태를 정의한 Enumeration. 연산자, 괄호, 함수, 피연산자 등을 정의.	2번, 3번
OperatorAssoc	연산자의 Associative 방법을 정의한 Enumeration	4번
ExprToken	ExprTokenizer에서 Token을 이 객체로 추출	2번, 8번
OperatorToken	연산자를 처리하기 위한 토큰	3번
FunctionToken	함수를 위한 토큰	3번
ValueToken	피연산자를 대변하기 위한 토큰	3번
EtcToken	연산자, 함수, 피연산자 이외 것을 대변하기 위한 토큰. 예를 들어 괄호 같은 거~	3번
ParserException	수식파싱 및 값 계산 중 발생할 수 있는 오류 처리 클래스	9번

5번에서 필요한 Stack과 Queue는 알고리즘 구현할 때 java.util 패키지에 있는 것을 이용하면 된다. 6번은 파싱하는 메소드에서 생성한 Queue를 반환하거나 멤버 변수로 저장하면 되고, 7번은 알고리즘의 결과이다.

조금만 더 생각해 보자.

수식 내에서 Token을 구분짓는 건 Token의 형태를 문자로 표현한 것들이다. 무슨 말인고 하니, 연산자, 숫자, 괄호, 함수 등을 표현한 수식 내 문자들이 Token을 뽑는 기준이라는 것이다. 오호라~ Token 뽑는 방법은 수식내 문자를 하나 하나 살펴보며 앞서 말한 문자와 일치하는 지 비교해 보면 될 듯 하다.

그렇다면 어떤 문자들이 있을까? 연산자를 먼저 살펴보면, 사칙연산(+, -, *, /)을 기본으로 승수연산(^), 나머지 연산(Modulus, %) 등이 있다. 물론, 비교 연산자(=, >=, <=, !=), 논리 연산자(and, or, not)도 포함되면 좋을 것이다. 숫자와 괄호는 특별히 말할 것이 없고, 함수는 정의하기에 따라 무궁무진 하기 때문에 연산자처럼 몇 개 정의해서 끝날 문제가 아니다. 뭔가 함수객체 들만 몰아 넣어 관리할 Gallery스러운 것이 필요하다. 조금 더 나가서 연산자도 함수처럼 관리하면 편할 것 같다. 실제 계산하는 메소드도 같이 포함시켜 놓고~

그래서 다음과 같은 것들을 추가로 만들면 조금 더 멋진 파서가 되지 않을까 싶다.

만들 애 이름	기능/역할
ExprTokenGallery	연산자, 함수 형태의 Token을 자신을 표현할 문자와 함께 Key & Value 형태로 관리하는 클래스.
Calculatable	연산자나 함수의 실제 계산을 위한 인터페이스. Token을 정의한 클래스에 멤버로 넣어 쉽게 값을 계산할 수 있게 함.

다음 편에 계속

휴... 사실 이 글을 쓰기 시작한 지 한달이 넘었다. 살은 더 붙여야 하지만 위에서 말한대로 구현도 다 해놨다. 그런데 왜 이리 안써지는지... 일 때문에 바쁜 것도 있었지만 이렇게 안써질 때가 가끔(사실 아주 많이) 있다. 이럴 땐 잠시 시간을 가져야 한다. 여기서 잠시 멈추고 다음에 소스와 함께 다시 해야겠다.