삐멜 소프트웨어 엔지니어

[일일회고] Python Platform으로 OS찾아내기

삐멜 — Sat, 16 Dec 2023 11:25:17 +0900

오늘의 문제

요즘 AWS Quicksight으로 대시보드를 만들고 있다. 파이썬으로 AWS Athena에 쿼리를 날리고, 그 결과를 가공해 S3버켓으로 올린다. 그러면 그 결과를 Quicksight DataSet으로 받아서 대시보드를 만드는 것이다. 그래서 이번 한 주간 (잘 못하는...) 파이썬으로 열심히 스크립트를 짰는데, 문제가 생겼다. 첫번째는 이 스크립트를 매일 실행하려면 AWS에 올려야되는데, 그 때는 credential을 인스턴스의 것으로 쓰고 싶고, 로컬 환경에서 테스팅 할 때는 다른 라이브러리에서 credential을 받아오고 싶다. 안그러면 테스팅 할 때 마다 체크해야하고... 코드를 예쁘게 짠게 아니라 여기저기 실수하게된다. 그래서 파이썬에서 플랫폼을 확인 할 수 있는지 알아보았다.

오늘 배운 것

플랫폼 관련된 정보를 주는 파이썬 라이브러리가 여러가지 있다.

os라이브러리를 먼저 봤는데, 이건 값이 posix로 리턴돼서 사용하지 못했다.

import os
print(os.name)

그 다음으로는 platform라이브러리가 있다.

import platform
print(platform.system())
print(platform.machine())

각 함수가 아래와 같이 반환했다. 맥은 Darwin을 반환한다고 한다.

Darwin
arm64

마지막으로 sys.

import sys
print(sys.platform)

마찬가지로 darwin을 반환했다.

나는 결국 platform라이브러리를 사용했다. 대략 아래와 같은 간단한 코드다.


if platform.system() == 'Darwin' :
    __PLATFORM__ = 'local'
else :
    __PLATFORM__ = 'staging'

레퍼런스

https://stackoverflow.com/questions/1854/how-to-identify-which-os-python-is-running-on

[일일회고] Athena Presto CASE 문, String Split함수

삐멜 — Wed, 13 Dec 2023 14:19:17 +0900

회고의 계절이 돌아왔다. 그래서 회고를 해보려는데 기억이 안난다. 일년간 뭘 배웠는지, 뭘 했는지 정말 기억이 나지 않는다. 분명히 새로운 것을 많이 배웠는데 여러가지 문제를 많이 해결했는데, 그 당시 문제 해결 할 때만 반짝 검색해서 쓰고 그 다음에는 기억이 안나서 또 검색하고 있다. 그래서 앞으로 배운게 있으면 짧게라도 정리해서 올려볼까 생각중이다. 기술 문제가 될 수도 있고, 프로세스나 사람간의 문제가 될 수도 있다.

오늘의 문제

요즘 데이터 분석 및 시각화를 하느라 Athena Presto 쿼리를 짜고 있다. 그 중 오늘 짠 쿼리에서, 문자열(스트링) 컬럼의 일부 정보를 다른 대체문자로 변경해야 하는 문제가 있었다. 예를들어 문자열은 ‘id-type-property-something_else’ 이런 식이고, 나는 property를 적절한 이름, 예를들어 P1, P2 등으로으로 바꾸고 싶었다.

두가지 방법을 고려했다. 첫번째 방법은 문자열을 ‘-’로 쪼갠 후(col_arr이라고 하자) 배열의 위치 [’id’, ‘type’, ‘property’, ‘something_else’]이면 col_arr[3]으로 빼내는 것이다. 그런데 이렇게 해 보니 property의 위치가 제각각이라 모든 케이스를 고려하기 힘들었다. 어쩔대는 property가 배열의 마지막에, 마지막에서 두번째에, 세번째에, 이렇게 가지가지였다. 두번째 방법은 그냥 자바의 contains와 비슷한 기능을 써 원하는 문자열을 포함하는 행들을 찾아내고, case문을 이용해 적절히 값을 고치는 것이다. 이 경우 카테고라이징을 제대로 안하면 데이터가 전부 ELSE로 가 버릴 위험이 있다. 그러나… 두번째 방법이 더 간단해서 그냥 두번재 방법으로 하되 검증을 해보기로 했다.

오늘 배운 것

Athena Presto 쿼리에서 CASE문 작성하는 법[출처]. Athena Presto N년차지만... 아직도 기본적인 SQL이 아니면 검색해야한다. 그래서 정리해서 남기기로 한 것.

SELECT CASE column_to_be_matched
WHEN 'value_A' THEN 'the_replacement_of_value_A'
WHEN 'value_B' THEN 'the_replacement_of_value_B'
WHEN 'value_C' THEN 'the_replacement_of_value_C'
ELSE 'default'
END
FROM some_table

내가 오늘 작성한 쿼리에서는 아래와 같은 방식으로 쓰였다.

SELECT id, (CASE 
 WHEN col LIKE '%property_1%' THEN 'P1'
 WHEN col LIKE '%property_2%' THEN 'P2'
 ELSE col) as "type"
END
FROM some_table

조금 헤맨 부분은, 예제와 달리 WHEN 내부 자체의 결과물이 boolean인경우에는 CASE 다음에 아무 값도 지정하지 않는다는 것이다. CASE 다음에 값을 넣으면 WHEN 다음에 나오는 값과 비교하게 되는 것 같다.

이렇게 하고, 아래처럼 GROUP BY로 각 타입마다 갯수가 얼마인지 세, 내가 찾지 못한 type이 있는지 확인했다. property_1이나 property_2가 아니면 전부 col 그대로 들어가기 때문이다.

SELECT "type", count(distinct id) 
FROM 
(SELECT (CASE 
 WHEN col LIKE '%property_1%' THEN 'P1'
 WHEN col LIKE '%property_2%' THEN 'P2'
 ELSE col) as "type"
END
FROM some_table) 
GROUP BY "type"

이 쿼리로 잘못된 부분을 정정하고 마지막 ELSE 부분을 원하는 값으로 전부 바꿨다.

추가로 쪼개는 함수도 알아보았는데.. split이 문자를 배열로 쪼개는 함수이다. 배열을 리턴한다.

split(string, delimiter)

cardinality는 배열의 길이 리턴한다. 따라서 아래는 쪼개놓은 배열의 길이를 가져오는 방법.

cardinality(split(string, delimiter))

이건 배열의 마지막 요소 반환. Athena Presto의 배열 인덱스는 1부터 시작한다.

split(string,delimiter)[cardinality(split(string, delimiter))]

개발자가 이해하는 Large Language Model

삐멜 — Mon, 23 Oct 2023 07:21:54 +0900

LLM(Large Language Model) 이란?

Free Stock photos by Vecteezy (https://www.vecteezy.com/free-photos)

주의!

나는 인공지능 전문가가 아니다. 그냥 여기저기서 주워듣고 배운 것을 정리해서 쓰는 것일 뿐이다.

세상이 LLM으로 핫하다. LLM을 기반으로 한 스타트업도 우후죽순으로 생겨나고 있다. 우리 같은 보통 사람들에게는 생소한 단어일 수도 있다. LLM. Large Language Model. 우리에게는 ChatGPT 또는 Generative AI와 같은 단어가 더 익숙하다. 맥킨지에서는 매일 Generative AI에 대한 뉴스레터를 보낸다. 책도 많이 나온다, AI 어쩌고, 챗GPT 저쩌고, 앞으로 글 쓰는 직업은 없어질 것이다, 그림을 그리는 직업도 사라질 것이다, 이러쿵저러쿵 말이 많다. Large Language Model, 그래서 뭘까? LLM은 이름 그대로, 커다란 사이즈의 언어를 처리할 수 있는 자연어 처리 모델이다.

그런데… 자연어 처리, 우리에게 이미 익숙한 것이다. Hey Siri? Hey Google? 말이다. 그러면 LLM, 대체 그들과 뭐가 다를까? 그냥… 또 다른 인공지능 아닌가? 조금 더 빠른 트레이닝, 그런건가? 이게 궁금해서, 어느 날 나는 ChatGPT에게 물어봤다.

“Large Language Model이 뭔지 설명해줘.”

Large Language Model은 대량의 텍스트 데이터를 학습하여 인간과 유사한 언어 이해와 생성 능력을 갖춘 인공지능 모델을 말합니다. 이 모델들은 수억 개에서 수조 개의 텍스트 문장을 학습하여 문장의 패턴, 어휘, 문맥 등을 이해하고 이를 활용하여 질문에 답하거나 문장을 생성할 수 있습니다.
이러한 모델은 주로 딥러닝 기술 중 하나인 순환 신경망 (Recurrent Neural Networks, RNNs) 또는 트랜스포머 (Transformer) 아키텍처를 기반으로 합니다. 트랜스포머 아키텍처는 특히 언어 모델링에 뛰어난 성능을 보이며 최근 대부분의 대형 언어 모델은 이 아키텍처를 기반으로 합니다.
이러한 Large Language Model은 자연어 이해, 기계 번역, 질의응답 시스템, 문서 요약, 텍스트 생성, 대화형 시스템 등 다양한 응용 분야에서 사용됩니다. 그중에서도 GPT (Generative Pre-trained Transformer) 시리즈와 BERT (Bidirectional Encoder Representations from Transformers) 모델은 널리 알려져 있습니다. 이러한 모델들은 많은 양의 텍스트 데이터를 학습하여 일반적인 자연어 처리 과제에서 높은 성능을 보이며, 지속적으로 연구와 발전이 이루어지고 있습니다.

ChatGPT는 이렇게 답했다. 그런데 나처럼 평범한 개발자가 이해하기에는 모르는 단어가 너무 많았다. 딥러닝? 순환 신경망? 트랜스포머? 모델? 내가 자주 헷갈리는 용어들이 많았다. 머신러닝을 얕고 넓게 공부한 게 N 년 전이라, 기억나는 것도 없었다. 모델은 무엇인가? 머신러닝 알고리즘은 무엇인가? 딥러닝은 무엇인가? 기초부터 차근차근, 다시 읽어보기로 했다.

모델(Model)

일단, LLM이 인공지능 모델이라는 것은 ChatGPT의 대답으로 유추할 수 있다. 그런데, 모델이라는 게 정확히 뭘까? 인공지능에서 모델이란 공식(Formula)을 뜻한다. 예를 들어, y=ax+b라는 것이 모델이 될 수 있다.

내가 이해하는 머신 러닝이란 많은 양의 데이터에서 귀납적으로 공식을 추출해 내는 것이다. 예를 들어

변수	데이터1	데이터2	데이터3	데이터4
x	1	2	3	4
y	3	5	7	9

이런 데이터가 있다면 우리는 a=2 b=1 이란걸 쉽게 유추할 수 있다. 또는! 고등수학이나 선형대수에서는

3 = a+b

5 = 2a + b

처럼 연립방정식을 만들어, 소거법 (또는 가우스-조르단 소거법)을 사용해 해결한다. 이렇게, ‘법’이라고 부르는 것, a와 b를 구하기 위해 하는 행위, 그 행위를 ‘머신 러닝 알고리즘’이라고 한다(한다-기 보다는 나는 이렇게 이해하고 있다).

정리를 하면 이렇다.

머신 러닝 알고리즘은 데이터를 이용해 연역적으로 a와 b를 찾아낸다.
모델은 y=2x + 1과 같은 머신 러닝 알고리즘의 결과물이다.

일반적으로 머신러닝에서는 이런 a와 b를 모델 파라미터 또는 가중치(weight)라고 부른다.

위의 y=ax+b 또는 조금 일반적으로 말해 위처럼 일차항의 다항식으로 된 형태의 모델을 선형 모델이라고 한다. 마찬가지로 ax^2…처럼 이차항이 나오기 시작하면 Polymonial 모델이 된다. 선형모델을 쓸 수 있는 경우가 뭐가 있을까? 예를 들면, 어떤 사람의 연봉과 빚을 인풋으로, 신용카드의 승인여부를 결정하는 경우가 있을 수 있다. y = a*(연봉) + b*(빚) 이렇게 말이다.

이런 모델을 만들어 주는, 즉 데이터를 인풋으로 받아서 모델의 가중치, 또는 파라미터를 결정해 주는 알고리즘에는 여러 가지가 있다. 예; Linear Regression, Logistic Regression등, 인공지능에 관심이 있었다면 한 번쯤 들어봤을 수도 있다. 이런 알고리즘 중 하나가 바로 딥러닝이다.

딥러닝(Deep Learning)

그렇다면 딥러닝이 Linear Regression이나 Logistic Regression와 같은 모델들과 다른 점은 무엇일까? 딥러닝은 인공신경망(Artificial Neural Network)을 이용해 모델을 만든 것이다. 다시 말해 인간의 신경을 본떠 만든 프로그램인 것이다.

인간의 신경은 뉴런과 시냅스로 연결되어 있다. 그리고 이렇게 연결된 뉴런과 시냅스들이 신경망(Neural Network)을 이룬다.

이렇게 연결된 신경망의 뉴런으로 들어온 자극은 전기신호(활동 전위)가 되어 시냅스를 통해 다른 뉴런으로 전달된다.

인간의 뇌는 어떤 행동을 반복할수록, 그 부분을 관장하는 뉴런 사이의 결속이 강해진다고 한다. 그리고 이런 결속이 반복되어 강해지면 기억이 된다. 나는 이, ‘기억’이라는 것, 또는 반복되어 강해진 결속을 인공신경망의 가중치로 이해하고 있다. 인공 신경망도 이런 인간의 신경망과 비슷하게 작동한다.

(image by @ShadeDesign)

딥러닝이라고 부르는 인공신경망은 Artificial Neural Netowork 그림(image by @ShadeDesign)처럼 생겼다. 그리고 각 노드가 하나의 작은 모델 또는 함수가 된다. 그리고 이 작은 모델들이 네트워크를 만들고, 노드의 개수를 줄여가다, 마지막 아웃풋 레이어에서 결과 값이 나온다. 동그란 부분은 신경세포의 핵(Cell Nucleus) 부분과 화살표는 Axon/Synapse와 닮아있다. 선형모델이나 다른 모델과 비교했을 때, 작은 모델의 집합으로 구성되어있으니 리소스가 많이 필요하겠네, 라는 생각이 먼저 든다.

딥러닝에서 ‘러닝’이란 이 각각의 노드의 함수의 파라미터 또는 가중치들을 찾는 것을 의미한다. 그리고 Large Language Model이란 방대한 양의 언어 데이터를 처리할 수 있는 인공신경망과 이런 방대한 양의 데이터를 효율적으로 처리해 가중치를 찾아낼 수 있는 알고리즘(예; 트랜스포머 아키텍처)의 결과물이다. LLM의 예로 PaLM, BERT, XLNet, GPT 등이 있다.

트랜스포머 아키텍처(Transformer Architecture)

그렇다면 최근 LLM에 사용된다는 트랜스포머 아키텍처 무엇인가? 일단 ChatGPT에게 트랜스포머 아키텍처에 대해 물어봤다.

"트랜스포머 아키텍쳐에 대해 설명해 줘."

트랜스포머 (Transformer)는 딥 러닝 모델 중 하나로, 자연어 처리 작업에 사용되는 아키텍처입니다. 이 아키텍처는 2017년에 발표된 논문 "Attention Is All You Need"에서 처음 제안되었습니다. 기존의 순환 신경망(RNN)이나 장단기 메모리(LSTM)와 달리, 트랜스포머는 어텐션 메커니즘(Attention Mechanism)을 기반으로 하고 있어 긴 시퀀스를 처리하는데 뛰어난 성능을 보입니다.

트랜스포머 아키텍처의 핵심 아이디어는 **셀프 어텐션 메커니즘(self-attention mechanism)**입니다. 이 메커니즘을 사용하면 입력 시퀀스의 각 단어가 서로 다른 가중치를 가지게 되어, 문맥을 더 잘 파악할 수 있습니다. 아래는 트랜스포머 아키텍처의 주요 구성 요소에 대한 설명입니다:

어텐션 메커니즘 (Attention Mechanism): 트랜스포머의 핵심입니다. 어텐션은 입력 시퀀스의 각 위치에 대한 가중치를 계산하여 중요한 정보에 집중할 수 있게 해줍니다. 즉, 입력 시퀀스의 모든 단어가 서로 다른 정도로 각 단어에 영향을 주게 됩니다.

멀티헤드 어텐션 (Multi-Head Attention): 여러 개의 어텐션 헤드를 사용하여 병렬로 어텐션 연산을 수행하고, 그 결과를 합침으로써 모델이 여러 종류의 정보에 동시에 집중할 수 있게 합니다. 이는 모델이 여러 종류의 문맥을 파악할 수 있게 해줍니다.

포지션 인코딩 (Positional Encoding): 트랜스포머는 단어의 위치 정보를 고려하지 않기 때문에 단어의 상대적인 위치 정보를 모델에 제공하기 위해 포지션 인코딩을 사용합니다. 이를 통해 모델은 단어의 순서를 학습할 수 있습니다.

피드포워드 신경망 (Feed-Forward Neural Network): 트랜스포머 블록 내에는 각 위치마다 독립적으로 적용되는 피드포워드 신경망이 있습니다. 이 신경망은 각 위치마다 동일하게 적용되며, 입력을 출력으로 변환하는 데 사용됩니다.

트랜스포머의 이러한 구조는 긴 시퀀스를 처리하고, 병렬 계산을 효율적으로 수행하여 학습 속도를 향상시키며, 자연어 처리 작업에서 높은 성능을 보이게 합니다. 이 아키텍처는 기계 번역, 텍스트 생성, 질의 응답, 문서 분류 등 다양한 자연어 처리 작업에서 사용됩니다.

이해가 안 돼 다시 물어봤다.

"무슨 소리인지 전혀 모르겠어. 쉽게 설명해 줘."

물론입니다! 트랜스포머는 자연어 처리를 위한 특별한 유형의 컴퓨터 프로그램이라고 생각하시면 됩니다. 이 프로그램은 문장을 이해하고 새로운 문장을 만들 수 있는 능력을 가지고 있어요.
트랜스포머가 이를 가능하게 하는 핵심 아이디어는 단어 사이의 관계를 이해하는 것입니다. 예를 들어, "고양이는 신발을 신고 걷지 않는다"와 "신발을 신은 고양이가 걷지 않는다"는 비슷한 뜻을 가진 두 문장이 있을 때, 트랜스포머는 단어 사이의 중요한 연결을 찾아내어 제대로 된 이해를 할 수 있습니다.
이를 가능하게 하는 주요 기술 중 하나는 **어텐션(Attention)**입니다. 이것은 어떤 단어가 다른 단어에게 얼마나 더 중요한지를 알려주는 메커니즘이에요. 예를 들어, "나는 학교에 갔다"라는 문장에서 "학교"라는 단어가 중요하다면, 트랜스포머는 이를 어텐션을 통해 파악합니다.
또한, 트랜스포머는 문장 속 단어의 순서도 이해할 수 있어요. 예를 들어, "나는 밥을 먹었다"와 "밥을 나는 먹었다"는 뜻이 다르지요. 트랜스포머는 단어의 순서를 알기 위한 정보도 학습하게 됩니다.
이런 방식으로, 트랜스포머는 복잡한 언어 구조를 이해하고 새로운 문장을 생성할 수 있게 됩니다. 이러한 능력은 번역, 질문에 답하기, 글을 쓰기 등 다양한 자연어 처리 작업에서 사용됩니다. 기본적으로, 트랜스포머는 컴퓨터가 언어를 이해하고 사용할 수 있도록 도와주는 특별한 프로그램이라고 생각하시면 됩니다.

전자는 너무 어려웠고, 후자는 너무 쉬웠다. 특히 어텐션 메커니즘이나 멀티헤드 어텐션이 잘 이해되지 않았다. 게다가 과거의 모델들을 설명해 주지 않으니 더 이해가 안 됐다. 결국 나는 여러 가지 다른 페이퍼들을 읽고, 아래와 같이 이해했다.

트랜스포머 아키텍처는 Sequence to Sequence(Seq2Seq) 아키텍쳐 중 하나이다. Seq2Seq 아키텍쳐는 한 시퀀스, 예를 들면 문장, 을 다른 시퀀스로 변환해 주는 아키텍처이다. 대표적인 예로 한글 → 영문 번역 따위가 있다.

다른 모델과 비교 해보면 이 모델이 더 복잡할 수밖에 없다는 걸 알 수 있다. 아까 본 신용카드 모델은 파라미터가 두 개 밖에 없었다. 근데 Seq2Seq에서는 인풋의 길이가 얼마나 길지 모른다. ‘안녕하세요, 반갑습니다.’ 같은 짧은 문장일 수도 있고, 논문이나 기사 같은 장문의 글이 될 수도 있다.

이렇게, 시퀀스 베이스의 머신러닝이 어려운 이유는, 각 단어뿐만 아니라, 단어가 배열된 위치나 순서가 중요하기 때문이다. 각 단어 하나하나를 인풋이라고 가정했을 때, 이제 인풋뿐만 아니라 인풋의 배열까지 ‘학습’ 해야 하는 것이다. 따라서 적절한 가중치를 찾아내기 위해 알고리즘은 이전의 인풋들을 기억해야 하고, 그러므로 학습에 필요한 데이터와 그 데이터를 저장하고 처리하기 위한 리소스가 더 많이 필요하다. 이를 위해 보통 인풋의 시퀀스들을 전부 인코딩하는 방식으로 단기 기억이나 장기 기억을 지원하는 모델들(Recurrent/Convolutional Neural Network;시리나 알렉사도 이 모델 기반이라고 한다)을 사용했다고 한다. 그러나 이 모델은 중간에 기억을 잃거나[1] 트레이닝을 하는데 시간이 오래걸린다[2]고 한다.

트랜스포머 아키텍처의 핵심은 셀프-어텐션 메커니즘과 멀티헤드 어텐션인데, 이는 이전 모델처럼 시퀀스의 인풋 전부를 고려하기보다는 중요한 정보에 집중하는 것이라고 한다. 그래서 중간에 기억을 잃지 않는다. 또, 트랜스포머 아키텍처는 구조적으로 병렬 처리가 가능하여 자연어 처리에서 높은 성능을 보인다고 한다. 어떻게 중요한 정보인지 알아낼까? 아쉽게도 거기까지는 이해하지 못했다.

[1] Vanishing Gradient라고 Back Propagation을 하면 할수록 앞쪽으로 전파되는 값이 작아지다 결국 사라진다고 한다.

[2] LSTM 이 그렇다고 한다. 병렬처리가 되지 않는 점이 성능에 큰 영향을 미치는 것 같다.

마치며

내게 딥러닝은 고도의 기술이라 완전히 이해하는 것이 쉽지 않고, AI전문가가 아니기에 그럴 동기와 배경지식(!!)도 부족하다. 그러나 요새 트렌드가 트렌드인지라 LLM과 Generative AI에 대해서는 수박 겉핥기 식이라도 이해해 보고 싶었다. 예상했던 대로, 쉽지 않았다. 선형모델부터 다시 읽고, 딥러닝까지 오느라 고생을 했고, 어쩐지 LLM보다는 딥러닝만 열심히 복습한 느낌이지만 , 어쨌든 ~~기초가 중요하고!~~ 누가 물어보면 겉핥기로는 대답할 수 있게 되었으니 목표 달성이다!

참고자료

What’s the Difference Between Self-Attention and Attention in Transformer Architecture?

https://towardsdatascience.com/transformers-141e32e69591

https://medium.com/@eraiitk/brain-and-artificial-neural-networks-differences-and-similarities-1d337fe50168

https://medium.com/inside-machine-learning/what-is-a-transformer-d07dd1fbec04

https://colah.github.io/posts/2015-08-Understanding-LSTMs/

Attention is all you need - https://arxiv.org/abs/1706.03762

https://www.ibm.com/topics/deep-learning

https://www.techopedia.com/definition/34948/large-language-model-llm

https://www.techopedia.com/definition/34474/self-supervised-learning-ssl

https://towardsdatascience.com/the-fall-of-rnn-lstm-2d1594c74ce0

https://dennybritz.com/posts/wildml/recurrent-neural-networks-tutorial-part-3/

https://www.knowledgehut.com/blog/web-development/long-short-term-memory

https://medium.com/@amanatulla1606/vanishing-gradient-problem-in-deep-learning-understanding-intuition-and-solutions-da90ef4ecb54

Deep Learning - John D. Kelleher

3. 자바 조건문 (2) switch-case

삐멜 — Mon, 16 Mar 2020 14:03:13 +0900

Switch case는 조건에 따라 코드를 실행한다는 점에 있어서 if-else와 매우 유사하다. 만약 if-else를 모른다면 if-else를 먼저 학습한 후 switch-case를 공부하는 것을 추천한다.

예상 독자

자바를 배우고 싶은 누구나
JDK와 IDE를 설치한 자바 학습자. ( 1. 자바 설치 및 개발환경 설정 )
char를 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (1) char )
boolean을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (2) boolean )
byte, short, int, long을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (3) byte, short, int, long )
float과 double을 공부한 자바 학습자. ( 2. 자바 변수와 자료형 (4) float, double )
if-else를 공부한 자바 학습자. ( 3. 자바 조건문 (1) if-else )

목표

Switch Case 기본
Default case
한 Case 문만 실행 시키는 방법
enum을 이용한 switch-case

Switch Case 기본

Switch-Case문은 어떻게 생겼는지 아래의 예제를 통해 알아보자.

public class Main {
    public static void main(String args[]) {
        String str = "Hello";
        switch (str) {
            case "Hello":
                System.out.println("Case1 : Hello");
        }
    }
}

위 예제에서 switch는 str을 검사한다. (str == case에 걸린 값)가 참이라면 해당 케이스부터 switch의 끝까지 실행한다.

switch (variable) {
    case condition: { // case 블록  }
}

variable == condition인 경우 매칭되는 case블록 부터 스위치 블록의 끝까지 실행한다.
condition에는 constant값만 들어갈 수 있으며 논리식(>,<,==)은 지원되지 않는다.
variable과 condition의 자료형은 같아야 한다.
char, byte, short, int, Character, Byte, Short, Integer, String, enum 자료형만 사용할 수 있다.

스위치 블록의 끝까지 실행한다는 것은 무슨 뜻인가? 아래의 switch-case문을 실행시켜보자.

public class Main {
    public static void main(String args[]) {
        String str = "Hello";
        switch (str) {
            case "Hi":
                System.out.println("Case0 : Hi");
            case "Hello":
                System.out.println("Case1 : Hello");
            case "World":
                System.out.println("Case2 : World");
        }
    }
}

그 결과는 다음과 같다.

Case1 : Hello
Case2 : World

Hello 뿐만 아니라 World까지 출력되었다! Hi는 str과 다르니 출력되지 않았다고 하지만 World는 왜 출력되었을까? Switch-case는 case에 해당하는 블록만 실행하는게 아니라, 참인 case 아래로 전부 실행한다.

switch-case의 이러한 특성이 if-elseif-else와 가장 큰 차이점이라 할 수 있다.

Default Case

default case는 항상 참인 케이스이다. switch에 들어오는 변수가 무엇이 되었든 default case는 항상 실행된다. 그래서 사람들이 모든 케이스에 해당되지 않을 경우 실행시키기 위해 많이 사용한다.

public class Main {
    public static void main(String args[]) {
        String str = "-";
        switch (str) {
            case "Hi":
                System.out.println("Case0 : Hi");
            case "Hello":
                System.out.println("Case1 : Hello");
            case "World":
                System.out.println("Case2 : World");
            default:
                System.out.println("Default Case");
        }
    }
}
// 실행 결과
//Default Case

다만 주의할 점은 위에서 말했듯이 default case는 항상 참인 케이스일 뿐이며 동작 원리는 다른 case와 동일하다는 점이다. 예를들어 default를 case문의 맨 위에 놓으면 아래와 같은 결과를 확인 할 수 있다.

public class Main {
    public static void main(String args[]) {
        String str = "-";
        switch (str) {
            default:
                System.out.println("Default Case");
            case "Hi":
                System.out.println("Case0 : Hi");
            case "Hello":
                System.out.println("Case1 : Hello");
            case "World":
                System.out.println("Case2 : World");
        }
    }
}

결과

Default Case
Case0 : Hi
Case1 : Hello
Case2 : World

결과가 왜 이렇게 나왔을까 한번 생각 해 보도록 하자. 위에서 switch 변수 == case 값이 참이라면 해당 케이스부터 switch문 끝까지 실행시킨다고 설명했다. default 케이스는 항상 참이므로 default 케이스부터 아래까지 전부 실행시킨 것이다.

한 Case문만 실행시키는 방법

Break

한 케이스만 실행시키고 싶다면 break문을 사용해 case를 빠져나오는 방법을 사용할 수 있다.

public class Main {
    public static void main(String args[]) {
        String str = "Hello";
        switch (str) {
            case "Hi":
                System.out.println("Case0 : Hi");
                break;
            case "Hello":
                System.out.println("Case1 : Hello");
                break;
            case "World":
                System.out.println("Case2 : World");
                break;
            default:
                System.out.println("Default Case");
        }
    }
}

//결과
Case1 : Hello

break문을 사용하면 case에 해당하는 블록을 실행시킨 후 switch문을 빠져나온다.

return

switch-case문 실행 후 해당 매서드 내에서 더 실행 할 것이 없다면 메서드를 바로 return하는 방법도 있다.

public class Main {
    public static void main(String args[]) {
        String str = "Hello";
        switch (str) {
            case "Hi":
                System.out.println("Case0 : Hi");
                return;
            case "Hello":
                System.out.println("Case1 : Hello");
                return;
            case "World":
                System.out.println("Case2 : World");
                return;
            default:
                System.out.println("Default Case");
        }
    }
}

Enum을 이용한 switch-case

switch-case는 enum과 함께 자주 이용된다. 아래의 예제는 enum을 switch-case에 이용한 예제이다.

public class Main {

    public enum Greeting { HI, HELLO, WORLD };

    public static void main(String args[]) {
        Greeting greeting = Greeting.HELLO;
        switch (greeting) {
            case HI:
                System.out.println("Case0 : Hi");
                break;
            case HELLO:
                System.out.println("Case1 : Hello");
                break;
            case WORLD:
                System.out.println("Case2 : World");
                break;
            default:
                System.out.println("Default Case");
        }
    }

}

끝

이 포스트에서는 자바의 조건문 중 하나인 switch-case를 알아보았다. 다음 포스트에서는 배열과 반복문에 대해 설명하도록 한다.

다음 포스트 : 4. 자바 배열과 반복문 (1) array and for loo p

Call by value vs Call by reference

삐멜 — Sun, 1 Dec 2019 17:09:15 +0900

이번 포스트에서는 메서드 파라미터의 평가 전략(Evaluation Strategy)중 대표적으로 소개되는 Call by value와 Call by reference에 대해 설명하도록 한다.

Introduction

독자에 대한 몇 가지 가정

1. 이 글의 독자는 Java, C, C++를 어느정도 알고 있거나, 새 언어를 읽는데 큰 어려움이 없다.

2. 이 글의 독자는 포인터 *, &에 대해 약간 알고있다. (많이는 몰라도 됨..)

3. 독자의 이해를 최대한 돕기 위해 스택(Stack)과 힙(Heap)을 구분하지 않는다. 본인이 컴퓨터 아키텍쳐에 대해 잘 안다면 아래 내용중에 무엇이 스택에 생성되고 무엇이 힙에 생성되는지 스스로 찾아낼 수 있을 것이다.

4. 설명을 최대한 단순하게 하기 위해 레퍼런스와 주소를 동일한 개념으로 사용한다.

전제

1. 모든 변수는 메모리 공간에 존재하고, 메모리 주소가 있다.

예를들어 int variable = 3; 일 때, variable(=3)이 실제 존재하는 곳은 어떤 메모리 공간이고 그 메모리공간에는 주소가 있다.

Address   [     Value    ]
0x0000    [      3       ] // int variable = 3 ;
0x0001    [      5       ] // int another_variable = 5;

2. Caller vs Callee method/function

Caller method/function : 어떤 메서드를 call 하는 메서드.

Callee method/function : 어떤 다른 메서드에 의해 call되는 메서드.

e.g, 언어 = 자바

public void adderWrapper() { // adder의 caller
    int a = 1;
    adder(a);
}

public int adder(int x) { // adderWrapper의 callee
    x = x + 1;
    return x;
}

3. 메서드나 함수의 파라미터 변수(parameter variables)는 그 메서드의 로컬 변수(local variable)이다. 실제 로컬 변수와 다른 점은 caller 메서드/함수가 어떤 값을 넘겨주면 그 값으로 파라미터 로컬 변수를 초기화 해 준다는 점이다. 예를들어 위의 예를 다시 들면, 자바에서는 add(1); 의 경우 x = 1로 초기화한다. 로컬변수이기 때문에, 메서드가 리턴하면 로컬 변수는 사라진다.

3까지 이해하고 있다면 넘어가도 좋다.

Call by value

Call by value란 메서드를 call할때 넘겨주고 싶은 변수를 지정하면, 파라미터 로컬변수가 그 caller가 지정한 변수 값의 복사본으로 초기화되는 것이다. Call by value의 대표적인 언어인 Java로 설명 해 보도록 하겠다.

public void adderWrapper() { // adder의 caller
    int a = 1;
    System.out.println("value of a before adder :" + a);
    adder(a);
    System.out.println("value of a after adder :" + a);
}

public int adder(int x) { // adderWrapper의 callee
    x = x + 1;
    System.out.println( "value of x :" +x);
    return x;
}

위 코드의 초기 메모리 주소/값은 아래와 같다.

Address   [     Value    ]
0x0000    [      1       ] // int a = 1; 이라고 했다. 
0x0001    [              ] // int x;

adder(a); 처럼 파라미터에 넘겨주고 싶은 변수 이름인 'a'를 지정했다. 이 때 adder 메서드의 x는 무엇으로 초기화 되는가? 1 초기화 된다. a의 값인 1을 복사한 값으로 초기화 했으므로 call by value이다.

Address [     Value    ]
0x0000    [      1       ] // int a = 1; 이라고 했다.
0x0001    [      1       ] // int x는 1로 초기화됨;

위 코드의 결과 값을 보자.

value of a before adder :1
value of x :2
value of a after adder :1

왜 a의 값이 바뀌지 않았는가? adder메서드에서 어떤 변수의 값을 바꾸었나? 0x0001(x 의 주소)공간에 존재하는 값을 바꾸었다. 위의 메모리 구조를 보았을 때, 0x0001 공간에 있는 값을 바꾸는 것이 0x0000(a의 주소)에 어떤 영향을 미치는가? 그렇지 않다.

Address   [     Value    ]
0x0000    [      1       ] // int a = 1; 이라고 했다.
0x0001    [      2       ] // x의 값이 x + 1로 업데이트 됨.

이번에는 자바의 오브젝트를 예로 들어보자.

public void toStringObject() {
    Object o = new Object();
    printObject(o);
}

public void printObject(Object objToPrint) {
    System.out.println(objToPrint.toString());
}

위 코드의 초기 메모리 주소 값은 다음과 같다.

Address   [     Value    ]
0x0000    [    0x0001    ] // Object o = new Object(); // 새 Object 생성 후, 그 레퍼런스를 o에 저장함.
0x0001    [ new Object() ] // new Object()의 인스턴스가 존재하는 공간.
0x000A    [              ] // Object objToPrint

이제 printObject(o)에 넘겨주고싶은 변수 이름인 'o'를 지정했다. 이 때, printObject 메서드의 objToPrint는 무엇으로 초기화 되는가? 0x0001즉 o안에 들어있는 값으로 초기화된다. o의 값을 넘겨줬으므로 call by value이다.

Address   [     Value    ]
0x0000    [    0x0001    ] // Object o = new Object(); // 새 Object 생성 후, 그 레퍼런스를 o에 저장함.
0x0001    [ new Object() ] // new Object()의 인스턴스가 존재하는 공간.
0x000A    [    0x0001    ] // Object objToPrint는 new Object의 레퍼런스인 0x0001로 초기화됨.

믿기지 않는다면 아래의 예제를 확인해 보자.

public void adder(Integer x) {
    System.out.println( "value of x :" +x);
    x = new Integer(100);
    System.out.println( "value of x after new Integer(100) :" +x);
}

public void adderWrapper() {
    Integer a = new Integer(3);
    System.out.println("value of a before adder :" + a);
    adder(a);
    System.out.println("value of a after adder :" + a);
}

처음 Integer a = new Integer(3)을 선언하면 메모리 주소/값은 아래와 같을 것이다.

Address   [      Value     ]
0x0000    [     0x0001     ] // Integer a = new Integer(3) // 새 Integer 생성 후, 그 레퍼런스를 a에 저장함.
0x0001    [ new Integer(3) ] // new Integer(3)의 인스턴스가 존재하는 공간.

다음 adder(a)를 call하면 어떻게 될까?

Address   [      Value     ]
0x0000    [     0x0001     ] // Integer a = new Integer(3) // 새 Integer 생성 후, 그 레퍼런스를 a에 저장함.
0x0001    [ new Integer(3) ] // new Integer(3)의 인스턴스가 존재하는 공간.
0x000A    [     0x0001     ] // Integer x는  new Integer(3) 레퍼런스인 0x0001로 초기화됨.

위처럼 x를 위한 0x000A라는 공간에 a의 값인 0x0001을 복사해 넣을 것이다. 그리고 System.out.println("value of x : "+ x);를 실행 할 것이다. 그 후 x = new Integer(100)을 하면 어떻게 되는가?

Address   [      Value     ]
0x0000    [     0x0001     ] // Integer a = new Integer(3) // 새 Integer 생성 후, 그 레퍼런스를 a에 저장함.
0x0001    [ new Integer(3) ] // new Integer(3)의 인스턴스가 존재하는 공간.
0x000A    [     0x000B     ] // x는 new Integer(100) 레퍼런스인 0x000B로 없데이트됨.
0x000B    [new Integer(100)] // new Integer(100)의 인스턴스가 존재하는 공간.

new Integer(100)이 메모리 어느 공간(0x000B)에 생성되고 그 장소의 레퍼런스인 0x000B가 x에 할당될 것이다. 이후 메서드는 리턴한다. 메서드가 리턴하면 그 메서드에 존재하던 로컬 변수는 어떻게 되는가? 사라진다.

Address   [      Value     ]
0x0000    [     0x0001     ] // Integer a = new Integer(3) // 새 Integer 생성 후, 그 레퍼런스를 a에 저장함.
0x0001    [ new Integer(3) ] // new Integer(3)의 인스턴스가 존재하는 공간.

0x000B    [new Integer(100)] // new Integer(100)의 인스턴스가 존재하는 공간.

따라서 x는 사라지고 a의 값은 여전히 변하지 않은채로 있다.

Call by reference

Call by reference란 메서드를 call할 때 넘겨주고 싶은 변수를 지정하면, 그 변수의 레퍼런스로 파라미터 로컬변수를 초기화 하는것이다. Call by reference를 지원하는 언어 중 가장 대표적인 c++언어의 예를 보자.

void adder(int& x) { // 2) c++에선 int&로 선언된 변수가 레퍼런스 변수이다.
    x = x + 1;
    cout << "value of &x:" << &x << endl;
    cout << "(referenced) value of x :" << x << endl;
    return;
}

int main() {
    int a = 3;
    cout << "Address of a :" << &a << endl;
    cout << "value of a before adder :" << a << endl;
    adder(a); // 1) 나는 a(= 3)을 넘기는 것 같은데
    cout << "value of a after adder:" << a << endl;
}

위 코드의 초기 메모리 주소/값은 다음과 같다.

Address   [     Value    ]
0x0000    [      3       ] // int a = 3;
0x000A    [              ] // int& x;

[참고! int& x; 의 뜻은 x안에는 메모리 주소가 들어있고, x를 이용할 때는 컴퓨터가 자동으로 x안에 들어있는주소를 참조(레퍼런스)한다는 뜻이다. 따라서 x에 들어있는 레퍼런스를 따라간 값을 이용하고 싶다면 그냥 x를 이용하면 된다. 이런 변수를 레퍼런스 변수라고 부른다. (이제 위 예제가 왜 call by reference인지 알겠는가?)]

[참고! 같은 맥락에서 봤을 때 자바의 인스턴스 변수는 모두 레퍼런스 변수이다.]

이제 adder(a)에 넘겨주고싶은 변수 이름인 'a'를 지정했다. 이 때, adder 메서드의 &x는 무엇으로 초기화 되는가? 0x0000 즉 변수 a(=3)이 존재하는 공간의 메모리 주소인 0x0000 값을 초기화된다. 그리고 메서드 내부에서 참조된 값인 x를 이용할 수 있다. call by value와의 차이가 무엇일까?

메서드가 처음 call되면 아래와 같은 상태로 초기화 될 것이다.

Address   [     Value    ]
0x0000    [      3       ] // int a = 3;
0x000A    [    0x0000    ] // int& x = 0x0000

x = x + 1가 실행된 후에는 어떻게 되는가?

x = x + 1을 하면 &x에 있는 주소인 0x0000를 참조해 3을 가져오고 1을 더해서 다시 0x0000를 참조한 공간에 4를 넣을 것이다.

x는 int&형이므로 x = x + 1을 하는 경우 0x0000에 1 을 더는 것이 아니라 0x0000을 참조하여 얻은 값인 3에 1을 더해 0x0000주소의 공간에 할당한다.

Address   [     Value    ]
0x0000    [      4       ] // int a = 4;
0x000A    [    0x0000    ] // x = x + 1;

따라서 0x0000(a)의 값은 4가 된다.

위 코드를 실행 해 보면 아래와 같은 결과가 나온다. a의 주소값과 x의 주소값이 같은 것을 확인할 수 있다.

Address of a :0x7ffebace936c
value of a before adder :3
value of &x :0x7ffebace936c
(referenced) value of x :4
value of a after adder:4

이처럼 어떤 변수를 메서드/함수에 파라미터로 넘겼을 때, 이 변수의 레퍼런스가 복사되어 넘어가는 것을 call by reference라고 부른다.

QnA

*) 위의 call by value의 오브젝트 예에서 reference를 넘겨줬는데 왜 call by reference가 아니고 call by value인가?

많은 사람들이 이 부분을 혼동한다. 우리가 주목해야 할 것은 '누구의' value를 또는 '누구의' reference를 넘겨주냐이다. 어떤 변수를 넘겨주는데 그 변수안에 들어있는 값이 복사되어 들어간다면 call by value, 그 변수의 레퍼런스가 복사되어 들어간다면 call by reference이다. 그 변수의 값 자체가 레퍼런스인지 기본형(primitive)인지는 중요하지 않다. 오브젝트 예의 경우에는 어떤 변수의 값 자체가 레퍼런스인 경우이다.

*) C언어에서 포인터를 넘겨주는것은 주소를 넘겨주는 것이므로 call by reference가 아닌가? 아니다. 이유는 위의 자바와 비슷하다.

아래를 보자. 편의상 C++로 작성했으나 cout을 제외한 문법은 C와 같다.

void adderWithPointer(int* x) {
      *x = *x + 1;
      cout << "value of x :" << x << endl;
      return;
  }

  int main() {
      int a = 3;
      int *p = &a;
      cout << "value of p :" << p << endl;
      cout << "value of a before adder :" << a << endl;
      adderWithPointer(p);
      cout << "value of a after adder:" << a << endl;
  }

결과 값이 어떻게 나오는가? (주소는 매 실행마다 다름.)

value of p :0x7ffd46fdbc3c
value of a before adderWithPointer :3
value of x :0x7ffd46fdbc3c
value of a after adderWithPointer:4

adderWithPointer로 넣어주는 변수는 무엇인가? p이다. p라는 로컬변수에는 어떤 값(&a)이 담겨있다. 그 값은 0x7ffd46fdbc3c이다. p의 값 0x7ffd46fdbc3c이 복사되어 x에 들어갔으므로 이는 call by value이다. 하지만 여전히 p가 a를 레퍼런스할 수 있다는 점은 똑같지 않은가? 맞다. 이는 C언어가 포인터와 call by value의 특성을 이용해 call by reference를 시뮬레이션한 call by address이다. 이런 특성 때문에 포인터를 넘기는 것을 때때로 call by reference라고 부르기도 한다(하지만 엄밀히 말하면 call by value/call by address이다).

끝

call by value와 call by reference는 사람들이 많이 헷갈려한다. 또 인터넷에도 포인터 주소나 레퍼런스를 넘기면 call by reference라는 둥 정확한 설명이 많지 않고 정확히 설명한 경우가 드물다. 왜냐하면 call by value/call by reference를 더 깊기 이해하기 위해서는 메서드/함수 실행을 위한 스택이 어떻게 생성되는지, 로컬변수와 파라미터가 어떻게 생성되는지 등을 알아야 하고, C/C++의 포인터나 자바의 인스턴스 레퍼런스와 같은 개념을 알아야 하기 때문이다 (운영체제/시스템+컴파일러의 복합적인 이해가 필요하다). 따라서 위의 내용이 전부 이해되지 않더라도 괜찮다. 이에 대해 더 공부하고 싶다면 Computer Systems: Programmer's perspective같은 시스템 관련 서적이나 운영체제/컴파일러를 참고하도록 해라.

가비지 컬렉터(Garbage Collector)와 Mark & Sweep

삐멜 — Tue, 26 Nov 2019 15:58:37 +0900

이번 포스트에서는 JVM(Java Virtual Machine)의 메모리 관리방법에 대해서 약간 설명하도록 한다. JVM의 메모리 관리방법을 알기 위해서는 JVM이 무엇인지에 대해 먼저 알아야한다. 따라서 JVM에 대해 간단히 설명하고, JVM이 메모리를 관리하는 방법인 Garbage Collector와 Mark & Sweep 알고리즘에 대해 설명하도록 한다. 초심자를 위한 글이기 때문에 가비지컬렉터의 기본 원리만 설명하고 자바 메모리 모델에 대해서는 다른 포스트에서 다루도록 하겠다.

JVM(Java Virtual Machine)이란?

JVM은 프로그램이다. 이 프로그램에 자바 언어를 컴파일한 *.class파일을 인풋으로 줘 실행하면 JVM 프로그램이 실행하면서 입력받은 .class파일을 실행한다.

$ javac GarbageCollectorTutorialMain.java

위처럼 자바 파일을 class파일로 컴파일한다.

$ java GarbageCollectorTutorialMain

위처럼 컴파일된 클래스파일의 이름을 매개변수로 주며 JVM을 실행시킨다. 그러며 JVM이 실행하면서 GarbageCollectorTutorialMain.class를 실행한다.

JVM은 클래스파일을 실행시키는 것 외에도 다른 많은 작업들을 한다. 그 중 대표적으로 JIT 컴파일러[프로그래밍 언어, 컴파일러, 인터프리터 참고]가 있고, 또 가비지 컬렉터(Garbage Collector), 즉 메모리 관리가 있다. (다른것도 많다.)

가비지 컬렉터(Garbage Collector) - gc() 를 부르면 생기는 일

가비지 컬렉터가 하는 일은 간단하다, 사용되지 않는 메모리를 다시 사용할 수 있도록 하는 것(Memory Reclamation)이다. 이게 무슨 뜻인가? JVM이 할당된 모든 메모리를 가지고 있고, 이를 관리한다는 뜻이다. JVM 실행시에 JVM 프로그램 내부에서 Stack과 Heap이라는 메모리 공간이 생성(초기화)된다. 메서드는 Stack에서 실행된다, 따라서 로컬 변수들은 Stack에 생성되고, 자바의 오브젝트와 클래스들은 Heap 공간에 할당된다. 가비지컬렉터는 우리가 인풋으로 준 클래스파일을 실행하는 도중에 실행되며 Heap공간에서 더이상 참조(reference)되지 않는 메모리 공간을 수거한다.

주의! 메모리에서 말하는 Heap은 자료구조의 Heap과는 다른 개념이다. Heap메모리는 Stack과는 다르게 메모리를 중구 난방으로 할당/해제 할 수 있는 공간정도로 생각하면 된다.

마크 앤 스윕(Mark and Sweep)

가비지 컬렉터에는 GC Root라는 것이 있다. GC Root들은 힙 외부에서 접근할 수 있는 변수나 오브젝트를 뜻한다. GC Root는 말그대로 가비지 컬렉션의 Root라는 뜻이다. GC Root에서 시작해 이 Root가 참조하는 모든 오브젝트, 또 그 오브젝트들이 참조하는 다른 오브젝트들을 탐색해 내려가며 마크(Mark)한다. 이게 바로 가비지 컬렉션의 첫번째 단계인 Mark단계이다.

아래는 GC Root가 될 수 있는 것들이다.

1. 실행중인 쓰레드 (Active Thread)

2. 정적 변수 (Static Variable)

3. 로컬 변수 (Local Variable)

4. JNI 레퍼런스 (JNI Reference)

<Sweep후 Heap공간의 모습>

Mark가 끝나면 가비지 컬렉터는 힙 내부를 전체를 돌면서 Mark되지 않은 메모리들을 해제(Reclaim)한다. 이 과정을 Sweep이라고 부른다.

알고리즘은 간단하다. 좀더 자세한 예를 보자.

오브젝트 생성

일단은 JVM에서 오브젝트를 생성하는 경우 어떻게 되는지 보자.

예를들어 String str = new String("Hello World");라는 코드가 있다고 치자. 그러면 str이라는 변수가 스택(Stack)에 생기고 new String("Hello World") 오브젝트는 Heap공간에 생성된다. 그리고 str의 변수가 생성된 String 오브젝트를 참조(reference)한다.

<자바 메모리 할당>

Mark and Sweep

여기서 GC Root가 누군지 보이는가? GC Root는 바로 지역변수인 str이다. 가비지 컬렉터가 실행되면 GC root인 str이 참조하는 메모리인 new String("Hello World");를 Mark할 것이다. 이후 메서드가 리턴하면서 str이라는 변수가 사라지면 new String("Hello World");는 아무도 레퍼런스 하지 않게 된다. 따라서 다음 가비지 컬렉터 실행시 Sweep될 수 있다.

<GC될 가능성이 있는 오브젝트>

"Sweep 될 수 있다"라고 한 이유는 JVM 메모리 모델에 따라 당장 Sweep이 될 수도, 아니면 다른 공간으로 옮겨질 수도 있기 때문이다.

구현이 잘 와 닿지 않으면 아래처럼 생각해보자.

1. 어떤 변수나 오브젝트는 자기 자신이 참조하고 있는 다른 오브젝트 리스트를 가지고 있다.

2. JVM혹은 GC(가비지 컬렉터)는 힙(Heap)공간의 모든 오브젝트에 접근 할 수 있으며, GC Root 리스트를 가지고 있다.

3. GC는 Map<오브젝트 주소, boolean>를 가지고 있고 이 Map은 힙 공간의 모든 오브젝트의 주소, false로 초기화된다.

4. GC Root부터 시작해 위의 맵에 map.put(오브젝트주소, true)와 같이 Mark 할 수 있다.

5. Sweep은 이 맵을 탐색해 false인 오브젝트주소의 메모리를 수거한다.

실제로 일어나는 일은 가비지 컬렉터마다 다를 수 있고, 실제 Map<오브젝트주소, boolean>은 메모리가 너무 크므로 최적화된 다른 종류의 맵(ex, bitmap)이나 다른 구현방법을 사용할 수 있다. 하지만 지금 단계에서는 위처럼 이해해도 상관 없다.

이 포스트에서 더 이상의 자세한 내용은 다루지 않도록 하겠다. 더 깊이 공부하고 싶은 독자들은 JVM Memory Model에 대해 찾아보면 된다.

코드를 통한 GC 확인

import java.util.ArrayList;
import java.util.List;

public class GarbageCollectorTutorialMain {

    public static void main(String [] args) {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();

        for(int i = 0; i < 10000; i++) {
            list1.add("Random-String1" + Math.random());
            list2.add("Random-String2" + Math.random());
        }

        Runtime.getRuntime().gc();

        list1 = null; // remove the reference to list1
        Runtime.getRuntime().gc();

        list2 = null; // remove the reference to list2
        Runtime.getRuntime().gc();
    }
}

이해를 돕기 위해 코드 예제를 가지고 왔다. 가비지 컬렉터 로그를 보기 위해서는 프로그램 실행시 몇가지 매개변수를 넘겨주어야 한다.

▲javac GarbageCollectorTutorialMain.java

터미널에서 자파 파일이 존재하는 디렉토리로 들어가 자바 파일을 컴파일 하도록 한다. 컴파일 후 아래처럼 JVM 매개변수를 명시해 가비지 컬렉터 실행시 로그가 나오도록 한다.

▲ java -XX:+UseSerialGC -Xms16m -Xmx16m -verbose:gc -XX:+PrintGCDetails GarbageCollectorTutorialMain

-XX:+UseSerialGC : 여러가지 가비지 컬렉터중 SerialGC를 사용하라는 뜻.

-Xms16m 최소 힙 메모리 16 메가바이트

-Xmx16m 최대 힙 메모리 16 메가바이트 (일부러 작게 했다)

-verbose:gc 가비지컬렉터 로그 출력

-XX:+PrintGCDetails 실행 종료시 종료 당시의 메모리 상태 출력

실행하면 아래처럼 가비지 컬렉터의 로그가 출력 될 것이다.

[GC (Allocation Failure) [DefNew: 4416K->511K(4928K), 0.0036435 secs] 4416K->1547K(15872K), 0.0036715 secs] 
[Times: user=0.00 sys=0.00, real=0.00 secs] <- 메모리 할당을 하려는데 부족해서 GC를 실행했다는 뜻.
 [Full GC (System.gc()) [Tenured: 1035K->2633K(10944K), 0.0051777 secs] 4337K->2633K(15872K),  <- 첫번쨰 .gc()
[Metaspace: 3132K->3132K(1056768K)], 0.0052066 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [Tenured: 2633K->2085K(10944K), 0.0035206 secs] 2633K->2085K(15872K),  <- 두번째  .gc()
[Metaspace: 3132K->3132K(1056768K)], 0.0035610 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] 
[Full GC (System.gc()) [Tenured: 2085K->442K(10944K), 0.0018681 secs] 2085K->442K(15872K),  <- 세번째 .gc()
 [Metaspace: 3132K->3132K(1056768K)], 0.0018869 secs] [Times: user=0.00 sys=0.00, real=0.01 secs]
        Heap <- PrintGCDetils
        def new generation   total 4928K, used 44K [0x00000007bf000000, 0x00000007bf550000, 0x00000007bf550000)
        eden space 4416K,   1% used [0x00000007bf000000, 0x00000007bf00b218, 0x00000007bf450000)
        from space 512K,   0% used [0x00000007bf4d0000, 0x00000007bf4d0000, 0x00000007bf550000)
        to   space 512K,   0% used [0x00000007bf450000, 0x00000007bf450000, 0x00000007bf4d0000)
        tenured generation   total 10944K, used 442K [0x00000007bf550000, 0x00000007c0000000, 0x00000007c0000000)
        the space 10944K,   4% used [0x00000007bf550000, 0x00000007bf5be8b0, 0x00000007bf5bea00, 0x00000007c0000000)
        Metaspace       used 3139K, capacity 4496K, committed 4864K, reserved 1056768K
class space    used 333K, capacity 388K, committed 512K, reserved 1048576K

끝

질문이 많을 것이다. Mark라는게 정확히 어떻게 일어나는지, Sweep이 정확히 어떻게 일어나는지. 위 예제의 Eden, tenure, metaspace등이 무엇을 의미하는지 궁금할 것이다. 이 내용들은 한 포스트에 작성하기 힘들고 또 JVM내부 구현에 대해 설명해야 하기 때문에 초보자를 위한 포스팅에는 적합하지 않다. 이후 가비지 컬렉터(Garbage Collector)에 대해 더 심도있게 다루는 포스팅을 작성하도록 하겠다.

클라우드(Cloud)란?

삐멜 — Mon, 2 Sep 2019 14:17:38 +0900

이 포스트에서는 클라우드가 무엇인지 설명하고 클라우드 서비스와 클라우드 컴퓨팅이 무엇인지에 대해 간단하게 설명하도록 한다.

클라우드(Cloud)란?

클라우드란 인터넷이다. 클라우드란 인터넷을 은유적으로 표현하는 말이다.

클라우드 서비스(Cloud Service)란?

클라우드 서비스란 클라우드, 즉 인터넷을 이용해 제공되는 서비스를 말한다. 예를 들어서 노트 어플을 생각해보자. 기존의 노트 어플(notepad)는 내 컴퓨터에 깔려있다. 노트패드에 노트를 작성하고 저장하면 어디에 저장되는가? 내 컴퓨터에 저장된다. 이 과정은 인터넷 연결이 전혀 필요 없다.

이제 요즘 사람들이 많이 쓰는 에버노트나 노션을 생각해보자. 에버노트(evernote)나 노션(notion)에 노트를 작성하고 저장하면 어디에 저장되는가? 내 컴퓨터에 저장되는가? 아니다. 바로 에버노트나 노션 회사의 서버(컴퓨터)에 노트가 저장된다. (실제로는 내 컴퓨터에도 저장되지만 결과적으로는 어플리케이션 서버에 저장된다.) 어떻게 에버노트나 노션의 서버에 내 노트가 저장되었는가? 바로 인터넷을 이용했기 때문이다. 이러한 특성 덕분에 인터넷이 가능한 어느 곳에서나 내 노트를 확인할 수 있다. 구글 드라이브, 드랍박스, 구글 메일, 구글 독, 깃 리파지토리등의 어플들이 클라우드 서비스이다. 이렇게 인터넷을 이용해 서비스를 제공하는 것을 '클라우드 서비스' 또는 SaaS (Software As A Service)라고 한다.

클라우드 서비스는 꼭 어플리케이션에만 적용되는 것이 아니다. 어느 서비스든 인터넷을 통해 제공되는 서비스는 클라우드 서비스이다. 이는 컴퓨팅 자원을 사고 운영하는 서비스에 대해서도 마찬가지이다. 컴퓨팅 리소스를 제공하는 클라우드 서비스를 특성에 따라 PaaS(Platform as a Service) 또는 Iaas(Infrastructure as a Service)라고 한다. 그리고 위처럼 인터넷을 통해 컴퓨팅 리소스를 이용하는 것을 클라우드 컴퓨팅(Cloud Computing)이라고 한다.

*컴퓨팅 리소스(자원) : 서버, 데이터베이스, 방화벽, 등등 컴퓨팅을 위해 사용되는 장비들.

클라우드 컴퓨팅(Cloud Computing)이란?

클라우드 컴퓨팅이란, 내 컴퓨터나 내 서버, 데이터베이스, 네트워킹, 등등을 쓰는게 아닌 컴퓨팅 리소스를 제공하는 회사를 통해 서버, 데이터베이스, 네트워킹등등을 사용하는 것이다. 그리고 이런 컴퓨팅 리소스를 '인터넷'을 통해 사고, 관리한다. 컴퓨팅 리소스를 제공하는 대표적인 클라우드 서비스 제공자로는 구글 클라우드, 마이크로소프트 Azure, 아마존 웹 서비스등이 있다.

즉, 내 어플리케이션의 컴퓨팅(computing)을 인터넷(Cloud) 너머의 누군가의 컴퓨터에서 하는것을 클라우드 컴퓨팅(Cloud Computing)이라고 한다. 이런 종류의 클라우드를 특성에 따라 PaaS(Platform as a Service) 또는 IaaS(Infrastructure as a Service)로 구분한다.

클라우드 컴퓨팅을 왜 쓰는가?

비용이 절감된다. 내가 어떤 웹 서비스를 운영하고싶다. 예시를 간단하게 하기 위해 서버만 예로 들어보자. 기존의 방법을 이용하기 위해서 나는 서버를 사야한다. 서버는 한대에 100만원 이상이다. 나는 초기비용으로 적어도 100만원을 써야 한다. 클라우드 컴퓨팅을 이용하면 이보다 훨씬 저렴하게 운영을 시작할 수 있다. 예를들어 아마존 웹 서비스의 EC2 m5.xLarge인스턴스는 한시간(오하이오 기준)에 $0.192 달러이다. 이는 한달에 대략 140불정도이다.

초기비용이 다가 아니다. 서버를 샀다면 서버를 운영하는 운영자가 필요하다. 이 서버가 잘 돌고 있는지, 꺼지지는 않았는지 확인하거나, 랜선이 끊겼다면 데이터센터에 가서 고쳐줄 사람을 고용해야 한다. 트래픽이 늘어 서버가 부족하면 서버를 더 사서 세팅 해 줘야 한다. 이런 비용을 운영 비용이라고 한다. 클라우드 컴퓨팅을 이용하면 클라우드 컴퓨팅 제공자가 이를 관리해준다. 따라서 운영에 드는 시간과 비용이 절감된다.

JavaBean이란?

삐멜 — Mon, 2 Sep 2019 06:07:21 +0900

JavaBean이라는 말을 많이 들어 보았을 것이다. 예를들어 스프링을 사용하는 경우 @Bean이라는 어노테이션을 사용해 봤다던가, XML에 아래와 같은 선언을 해본적이 있을 것이다.

<beans>
    <bean name="Service" class="com.fsoftwareengineer.ServiceImpl"/>
</beans>

그렇다면 JavaBean이란 정확히 무엇인가?

JavaBean

JavaBean은 JavaBean API Specification에 따른 Standard이다. 여러분은 클래스이름은 CapitalCase로, 필드나 메서드 이름은 camelCase로 쓰라는 말을 많이 들어 봤을 것이다. 사실 클래스 이름을 Capital Case가 아닌 다른 형식을 사용한다고 누가 잡아가는것은 아니다. 하지만 개발자들 사이에서는 보통 이런 규칙을 지킨다. 이를 Standard라고 한다.

JavaBean이란, 3가지 규칙을 지키는 클래스이다.

모든 필드는 private이며, getter/setter메서드를 통해서만 접근이 가능하다.
Argument가 없는(no-argument) 생성자가 존재한다.
java.io.Serializable 인터페이스를 구현한다.

다시 말해 아래처럼 생긴 클래스를 JavaBean이라고 부른다.

import java.io.Serializable;

public class SomeBean implements Serializable {
    private String beanName;
    private int beanValue;

    public SomeBean() {
        // no-argument constructor
    }

    public String getBeanName() {
        return beanName;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }

    public int getBeanValue() {
        return beanValue;
    }

    public void setBeanValue(int beanValue) {
        this.beanValue = beanValue;
    }
}

무엇을 위한 규칙인가?

왜 JavaBean을 만들었을까? 왜 이런 제약을 걸었을까? JavaBean의 목적은 여러가지 다른 오브젝트들을 하나의 오브젝트(Bean)에 담기 위함이다. JavaBean의 규칙을 소프트웨어 프로토콜이라고 생각하면 쉽다.

왜 Private 필드와, Getter/Setter만으로 이루어져 있는가?

이는 JavaBean만의 스탠다드는 아니다. 이런 스탠다드를 지키는 클래스를 POJO(Plain Old Java Object)라고 부른다. private, getter, setter를 이용하는 이유는 Encapsulation을 위해서이다.

왜 No-Argument 생성자를 사용하는가?

예를 들어서, 어떤 다른 소프트웨어가 SomeBean을 프로그램 내에서 생성하고 싶다.

public class BeanCreator {

    public Object create() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        String classPath = "SomeBean";
        Class cls = Class.forName(classPath);
        return cls.newInstance();
    }
}

이 때, 생성자에 Argument가 있다면 어떻게 되는가? 이 소프트웨어는 Argument가 몇개인지, 어떤 필드에 맵핑되는지 찾아야 한다. Argument가 없는 생성자를 반드시 만들면 위처럼 오브젝트를 런타임(Runtime)에 생성해 주는 프로그램은 오브젝트 생성 → getter/setter를 이용해 값 설정으로 단순하게 목적을 달성 할 수 있다.

왜 java.io.Serializable 인터페이스를 구현하는가?

JavaBean의 목적은 여러가지 오브젝트들을 하나의 오브젝트에 담기 위함이라고 했다. 담아서 뭘 하는가? 우리는 보통 담아서 네트워크를 통해 전송하거나, 파일/데이터베이스에 저장하거나 한다. 메모리에 존재하는 오브젝트를 네트워크를 통해 전송하거나 파일에 저장하려면 data stream(e.g, byte[])으로 이 오브젝트를 변환시켜줘야 한다. 이 변환 작업을 Serialization이라고 부른다. JavaBean을 저장하거나 전송하는 일이 많기 때문에, Serializable가 스탠다드에 포함되는것으로 추정된다.

병행성(Concurrency)을 위한 CountDownLatch

삐멜 — Thu, 22 Aug 2019 13:39:59 +0900

CountDownLatch

우리가 사용하는 고급 언어는 대부분 Concurrency(병행성)에 관련된 API를 제공한다. 자바도 마찬가지로 atomic, volitile, semaphore등 기본적인 병행성 관련 메커니즘에서 CyclicBarrier, CountDownLatch등의 고급기능까지 제공한다. 그 중 이 포스트에서는 CountDownLatch에 대해 알아보도록 한다.

CountDownLatch는 언제 쓸까?

쓰레드를 N개 실행했을 때, 일정 개수의 쓰레드가 모두 끝날 때 까지 기다려야지만 다음으로 진행할 수 있거나 다른 쓰레드를 실행시킬 수 있는 경우 사용한다. 예를들어서 리스트에 어떤 자료구조가 있고, 각 자료구조를 병렬로 처리한 후 배치(batch)로 데이터베이스를 업데이트 한다거나 다른 시스템으로 push하는 경우가 있다.

CountDownLatch의 어떤점이 이를 가능하게 하는가?

CountDownLatch를 초기화 할 때 정수값 count를 넣어준다. 쓰레드는 마지막에서 countDown() 메서드를 불러준다. 그러면 초기화 때 넣어준 정수값이 하나 내려간다. 즉 각 쓰레드는 마지막에서 자신이 실행완료했음을 countDown 메서드로 알려준다. 이 쓰레드들이 끝나기를 기다리는 쪽 입장에서는 await()메서드를 불러준다. 그러면 현재 메서드가 실행중이 메인쓰레드는 더이상 진행하지않고 CountDownLatch의 count가 0이 될 때까지 기다린다. 0이라는 정수값이 게이트(Latch)의 역할을 한다. 카운트다운이 되면 게이트(latch)가 열리는 것이다.

예제를 통해 확인하도록 하자.

예제

예제에서는 Worker라는 쓰레드 Runnable을 구현하고 CountDownLatch를 사용할 때와 사용하지 않을때 결과가 어떻게 다른지 실험해본다.

import java.util.concurrent.CountDownLatch;
        import java.util.stream.IntStream;

public class App {

    public static void main(String[] args) throws InterruptedException {
        App app = new App();
        app.runWorkers();
    }

    private void runWorkers() throws InterruptedException {
        CountDownLatch countDownLatch = new CountDownLatch(5); // 최대 5개의 쓰레드 동시 실행
        IntStream.range(0, 5)
                .mapToObj(i -> new Worker(i, countDownLatch))
                .map(Thread::new)
                .forEach(Thread::start);

        System.out.println("Done awaiting..");

    }

    public class Worker implements Runnable { //쓰레드
        private CountDownLatch countDownLatch;
        private int index;

        public Worker(final int index, final CountDownLatch countDownLatch) {
            this.index = index;
            this.countDownLatch = countDownLatch;
        }

        @Override
        public void run() {
            try {
                System.out.println("Starting thread... " + index);
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Finishing Thread... " + index);
            }
        }
    }
}

실행 결과

Starting thread... 0
Starting thread... 1
Starting thread... 2
Starting thread... 3
Done awaiting..
Starting thread... 4
Finishing Thread... 0
Finishing Thread... 2
Finishing Thread... 3
Finishing Thread... 1
Finishing Thread... 4

countDown이나 await메서드를 사용하지 않으면 위처럼 쓰레드를 실행하고 나서 이 메서드도 기다리지 않고 다음 줄을 실행하기 때문에 쓰레드가 종료하기 전에 "Done awaiting"이 출력된다. 이제 쓰레드 마지막에 countDown()을 넣어보자.

@Override
public void run() {
    try {
        System.out.println("Starting thread... " + index);
        Thread.sleep(3000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        System.out.println("Finishing Thread... " + index);
        countDownLatch.countDown(); // 이 줄 추가
    }
}

실행 결과

    Starting thread... 0
    Done awaiting..
    Starting thread... 3
    Starting thread... 4
    Starting thread... 2
    Starting thread... 1
    Finishing Thread... 0
    Finishing Thread... 3
    Finishing Thread... 2
    Finishing Thread... 4
    Finishing Thread... 1

넣어봤자 아무 소용이 없다. 왜인가? 아무도 기다리고있지 않기 때문이다. 이제 기다리는 쪽에서 await을 이용하도록 해보자.

private void runWorkers() throws InterruptedException {
    CountDownLatch countDownLatch = new CountDownLatch(5);
    IntStream.range(0, 5)
            .mapToObj(i -> new Worker(i, countDownLatch))
            .map(Thread::new)
            .forEach(Thread::start);

    countDownLatch.await(); // 이 줄 추가
    System.out.println("Done awaiting..");

}

실행 결과

Starting thread... 0
Starting thread... 3
Starting thread... 2
Starting thread... 4
Starting thread... 1
Finishing Thread... 0
Finishing Thread... 1
Finishing Thread... 4
Finishing Thread... 2
Finishing Thread... 3
Done awaiting..

await을 추가하고 돌리자 Done awaiting이 가장 마지막에 실행된다. await()메서드가 CountDownLatch의 count가 0이 될 때 까지 기다리기 때문이다.

자바 Lambda (람다)

삐멜 — Tue, 20 Aug 2019 13:16:13 +0900

이번 포스트에서는 자바 8부터 제공하는 Lambda 의 사용법에 대해 알아보도록 한다. 이 포스트는 독자들이 자바의 클래스, 인터페이스, 메서드등 기본을 이미 알고있다고 가정한다.

Lambda (람다)

Lambda(람다)란? 소프트웨어 세계에서 람다란 함수이다. 자바에서는 메서드이다. 그렇다면 모든 함수나 메서드가 람다인가? 아니다. 매개변수로 전해질 수 있는 함수/메서드만을 람다라고 한다. 매개변수로 전해진다는게 무슨뜻일까. 설명을 보며 생각해보아라.

전통적인 자바 프로그램을 떠올려 보자. 메서드를 만들려면 뭐부터 만들어야 할까? 클래스부터 만들어야한다. 실제 산업에서는 인터페이스-인터페이스 구현클래스로 나누어 많이 개발한다. 예를들어서 x + y를 계산하는 Operation 인터페이스가 있다고 하자.

public interface Operation {
    Integer add(Integer x, Integer y);
}

이 인터페이스를 사용하기 위해서는 이 인터페이스를 구현하는 클래스가 필요하다.

public class OperationImpl implements Operation{
    @Override
    public Integer add(Integer x, Integer y) {
        return x + y;
    }
}

이제 사용하기 위해 메인에서 초기화를 하고 불러보도록 하자.

public class App {

    public static void main(String[] args) {
        Operation op = new OperationImpl();
        int result = op.add(1, 3);
        System.out.println(result);
    }
}

실행하면 결과 값인 4가 나올것이다.

add 메서드를 사용하기 위해서 개발자는 add 메서드가 존재하는 인터페이스 생성(Operation), 인터페이스 구현(OperationImpl), 그리고 메서드를 사용하기 위해 인터페이스 오브젝트 생성(new OperatonImpl)과정을 거쳤다. 인터페이스 구현과 오브젝트 생성과정을 하나로 합치고, 별도의 OperationImpl.java같은 파일 없이도 인터페이스를 구현할 수 있다면 어떻겠는가? 자바에는 이미 그런 기능이 있다.

public class App {

    public static void main(String[] args) {
        Operation op = new Operation() {
            @Override
            public Integer add(Integer x, Integer y) {
                return x + y;
            }
        };
        int result = op.add(1, 3);
        System.out.println(result);
    }
    
}

위처럼 오버라이드 해야하는 메서드의 구현부분을 new 인터페이스이름() { ...바디부분.. }의 바디부분에 넣어주면 된다. 파일만 안 만들었을 뿐이고 구현 부분 클래스의 내부를 작성해야 하는 것은 변함 없다. 람다는 여기에서 조금 더 간단해진 경우이다.

public class App {

    public static void main(String[] args) {
        Operation op = (x, y) -> { return x + y; }; // @Override public int add(int x, int y) { return x + y; } 와 같은 뜻
        int result = op.add(1, 3);
        System.out.println(result);
    }

}

new Operation() { @Override.. }하고 구구절절 쓰지 말고, 그냥 깔끔하게 메서드만 구현해서 넘기자는 것이다. 괄호 안에는 인터페이스 구현부분의 파라미터 이름을 개수에 맞게 넣어주고 '->' 다음에는 메서드 바디 부분을 { } 꺽쇠괄호 안에 넣어준다. Operation 인터페이스에서 add메서드의 인자가 2개였기 때문에 x, y 두개를 매개변수로 넣는 것이다. 메서드를 오버라이딩 하는것과 똑같다. 다만 표현방식이 조금 다른것 뿐이다. 리턴 값이 있으므로 리턴을 반드시 해주어야 한다.한줄짜리인 경우 아래처럼 간략하게 쓸 수 있다.

Operation op = (x, y) -> x + y;

Lambda의 제약

이제 의문이 생길 것이다. 만약에 인터페이스에 메서드가 두개 있으면 어떻게 할 것인가? 답은 간단하다. 람다를 사용하지 못한다. 위와 같은 수식으로 인터페이스의 구현부분을 작성할 수 있는 이유는 인터페이스에 구현해야할 메서드가 하나밖에 없기 때문이다. 그렇지 않으면 매개변수의 자료형을 명시하지 않는데 어떤 메서드를 어떻게 맵핑 할 것인가? 구현해야 할 메서드가 하나밖에 없으니, 람다 표현을 쓰기 시작하면 자바가 매개변수는 몇개인지, 타입이 무엇인지 미리 알고있는 상태인 것이다.

Operation op = (x, y, z) -> x + y; 
// Error:(4, 24) java: incompatible types: incompatible parameter types in lambda expression

위를 시도하면 에러가 날것이다. 또한 y.을 누르면 이미 이 메서드의 두 인자는 Integer임을 알고 있기 때문에 IDE에서도 코드 컴플리션을 제공한다.

printResult((x, y) -> y.compareTo(x));

메서드가 하나인 인터페이스에 밖에 사용하지 못하면 무슨 생각인가? 의외로 실세계에선 1회 사용을 위해 인터페이스를 구현하는 일이 잦다. 또, 반대로 생각하면, 구현할 메서드가 여러개라면 코드 퀄리티와 유지보수를 위해 구현부를 파일로 만드는 것이 적당하다는 뜻일 수도 있다. 다만 기존에는 구현해야할 메서드가 하나밖에 없는 인터페이스임에도 인터페이스 구현 클래스를 하나하나 만들어야 했다. 딱 한 군데서만 쓰고 아무데서도 안쓰더라도 말이다. 자바 8 람다를 이용하면 이런 불편함을 해소할 수 있다. 가장 대표적인 예로 Comparator가 있다. 이제 프린트 부분을 따로 떼어내 보자.

public class App {

    public static void main(String[] args) {
        Operation op = (x, y) -> x + y;
        printResult(op);
    }

    private static void printResult(Operation op) {
        int result = op.add(1, 3);
        System.out.println(result);
    }
}

printResult라는 메서드를 만들고 메서드의 매개변수로 Operation을 넘겨준다. 메인에서는 printResult에 넘겨줄 op 오브젝트를 람다 표현으로 초기화한다. 위에서 매개변수로 전해질 수 있는 함수/메서드를 람다라고 부른다고 했다. 이제 무슨 뜻인지 감이 오는가? 람다를 이용하면 아래같은 방식으로 코드를 간단히 할 수 있다.

public class App {

    public static void main(String[] args) {
        printResult((x, y) -> x + y);
    }

    private static void printResult(Operation op) {
        int result = op.add(1, 3);
        System.out.println(result);
    }
}

람다 표현을 사용하면 그 자체로 인터페이스의 구현 오브젝트가 생성된다. 람다 표현 자체가 하나의 인터페이스 오브젝트 이므로 이를 매개변수로 넘기는것에도 문제가 없는 것이다.

끝

람다는 Stream과 같이 많이 사용된다. 다음 포스트에서는 Stream을 소개하면서 Lambda를 적용한 예를 더 보도록 한다.