java

concurrent programming 사전 학습

/ bahamoth2013 / 댓글 남기기

금번 스터디 주제는 concurrent programming 입니다.

멀티코어 환경에서 코어 갯수가 2배로 늘어나면 성능도 2배로 늘어나기를 기대하지만, 실제로 thread가 어떤 구조로 되어있고, 어떤 자원들이 공유되며, 해당 공유 자원을 코어가 어떻게 처리하는지에 대한 정확한 이해가 없으면 이러한 성능향상은 있을 수 없습니다. 때문에 멀티코어 환경에서 프로그램의 성능을 높이려면 concurrent 한 데이터 처리 기법에 대한 이해가 반드시 필요합니다.

스터디 시작 전 미리 알아두어야 할 사전 지식에 대하여

  • 자료 링크
  • (설명이 필요한 내용은)간단한 설명

를 이 페이지에 정리해 두었으니 스터디 시작 전에 미리 공부를 해두었으면 합니다.

사전 학습 내용은 모두 java 및 jvm 내용이지만, 다른 언어/os 도 비슷비슷합니다. 하나만 제대로 알고 있으면 나머지는 쉽게 이해가능합니다.

jvm memory 구조

jvm run-time data area

dependency hell과 빌드지옥 탈출

jvm의 메모리 구조를 잘 이해하려면 java process가 어떻게 동작하는지 알아야 합니다. 근데 아이러니하게도 java process가 어떻게 동작하는지 알려면 jvm의 메모리 구조를 이해하고 있어야 합니다. 이러한 모순적 상황에서 이해의 수준을 높이려면 메모리 구조와 process 의 동작 원리를 반복적으로 여러번 공부하는 방법 밖에는 없습니다.

runtimeArea.PNG

jvm 내에서 프로세스의 흐름을 기술하기 위한 저장 영역을 run-time data area 라고 합니다. 어떤 process가 실행되어 종료될 때 까지 사용되는 모든 데이터는 이 영역에 기록됩니다.

  • program counter register : 프로그램 카운터(pc)는 현재 동작중인 프로세스/또는 쓰레드가 sleep 상태에 진입하여 CPU 점유권을 잃어버렸다가 다시 되찾을 때 현재 이 쓰레드가 어디까지 진행되었는지에 대한 기록을 남겨놓기 위한 저장공간입니다. pc register에는 현재 진행중인 instruction의 주소값이 저장됩니다.
  • jvm stack : 프로그램 내에서 method가 호출되면 그 method 를 수행하기 위해 필요한 저장공간을 제공합니다. 또한 method의 호출은 계층적으로 호출순서가 발생하므로 이 순서를 보장하여 처리하기 위해 stack 을 사용합니다. stack에 저장되는 element의 단위는 frame 이라 합니다.
  • native method stack : native method stack은 조금 특별한 영역으로, jvm의 깍두기와도 같은 예외 케이스입니다. 외부에서 실행되는 native process와의 인터페이스(jni) 를 호출하기 위한 공간입니다.
  • method area : method area는 프로그램을 실행하기 위한 메타정보(class구조, method, constructor 등등)을 저장하는 영역입니다. 특히 static 으로 선언된 변수가 이 영역에 저장된다는 사실을 기억해 두기 바랍니다.
  • run time constant pool : run time constant pool 은 method area 내부에 존재하는 영역으로, constant,  class 및 interface의 symbolic reference table 정보 등을 저장하고 있습니다.
  • heap : run time 에 동적으로 할당되는 데이터가 저장되는 영역입니다. heap에 할당된 데이터는 gc의 대상입니다.

지금부터 설명하는 내용이 중요합니다. run-time data area 내에서 어떤 영역은 프로세스 내의 모든 thread 들이 공유하는 반면, 어떤 영역은 각 thread 마다 독립적으로 생성됩니다. 여기서 thread 간에 공유되는 리소스 영역이 중요합니다. 극단적으로 말하면 모든 쓰레드 문제는 동기화 문제이며, 모든 동기화 문제는 공유 리소스로부터 발생합니다.

run-time data area 에서 다음 영역은 process 내 모든 thread가 공유합니다.

  • method area
  • run-time constant pool
  • heap

다음 영역은 thread 1개 마다 독립적으로 1개씩 생성되며, 데이터는 공유되지 않습니다.

  • program counter register
  • stack
  • native method stack

runtimeArea2.PNG

java process

process 를 간결하고 정확하게 정의하자면, “program in execution”(=실행중인 프로그램)입니다.

process 가 실행되는 순서는 다음과 같습니다.

  1. jvm startup
  2. load class
  3. link class
  4. init class
  5. create class

java process의 동작 원리를 자세하게 설명하는 것은 본 문서의 목적을 넘어서므로 무얼 보고 공부해야 하는지 링크만 제공합니다.

java program execution

 

java8 consumer / supplier 를 이용한 builder pattern 구현

/ bahamoth2013 / 댓글 2개

개요

java8 feature에 대하여 실무에서 활용 가능한 수준으로 best practice 제공

시작하는 말

디자인패턴에 대한 흔한 오해 중 대표적인 한 가지가 “디자인패턴은 프로그램 언어 독립적이다.” 입니다.

허나 실상은 그렇지 않으며, 매우 언어에 종속적이어서 특정 언어에서 제공하는 기능을 면밀히 살피지 않으면

의도한 대로 코드가 동작하지 않을 수도 있고, 해당 언어만의 장점을 살리지 못하는 반쪽짜리 코드가 될 수도 있습니다.

java8 에 추가된 functional interface 중 consumer / supplier 를 이용하면 보다 직관적인 builder pattern을 구현할 수 있습니다.

먼저, 종래에 java에서 builder pattern을 어떻게 구현하는지 살펴보고, 여기에 java8 feature 를 추가하여 어떻게 더 나아지는지 살펴보겠습니다.

builder pattern?

왜 쓰나

디자인패턴을 공부할 때 항상 염두에 두어야 할 것이 있습니다.

이 패턴을 왜 쓰나?

무엇이 좋아지나?

무엇이 안좋아지나?

 

모든 문제를 한방에 해결하는 만능의 해법이란 존재하지 않습니다.

어떤 문제를 해결하기 위한 선택을 하면 반드시 trade-off 가 발생합니다.

 

스타크래프트에서, 미네랄을 먼저 채취하여 후반에 많은 병력을 생산하기 위한 12드론 2해처리 빌드는 초반 러시에 취약하다는 단점이 존재합니다.

반대로 초반에 병력을 상대보다 먼저 뽑는 4드론 빌드는 초반러시에 강력하나 후반으로 갈수록 취약합니다.

초반에 병력도 많이 뽑고, 미네랄도 많이 캐고, 후반 병력도 많이 뽑는 그런 마법과도 같은 해법이 존재할까요?

아니면 그때 그때 상황에 맞는 적절한 젼략을 사용해야 할까요?

 

예시가 즈질스러우니 국민 패턴 싱글톤 패턴을 예로 들어봅시다.

싱글톤으로 생성된 객체는 어플리케이션 실행~종료 시까지 어디에서나 접근 가능합니다.

어플리케이션 내부에서 공유하여야 할 리소스 정보를 쉽게 참조 가능하다는 장점이 존재하지만,

싱글톤 객체는 객체지향 언어 버전의 전역변수나 마찬가지여서

1) 싱글톤 객체 – 다른 객체간 의존성이 높아짐,

2) 인스턴스 생성의 책임이 분리되지 않기 때문에 SRP 위반,

3) unittest객체가 싱글톤 객체에 종속성이 발생하기 때문에 단위 테스트 어려움

등의 단점이 있습니다.

객체지향 5원칙 (aka. S.O.L.I.D)에 만족하는 싱글톤 패턴은 존재하지 않습니다. 싱글톤 자체가 태생적으로 SRP를 위반하기 때문이죠.

허나 파일경로, ip주소 등 1) 쉽게 변경되지 않고, 2) 어플리케이션 영역 전체에 공유가 필요한 리소스는 싱글톤으로 구현하는 편이 유리합니다.

 

GoF 의 디자인패턴에 소개된 모든 패턴은 저마다 장/단점이 분명합니다.

각 패턴의 장/단점이 무엇인지 분명히 알면 장점은 부각시키고 단점은 최소화할 수 있습니다.

장점은 살리고, 단점은 감춘다. 이것이 좋은 소프트웨어 아키텍트가 갖추어야 할 설계 역량입니다.

 

이 글에서 소개할 디자인 패턴은 builder 패턴입니다. 빌더 패턴을 쓰는 이유는 크게 2가지입니다.

1) 귀찮아서

2) 보기 좋으라고

 

다음과 같은 class foo 를 가정해 봅시다.

귀찮은 class 생성
public class foo {
    private String a;
    private String b;
    private String c;
    private String d;
    private String e;
    private String f;
    private String g;
    private String h;
    private String i;
    private String j;
    private String k;
    private String l;
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.d = d;
        this.e = e;
        this.f = f;
        this.g = g;
        this.h = h;
        this.i = i;
        this.j = j;
        this.k = k;
        this.l = l;
    }
}

new foo(a,b,c,d,e,f…,z) 하기 귀찮습니다. 또 생성자의 parameter 가 길어지면 실수나 오타를 발견하기도 어렵습니다.

 

빌더 패턴은 new foo(a,b,c,d,e,f…,z) 를 new builder().a(a).b(b)…build() 로 보기 좋게 바꾸기 위하여 사용합니다.

‘보기 좋게 바꾼다’고 표현했지만 실제로는 부수적으로 따라오는 몇 가지 장점이 더 있습니다.

1) 실수, 오타의 여지를 줄여줌

2) 생성 parameter에 제약조건을 부여할 수 있습니다. (e.g. 타입, 필수 여부 등등)

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 1

빌더 패턴의 가장 기본적인 아이디어는 객체 생성의 책임을 분리하는 데에 있습니다.

내가 만들려 하는 객체 생성의 역할을 다른 객체에 위임하는 것이죠.

 

builder pattern의 가장 기본적인 구현은 다음과 같습니다.

foo builder
public class fooBuilder {
    private String a;
    private String b;
    ...
    
    public fooBuilder setA(String a) {
        this.a = a;
        return this;
    }
    public fooBuilder setB(String b) {
        this.b = b;
        return this;
    }
    ...
    public foo build() {
        return new foo(this.a, this.b, ...);
}

 

위에서 작성한 fooBuilder class 를 사용하는 방법은 다음과 같습니다.

foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();

 

위에서 작성한 fooBuilder 클래스는 드닥 마음에 들지 않습니다. foo 객체를 생성하기 위해 불필요하게 fooBuilder 객체도 생성하여야 하니까요.

그러면 fooBuilder 의 메소드를 static으로 만들면 어떨까요? fooBuilder 객체를 생성하지 않아도 foo 객체를 생성할 수 있지 않을까요?

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 2

fooBuilder class를 이렇게 바꿔봅시다.

foo builder
public class fooBuilder2 {
    private String a;
    private String b;
    ...
    
    public static fooBuilder setA(String a) {
        this.a = a;
        return this;
    }
    public static fooBuilder setB(String b) {
        this.b = b;
        return this;
    }
    ...
    public static foo build() {
        return new foo(this.a, this.b, ...);
}
foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();
 
//builder2 사용
foo myFoo = fooBuilder2.setA(a).setB(b)...build();

불필요한 builder 객체 생성을 없앴습니다. 어떤가요? 잘 작동할까요?

절대 이딴 식으로 프로그래밍 하시면 안됩니다. 오밤중에 서버실 끌려가 밤새도록 디버깅하는 수가 있어요.

fooBuilder2 는 thread safe 하지가 않습니다. 따라서 concurrent 환경에서 foo 객체가 지멋대로 만들어 지는 수가 있어요.

concurrent 와 thread safety 얘기는 길어지니 다음에 따로 다루기로 하고, 암튼 fooBuilder2 는 실패실패 대실패입니다. 절때 이딴식으로 개발하면 안되요.

 

java8 feature 를 사용하지 않은 builder pattern, Ver. 3

서두에 언급하였듯, 디자인패턴은 언어 종속적입니다.

java 언어에서만 지원하는 특별한 feature(inner class) 를 사용하면 builder pattern을 좀 더 아름답게 구현할 수 있어요.

fooBuilder를 foo class 내에 static inner class 로 구현하는 겁니다.

foo builder
public class foo {
    private String a;
    private String b;
    ...
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        ...
    }
    public static class fooBuilder {
        private String a;
        private String b;
        ...
        fooBuilder() {}
        public fooBuilder setA(String a) {
            this.a = a;
            return this;
        }
        public fooBuilder setB(String b) {
            this.b = b;
            return this;
        }
        ...
        public foo build() {
            return new foo(a, b,...);
        }
    }
}
foo builder
//기존
foo myFoo = new foo(a,b,c,d,...);
 
//builder 사용
fooBuilder myFooBuilder = new fooBuilder();
foo myFoo = myFooBuilder.setA(a).setB(b)....build();
 
//builder2 사용
foo myFoo = fooBuilder2.setA(a).setB(b)...build();
 
//static inner class builder 사용
foo myFoo = new foo.fooBuilder.setA(a).setB(b)...build();

static inner class 로 객체 생성 코드를 보기 좋게 바꾸었지만 여전히 단점은 존재합니다.

1개의 foo 객체 생성을 위하여 반드시 1개의 fooBuilder 객체를 생성해야 하는 문제는 남아 있습니다.

메모리를 효율적으로 사용해야 하는 환경에서는 적합하지 않습니다.

또한 builder class가 inner class 로 포함되면서 클래스 재사용성에 대한 고민을 다시 해야 합니다.

 

java8 feature 를 사용한 builder pattern

지금까지

1) GoF가 처음 제안한, 고전적 형태의 Builder pattern

2) java의 언어적 특징, static inner class 를 사용한 Builder pattern

을 살펴 보았습니다.

이번에는 java8에 추가된 functional interface 를 사용하여 builder pattern을 구현하는 방법을 소개할건데요.

시작하기에 앞서, java8의 Consumer / Supplier 가 무엇인지 알아보도록 합시다.

 

functional interface?

functional interface에 대하여 잘 모르는 분들이 많이 계시리라 생각되어 간단히 소개합니다.

함수형 언어의 가장 큰 특징 중 하나가 function(=method) 을 변수처럼 사용하는겁니다.

 

예를 들면,

var foo = someFunction(); //함수 definition에 대한 reference
 
var foo = (x) -> x*x; //definition이 없는 함수(=익명함수)에 대한 reference

 

예제에서의 var foo 처럼 function을 저장하는 방법이 언어적으로 제공되어야 하는데요.

java8 이전의 java에서 L-value 에 위치할 수 있는 type 들(Object나 primitive type 등)은 function reference 에 대한 저장을 고려하지 않았습니다.

때문에 함수형 언어로의 확장을 위하여 java8은

1) var foo 와 같은 역할을 제공하는 새로운 type을 정의하던가

2) 아니면 기존에 제공하던 언어 기반을 크게 변경하지 않으면서 꼼수를 쓰던가

둘 중 하나를 선택하여야 했습니다.

 

java8 은 2) 를 선택하는 꼼수를 두었는데요. 그 꼼수가 functional interface 입니다.

java compiler는 @FunctionalInterface 라는 Annotation 이 포함된 다음 조건을 충족하는 interface를 위 예제의 var foo 처럼 취급하기로 약속하였습니다.

1) non-static method

2) non-default method

3) only 1 method in interface

@FunctionalInterface
interface var {
    void execute(String arg);
}
 
var foo = (x) -> System.out.println(x);
 
foo.execute("Hello");

참 쉽죠?

 

java8에선 기본적인 형태의 functional interface 를 미리 정의해 두었습니다.

Consumer / Supplier / Function / Predicate 4가지인데요.

각각 용도가 다릅니다만 자세한 것은 다음 기회에 다루도록 하겠습니다.

 

Consumer 를 사용한 builder pattern

기본적인 아이디어는 이렇습니다.

1) 생성하고자 하는 객체의 setter method 를 변수로 저장

2) 객체 생성 시 저장해 두었던 setter method를 실행하여 객체 생성

 

구현체는 다음과 같습니다.

foo builder
public class foo {
    private String a;
    private String b;
    ...
    public foo(String a, String b, String c, String d, String e, String f,
               String g, String h, String i, String j, String k, String l) {
        this.a = a;
        this.b = b;
        ...
    }
    public static class fooBuilder {
        private foo _myFoo;
        private List<Consumer<foo>> _setters = new ArrayList<>();
        public <T> fooBuilder with(BiConsumer<foo, T> setter, T val) {
          if (_myFoo == null)
               _myFoo = new foo();
         Consumer<foo> c = _myFoo -> setter.accept(_myFoo, val);
         _setters.add(c);
         return this;
       }
       public foo build() {
           foo val = _myFoo;
           _setters.forEach(_setters -> _setters.accept(val));
           _setters.clear();
           return _myFoo;
       }
    }
}
foo builder
//function interface 로 구현한 builder class 사용
foo myFoo = new foo.fooBuilder().with(foo::setA, "A").with(foo::setB, "B")...build();

 

위 패턴의 장단점을 살펴 볼까요?

장점은

1) 코드 재사용 : 생성할 Class 에 존재하는 setter 를 Builder Class에 중복으로 생성하지 않고 변수에 담아 재사용

 

단점은

1) 대동소이한 Builder를 매번 재구현하여야 함

 

Supplier / Consumer 를 사용한 builder pattern

위의 단점을 개선하여 봅시다.

Builder 코드를 재사용하여 생산성을 높이는 데에는 다음 두 가지 방법이 있습니다.

1) 상속을 통한 재사용

2) Generic을 통한 재사용

 

여기선 2) 방법으로 builder pattern을 고쳐 보겠습니다.

 

구현체는 다음과 같습니다.

generic builder
public class GenericBuilder<T> {
    private final Supplier<T> _instance;
    private List<Consumer<T>> _setters = new ArrayList<>();
    private GenericBuilder(Supplier<T> instance) {
        this._instance = instance;
    }
    public static <T> GenericBuilder<T> of(Supplier<T> instance) {
        return new GenericBuilder<T>(instance);
    }
    public <U> GenericBuilder<T> with(BiConsumer<T, U> consumer, U value) {
        Consumer<T> c = setter -> consumer.accept(setter, value);
        _setters.add(c);
        return this;
    }
    public T build() {
        T value = _instance.get();
        _setters.forEach(iter -> iter.accept(value));
        _setters.clear();
        return value;
    }
}
foo builder
//Generic builder class 사용
foo myFoo4 = GenericBuilder.of(foo::new)
        .with(foo::setA, "A")
        .with(foo::setB, "B")
        .with(foo::setC, "C")
        ...
        .build();

 

위 패턴의 장단점은 다음과 같습니다.

장점은

1) 코드 재사용 : GenericBuilder 클래스를 범용적으로 재사용 가능

 

단점은

1) inner class 를 사용할 때 보다 직관적이지 않다.

 

결론

여기서는 builder 패턴만 다루었지만 다른 패턴 공부도 위와 비슷하게 진행하시면 많은 도움이 될 겁니다.

이 패턴을 왜 쓰는지

내가 사용하는 언어에 특화된 구현 방법은 없는지

특히 java8 feature 를 사용할 여지가 있는지

java6 / java7을 쓰면 안되는 이유

/ bahamoth2013 / 댓글 한 개

개요

kth 내부 서비스 또는 kt 용역 서비스 중 상당수는 호환성이라는 명목 하에 java6 / java7 로 개발/유지보수하는 프로젝트들이 많이 있습니다.

물론 java6 / java7 로 개발한다고 잘 돌던 서비스가 당장 멈추거나 하는 일은 없을겁니다만

서비스 품질은 다음과 같은 측면에서 경쟁사에 뒤쳐진다고 보시면 됩니다.

1) 보안

2) 가용성

3) 호환성

4) 기술 역량

 

보안

oracle java6 의 End of Public Update 는 2013년 2월, java7은 2015년 4월에 종료되었습니다.

무슨 말인고 하면, 누군가가 java의 새로운 보안 결함을 발견한다면 java6 / java7 로 개발된 서비스는 더이상 보안 업데이트가 없다는 뜻입니다.

다음 사이트(oracle jre 링크)를 참고하시면, 지금까지 알려진 보안 결함 리스트를 보실 수 있는데요.

java6 은 대략 200여 개, java7은 대략 100여 개 정도의 보안 결함 업데이트가 없었습니다.

물론 네트워크 방화벽이라던지 정기 OS 패치 등으로 이중 삼중 보안 장치를 마련해 두고 있지만

때때로 이러한 모든 보안 장치를 무력화할 만한 대형 결함이 발견되기도 하는데, 그럴 때 동작하는 서비스가 java6 / java7 기반이라면 대책이 없습니다.

 

가용성

Interned String 문제

java6을 쓰면서 서비스에 특별한 장애 요소도 없는데 이상하게 보름에서 한달 정도 지나면 서비스가 내려가는 경험이 있으셨다면 십중팔구는 Interned String 문제입니다.

java6 과 java7/8 은 String pool 저장소가 근본적으로 다릅니다.

java6 이하 버전의 경우 신규 생성된 String은 PermGen 에 위치하며, 동일한 String의 경우 pooling 합니다.

 

PermGen 사이즈는 고정이므로(java8은 좀 다릅니다만),

1) 100bytes 사이즈의 서로 다른 값을 가진 String(e.g. 임시 발급 key, UUID 등등등)이

2) 100Mbytes 사이즈 PermGen

에 채울 수 있는 최대값은 100 * 1000 * 1000 = 100M 이므로

최대 100만 개의 String 이상 String이 신규로 생성되면 PermGen 영역이 가득차게 되고, 아래와 같은 익셉션과 함께 프로그램이 제대로 동작하지 않을겁니다.

exception

java.lang.OutOfMemoryError: PermGen space

 

java7부터는 String.intern() 메소드를 명시적으로 호출하지 않는 한, PermGen 영역에 String을 Poolling 하지 않습니다.

단지 jvm 버전을 올리는 것 만으로도 가용성 및 장애 요소를 한 가지 줄일 수 있습니다.

 

Fixed PermGen size 문제

허나, java7 이하 버전에서 여전히 PermGen size 는 고정이라는 문제가 존재합니다.

대개의 경우 String이 PermGen space를 잡아먹는 주된 요인이겠지만,

본래 PermGen의 주된 목적은 어플리케이션에서 사용되는(=load한) class 정보의 저장입니다.

java7에서 PermGen 사이즈를 적당히 크게 잡아줄 경우, PermGen이 고갈되는 경우는 왠만해선 발생하지 않겠습니다만

다음과 같은 시나리오에서는 PermGen이 고갈됩니다.

1) classloader 가 동적으로 신규 class를 지속적으로 load

2) 프로그램 사이즈가 정말 커서 많은 class가 필요

PermGen 사이즈는 고정이라는 원죄가 있기 때문에 jvm 옵션으로 PermGen 사이즈를 조정하더라도 항상 문제가 발생할 여지가 있습니다.

java8 에서는 PermGen 이 사라진 대신 해당 역할을 metaspace가 대체합니다.

차이점은 다음과 같습니다.

1) metaspace의 메모리 영역은 native 입니다.

2) memory가 부족하면 동적으로 할당 가능합니다.

 

cf) PermGen?

2015년도 신입사원 교육자료 중 2일차, dependency hell 작성할 때 그려둔 native application 의 memory 모델입니다.

물론 java와 디테일에는 차이가 있지만, Heap / Stack / Data / Code 섹션에 대한 포괄적인 개념은

java나 native나 혹은 이후 여러분들이 접하게 될 어떤 언어라도 대동소이합니다. 하나만 제대로 알고 있으면 되겠죠?

위 메모리 모델은 내가 짠 프로그램이 실제로 어떻게 작동하는지 알고 싶은 개발자라면 반드시 대가리헤또에 필수 탑재되어 있어야 합니다.

메모리 모델

stack : 프로그램의 흐름(=function call), local 변수 등을 저장

heap : 프로그램 내에서 동적으로 할당한 데이더를 저장

data : 전역변수를 저장

code : 프로그램 메타정보(=function meta) 등을 저장

각 메모리 영역별로 역할이 주어져 있지만, 가장 중요한 핵심은

1) 어플리케이션 시작 전에 사이즈를 결정할 수 있는 영역과(code / data)

2) 어플리케이션 실행 도중에 사이즈가 변경되는 영역(stack / heap)

이 분리되어 있다는 점입니다.

 

디테일은 다르지만 자바 메모리모델도 어플리케이션 시작 전에 사이즈를 결정할 수 있는 영역과 그렇지 않은 영역으로 구분됩니다.

다만, PermGen 영역의 정체성이 모호한데요.

본래 의도대로라면 PermGen 영역은 런타임에 증가되어선 안되는 영역입니다만 몇 가지 경우에 예외를 두었고

그 예외 때문에 자바 어플리케이션은 지금까지 고통받아 왔습니다.

 

java memory model

아래 그림은 어떤 존잘님께서 그린 java 메모리 모델입니다. (출처 : http://javarevisited.blogspot.com/2011/04/garbage-collection-in-java.html)

1) java7 이하 메모리 모델

2) java8 메모리 모델

 

Compressed Ordinary Object Pointer default enabled

jvm에는 Ordinary Object Pointer, 줄여서 OOP(객체지향 프로그래밍과 혼동 금지!, 보통 hotspot oop 라고 부릅니다.)에 대한 압축을 enable / disable 하는 옵션이 있습니다.

hotspot oop 는 기회가 된다면 나중에 따로 다루겠지만, 간단히 요약하면

데이터의 주소 정보를 효율적으로 쓰기 위한 꼼수

라고 보시면 됩니다.

compressed oop 옵션은 java7부터 default enabled 입니다.

만일 64bit 플랫폼 환경에서 java6을 쓰신다면 어플리케이션 실행 시 이 옵션을 enable 하여야 메모리를 좀 더 효율적으로 쓸 수 있습니다.

 

호환성

신규 버전의 java 에는 보안 / 기능 / 성능 / 정책 위배 등 여러가지 사유로 과거 버전중 deprecated 되는 API들이 발생합니다.

java6 또는 java7에서 java8로 올리지 못하는 여러 가지 이유중에는 deprecated API에 대한 호환성 문제가 꽤 비중이 높은 편인데요.

당장 deprecated API를 수정할 여력 없이 운영만 하는 서비스는 현실적으로 java 버전을 높이기 어려운 것이 사실입니다.

허나 신규 프로젝트에서 deprecated API 를 사용하거나, 해당 API를 사용한 library 를 쓰는 일은 없어야 합니다.

이미 배포한 API를 없앤다는 건 정말 어려운 일입니다. 그래서 보통은 왠만하면 해당 API를 없애지 않고 구현을 변경하거나 다른 더 좋은 구현을 만들어내 해당 API 사용률을 낮추도록 유도합니다.

그럼에도 불구하고 API를 없애는 결정을 했다는건 정말 그 API를 쓰지 말아야 할 중대한 이유가 있기 때문에 없애는 겁니다.(쓰지 말라면 쓰지 마루요)

아래 링크는 oracle에서 제공하는 java7 / java8 의 deprecated 된 api 리스트 및 java8 호환성 guide 문서입니다.

호환성

java7 deprecated APIs : https://docs.oracle.com/javase/7/docs/api/deprecated-list.html

java8 deprecated APIs : https://docs.oracle.com/javase/8/docs/api/deprecated-list.html

java8 호환성 가이드 : http://www.oracle.com/technetwork/java/javase/8-compatibility-guide-2156366.html#A999081

 

기술역량

modern language 열풍이 분지 올해로 10년 쯤 지났습니다.

무수히 많은 modern language가 생겨나기도 하였지만, 기존 language들이 modern language 의 철학을 담는 경우도 종종 있었습니다.

java는 다른 언어에 비해 modern language의 주요 개념, 기능 등을 담아내는 시점이 매우 늦은 편입니다.

심지어 java보다 30년은 오래된 c++이 오히려 java보다 100만배는 modern 합니다.

 

현대의 소프트웨어 개발 환경은 몇 가지 특징이 있습니다.

1) 과거에 비해 어플리케이션의 규모 / 복잡도가 기하급수적으로 높아졌습니다.

2) 난립하는 하드웨어에 효율적으로 대응하기 위한 수단이 필요합니다.

3) 더이상 수직적인 하드웨어 성능은 높아지지 않습니다. 허나 처리해야 할 데이터의 양은 엄청나게 늘었습니다.

 

과거, 구조적 프로그래밍의 한계를 객체지향 프로그래밍으로 극복한 시절이 있었습니다.

현재는 객체지향 프로그래밍의 한계에 다다랐다고 보아도 과언이 아닙니다.

우리가 쓰는 대부분의 CPU 는 멀티코어 프로세서로 설계되었습니다.

허나 객체지향 언어로 멀티코어 성능을 온전히 내는 어플리케이션을 만들기는 매우 어렵습니다. 디버깅은 100만배 더 어렵습니다.

 

과거, 비동기 네트워킹은 시스템 프로그래머만의 전유물이던 시절이 있었습니다.

현재는 클라이언트 프로그래머도 비동기 처리의 동작 원리를 반드시 이해하여야 합니다.

비동기 처리는 반드시 OS의 지원 / 프로그램 언어의 지원이 필요합니다.

 

modern language 에는 다음과 같은 몇 가지 공통적인 특징이 있습니다.

1) 함수형 프로그래밍 패러다임 수용

2) 불필요한 코드 노가다 지양

3) 강력한 type 추론

4) lazy execution 을 구현하기 위한 효율적인 수단 제공

5) REPL(Read – Evelauation – Print – Loop) 또는 준하는 어플리케이션 확인 수단 제공

6) thread local stack 에 대한 디버깅 수단 제공

 

java8 도 많이 늦은 편인데 이러한 소프트웨어 개발 환경의 변화를 java6 / java7 로 대응한다? 쉽지 않습니다.

지금으로부터 약 40여 년 전, 프로그래밍 세계를 평정하던 cobol이라는 언어가 있었습니다.

당시 두터운 사용자/커뮤니티층을 형성하던 cobol 개발자들은 굳이 OOP 를 학습할 필요성을 느끼지 못하였습니다.

c++이 출시되고 채 10년이 못되어 cobol 어플리케이션은 씨가 말랐고, OOP는 대세가 되었습니다.

요즘의 java를 보면서 과거 cobol의 역사가 자꾸 오버랩되는 것은 우연의 일치일까요?

 

요약

java8 써라. 두번 써라.