유튜브에서 그냥 킹오브 98이나 보려고 들어갔다가 다음과 같은 영상이 메인에 보였다. 꼴에 프랑스어를 조금 배우고 프로그래밍도 조금 배웠다고 유튜브 알고리즘이 띄워주나 보다. 보다보니 뭔가 IDE와 빌드툴의 도움만 받으면서 근본도 모르고 개발을 한 것 같아 영상의 내용을 글로 옮겨본다. 모하메드 교수님이 불어로 쏼라쏼라 하지만 코드는 만국 공통이니 못 알아 들을 것도 없었다. 시작해 보자!

프로젝트 생성

1. mkdir example && cd example
2. mkdir -p src/main/java
3. mkdir -p src/test/java
4. mkdir -p src/main/resources
5. mkdir -p target/classes
6. mkdir lib

mkdir의 -p 옵션은 바로 필요한 디렉터리를 한 번에 만들겠다는 뜻 이다.

1. 프로젝트 폴더를 만들고 안으로 이동한다.
2. 소스 코드를 작성하는 main 폴더를 만든다.
3. 테스트 코드를 작성하는 test 폴더를 만든다.
4. 설정 파일, 리소스 파일들을 담아두는 resources 폴더를 만든다.
5. 컴파일 이후 .class 파일들을 저장할 곳을 만든다.
6. 서드파티 라이브러리 .jar 파일들을 저장하는 곳을 만든다.

tree 명령어를 사용해서 다음과 같은 구조가 보이면 된다.

.
├── lib
├── src
│   ├── main
│   │   ├── java
│   │   └── resources
│   └── test
│       └── java
└── target
    └── classes

💡 맥 OS에는 tree 명령어가 없다.

brew install tree

소스 코드 작성

1. cd src/main/java
2. mkdir -p com/example/app && cd com/example/app
3. vi App.java

1. 소스 코드 작성을 위해 java 폴더로 이동한다.
2. 패키지를 만들고 경로를 이동한다.
3. App.java 라는 이름의 파일로 vim 에디터를 연다.

그리고 다음과 같이 아주 간단히 main 메소드를 포함하는 자바 코드를 작성해본다. 이후에 다른 클래스를 import 해볼 것이니 걱정하지 말자!

package com.example.app;

public class App {
  public static void main(String[] args) {
    System.out.println("Hello World");
  } 
}

컴파일

프로젝트의 루트 경로로 돌아간 후 아래의 명령어를 실핸한다.

javac src/main/java/com/example/app/App.java -d target/classes

App.java 파일을 컴파일하고 결과를 target/classes 디렉토리에 넣는다는 뜻이다.

tree 명령어를 실행해보면 다음과 같다.

.
├── lib
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── app
│   │   │               └── App.java
│   │   └── resources
│   └── test
│       └── java
└── target
    └── classes
        └── com
            └── example
                └── app
                    └── App.class

자, 이제 실행해보자!

실행

java -cp target/classes com.example.app.App

-cp 는 클래스 패스를 설정하는 옵션이다. App.class 파일을 실행한다.

결과는 예상대로 다음과 같다.

Hello World

클래스 패스를 매번 지정해 주어야하는게 조금 귀찮다. java com.example.app.App 을 실행하면 다음과 같이 클래스를 찾을 수 없다고 오류가 나타난다.

Error: Could not find or load main class com.example.app.App
Caused by: java.lang.ClassNotFoundException: com.example.app.App

클래스 패스 설정 없이 바로 자바 프로그램을 실행하고 한다면 다음과 같이 환경 변수에 클래스 패스를 지정해주어야 한다.

export CLASSPATH="/[YOUR_PATH_HERE]/example/target/classes:$CLASSPATH"

그리고 나서 java com.example.app.App 을 실행하면 _"Hello World"_가 똑같이 나타날 것이다.

import 할 클래스 작성

1. mkdir src/main/java/com/example/app/service && cd src/main/java/com/example/app/service
2. vi Service.java

1. service 패키지를 추가하고 해당 경로로 이동한다.
2. Service.java 이름의 파일을 에디터로 연다. 아래의 내용을 작성한다.

package com.example.app.service;

public class Service {
    public double compute(double a, double b) {
        return a + b;
    }
}

Service 컴파일

프로젝트의 루트로 경로를 다시 이동시키고 아래의 명령어를 실행시킨다.

javac -d ./target/classes ./src/main/java/com/example/app/service/Service.java

tree 명령어를 실행해보면 다음과 같다.

.
├── lib
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── app
│   │   │               ├── App.java
│   │   │               └── service
│   │   │                   └── Service.java
│   │   └── resources
│   └── test
│       └── java
└── target
    └── classes
        └── com
            └── example
                └── app
                    ├── App.class
                    └── service
                        └── Service.class

Service.class 파일이 생긴 것을 확인할 수 있다.

App에 Service 임포트 시키기

App.java 파일을 다음과 같이 수정한다. 코드 설명은 따로 하지 않아도 알 것이다.

package com.example.app;

import com.example.app.service.Service;

public class App {
  public static void main(String[] args) {
    if(args.length != 2) {
        System.out.println("두 개의 인수를 주세요!");
        System.exit(0);
      }
      Service service = new Service();
      double a = Double.parseDouble(args[0]);
      double b = Double.parseDouble(args[1]);
      double result = service.compute(a, b);
      System.out.println(String.format("%s 더하기 %s 는 %s 이다.", a, b, result));
  } 
}

다시 App.java 파일을 컴파일 해본다.

javac -d ./target/classes ./src/main/java/com/example/app/App.java

App 실행하기

앱을 실행해본다.

java com.example.app.App

결과는 다음과 같다.

두 개의 인수를 주세요!

두 개의 인수를 주고 다시 실행해본다.

java com.example.app.App 5 7

결과는 다음과 같다.

5.0 더하기 10.0 는 15.0 이다.

필요한 import 하고 컴파일하고 실행까지 해보았다!

필요한 jar 파일 다운 받기

테스트 코드 작성 및 실행에 필요한 jar 파일들을 다운받는다.

• junit-4.13.jar
• hamcrest-core-1.3.jar

다운로드 받은 후 lib 경로에 넣어준다.

테스트 코드 작성

src/test/java 경로에 똑같은 com/example/app/service 패키지를 만들고 ServiceTest.java 파일을 생성하여 테스트할 코드를 작성한다. 일부러 실패하는 테스트로 만들었다.

package com.example.app.service;

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ServiceTest {
  @Test
  public void testCompute() {
    Service service = new Service();
    double a = 12;
    double b = 8;
    double expected = 100;
    double result = service.compute(a, b);
    assertEquals(result, expected, 0.001);
  }
}

테스트 코드 컴파일

jar 파일과 직접 컴파일한 클래스를 불러올 수 있도록 클래스패스를 설정하여 ServiceTest.java 를 컴파일 한다.

javac -d ./target/classes -cp ./lib/junit-4.13.jar:./lib/hamcrest-core-1.3.jar:./target/classes ./src/test/java/com/example/app/service/ServiceTest.java

tree 명령어를 실행해보면 다음과 같다.

.
├── lib
│   └── junit-4.13.jar
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── app
│   │   │               ├── App.java
│   │   │               └── service
│   │   │                   └── Service.java
│   │   └── resources
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── app
│                       └── service
│                           └── ServiceTest.java
└── target
    └── classes
        └── com
            └── example
                └── app
                    ├── App.class
                    └── service
                        ├── Service.class
                        └── ServiceTest.class

테스트 코드 실행

JUnit 4의 테스트를 실행하기 위해 JUnitCore 가 필요하다. 해당 문서에 커맨드 라인에서의 실행법이 나와있다.

To run tests from the command line, run java org.junit.runner.JUnitCore TestClass1 TestClass2

다시 한 번 클래스 패스를 설정해 필요한 클래스들을 불러오고 JUnitCore 로 테스트를 실행해 본다.

java -cp "./target/classes/:./lib/junit-4.13.jar:./lib/hamcrest-core-1.3.jar:" org.junit.runner.JUnitCore com.example.app.service.ServiceTest

결과는 다음과 같다.

JUnit version 4.13
.E
Time: 0.006
There was 1 failure:
1) testCompute(com.example.app.service.ServiceTest)
java.lang.AssertionError: expected:<20.0> but was:<100.0>
        at org.junit.Assert.fail(Assert.java:89)
        at org.junit.Assert.failNotEquals(Assert.java:835)
        at org.junit.Assert.assertEquals(Assert.java:555)
        at org.junit.Assert.assertEquals(Assert.java:685)
        at com.example.app.service.ServiceTest.testCompute(ServiceTest.java:14)

FAILURES!!!
Tests run: 1,  Failures: 1

잘 동작한다 😙.

jar 파일 만들기

jar 파일로 만들어 앱을 실행시켜 보자. 경로를 target/classes 를 이동시켜 target 경로에 app.jar 파일을 만든다.

jar cfv ../app.jar .

옵션의 의미는 다음과 같다.

• c : 자바 아카이브 파일을 생성한다.
• f : 파일 이름을 정한다.
• v : 콘솔에 진행상황을 출력한다.

added manifest
adding: com/(in = 0) (out= 0)(stored 0%)
adding: com/example/(in = 0) (out= 0)(stored 0%)
adding: com/example/app/(in = 0) (out= 0)(stored 0%)
adding: com/example/app/App.class(in = 925) (out= 605)(deflated 34%)
adding: com/example/app/service/(in = 0) (out= 0)(stored 0%)
adding: com/example/app/service/Service.class(in = 272) (out= 210)(deflated 22%)
adding: com/example/app/service/ServiceTest.class(in = 559) (out= 393)(deflated 29%)

다음과 같은 정보가 나오며 app.jar 이 생성되었다.

jar 파일 실행하기

target 경로에 jar 파일을 생성했으므로 해당 경로로 이동하고 다음의 명령어를 입력해 앱을 실행해 본다.

java -cp app.jar com.example.app.App 10 2

결과는 다음과 같다.

10.0 더하기 2.0 는 12.0 이다.

Manifest 추가 후 실행

resources 폴더에 MANIFEST.TXT 파일을 만들고 다음 내용을 추가한다.

Main-Class: com.example.app.App

💡 줄바꿈을 통해 마지막 빈 줄을 만드는 것이 매우 중요하다!!!!

target/classes 경로로 이동한 후 Manifest 파일을 app.jar 생성 시 추가시켜준다 (Manifest 파일 경로를 명시해주지 않으면 디폴트로 알아서 하나 만들어 준다).

jar cfvm ../app.jar ../../src/main/resources/MANIFEST.TXT .

target 으로 이동해 앱을 실행시켜 본다.

java -jar app.jar 20 30

결과는 다음과 같다.

20.0 더하기 30.0은 50.0 이다.

소감

한 번 알아본 것으로 족하고 IDE와 빌드툴에 의존해야 겠다 🤪.

참고 자료

• Youtube - Sources de l'Informaticien avec Pr.Mohamed YOUSSFI - Part 1 - Bases et Outils de Développement JAVA - Java sans IDE et sans Maven

• ABC 순서 입니다.
• 지금 적혀있는 내용도 변경 될 수 있습니다.

Ask / Offer Price

브로커가 Quote Currency 와 교환하여 Base Currency 를 판매하려는 가격이다. 만약 어떤 통화를 사고 싶다면, 브로커는 ask 가격에 판매해 줄 것이다.

Base Currency

GBP/USD 와 같은 페어에서 앞에 있는 통화를 의미한다. 해당 페어에서 환율을 이야기할 때 항상 1이 된다. Base Currency 의 가치가 오를 것 같으면 구매하고 반대라면 팔면된다.

Bid

브로커가 Quote Currency 와 교환하여 Base Currency 를 구매하려는 가격이다. 만약 어떤 통화를 팔고 싶다면, 브로커는 bid 가격에 구매를 해줄 것이다.

BRIICS

Brazil, Russia, India, Indonesia, China, South Africa를 줄여서 부르는 말.

Brokers / Trading Providers

엄밀히 말하면, 중간에서 구매자와 판매자를 연결해주는 기관이 아니다. 내가 구매를 하면 브로커는 판매자가 되고, 내가 판매를 하면 브로커는 구매자가 된다.

Buy

통화를 산다는 것은 사실 Base Currency 를 사고 Quote Currency 를 파는 것을 의미한다. Ask 가격에 Base Currency 를 산다.

CEE Currencies

중앙 유럽과 동유럽을 합쳐서 CEE, Central and Eastern Europe, 라고 부른다. CEE 통화 중 4개의 통화가 많이 알려져있다.

CFD / Contract For Difference (차액 거래)

약정 개시 시점과 종료 시점의 차액을 거래하는 상품. 약정 만료일은 단기로 끝나거나 장기로 계속 이어갈 수 있다. 수익, 손실 여부의 방향을 올바르게 예측하여 수익을 낼 수 있다.

Close Out / Offsetting / Liqudating

Retail Forex 거래에서 브로커와 반대되는 거래를 하는 행위. 트레이더가 미국 달러로 영국 파운드를 구매했다면, 영국 파운드를 미국 달러로 파는 행위를 "close out" 했다고 한다.

Commodity Currencies

일부 트레이더들은 USD, EUR, JPY, GBP, CHF 만을 주요 통화로 생각한다. 그들은 AUD, NZD, CAD를 commodity currencies 라고 부른다.

Counter / Quote Currency

GBP/USD 와 같은 페어에서 뒤에 있는 통화를 의미한다. 하나의 Base Currency 를 사기 위해 Quote Currency 를 얼마나 지불해야하는지 알려주는 것이 바로 환율이다. 반대로 하나의 Base Currency 를 팔면 얼마나 Quote Currency 를 받을 수 있는지 의미한다.

Derivative (파생 상품)

파생 상품은 실제 자산 보유하지 않아도 거래할 수 있도록 설계된 금융 상품이다. 예로는 옵션, 선물, 스왑 등이 있다.

Dollar's nicknames

buck, greenbacks, bones, benjis, benjamins, cheddar, paper, loot, scrilla, cheese, bread, moolah, dead presidents, cash money

ETF (통화 ETF)

세계 기축통화인 미국 달러화를 상품으로 달러화의 선물지수를 추종하도록 설계된 ETF를 통화 ETF라고 한다. 즉, 미래의 통화 가치를 대표하는 미 달러화의 환율이 상승할지 하락할지에 투자의 기준을 두고 투자하는 상품이다.

특징은 다음과 같다.

• 포트폴리오가 다양화 된다.
• 개별적인 거래를 일일이 해야하는 부담을 줄일 수 있다.
• 통화 리스크에 대해 헤지를 할 수 있다.
• 펀드를 구성하는 금융, 투자 회사에 의해 만들어진다.
• 주식 상품 처럼 share를 제공한다.
• 24시간 열려있는 시장이 아니다.

Exchange Rate (환율)

서로 다른 국가간의 화폐의 상대적인 가격이다. 자기 나라 돈과 다른 나라 돈의 교환 비율.

Exotic Currency Pairs

하나의 주요 통화와 브라질(BRL), 멕시코(MXN), 칠레(CLP), 홍콩(HKD) 등과 같은 신흥 경제 국가의 화폐를 합친 통화 페어. 지정학적, 경제적인 이벤트에 매우 민감하다.

Flat / Square

열린 포지션이 하나도 없으면 "flat" 또는 "square" 되었다고 부른다. 포지션을 닫는 것을 "squaring up" 이라고 부른다.

Futures (선물 거래)

특정 자산을 미래 날짜에 지정된 가격으로 사거나 파는 계약. 통화의 경우, 하나의 화폐를 어느 날짜에 구매하거나 팔 가격을 정하는 계약이다.

FX / Forex / Foreign Exchange Market (외환 시장)

통화를 거래할 수 있는 글로벌 금융시장이다.

G10 Currencies

G10 이라고 부르는 국가들의 통화. 세계에서 유동성이 가장 큰 10가지 화폐이다.

Hedge (헤지)

투자자가 가지고 있거나 앞으로 보유하려는 자산의 가치가 변함에 따라 발생하는 위험을 없애려는 시도.

Interdealer / Interbank Market

FX 딜러들 간에 거래가 일어나는 마켓. 딜러는 클라이언트와 언제든지 통화를 매매할 준비가 되어 있는 금융 중개자이다. 환율 변화에 따른 위험에 대처할 수 있는 은행, 보험회사, 연금 기구, 대기업이 포함된다.

ISO 4217 Currency Code

Internation Organization for Standardization (ISO)에서 1973년에 제정한 3자리 화폐 코드. 앞의 두 자리는 국가명이고 마지막 한 자리는 화폐명이다.

• KRW - KR (대한민국) + W (원)
• NZD - NZ (뉴질랜드) + D (달러)

Levarage (레버리지)

필요 마진(Required Margin)에 몇 배에 해당하는 포지션을 열 수 있게 브로커들이 레버리지를 제공한다.

레버리지가 50:1 인 경우

• $2,000의 필요 마진을 가지고 $1,000,000의 EUR/USD 포지션을 열 수 있다.

Liquidity (유동성)

활성도를 나타내는 단어. 특정 통화 페어를 사고 파는 활성 거래자 수와 거래되는 거래량을 기반으로 한다. 자주 거래될 수록 유동성이 더 높다.

Long

Buy 와 같은 말이다. Buy 참조

Lot

외환 거래에서는 "lot" 으로 unit(화폐 단위) 을 이야기한다.

• 1,000 units = micro lot
• 10,000 units = mini lot
• 100,000 units = lot / standard lot

Major / Minor Cross-Currency Pairs

주요 통화 페어 중 미국 달러를 포함하지 않는 페어들. "crosses" 또는 "minors" 라고도 불린다. USD를 포함하지 않으면서 가장 활발히 거래되는 crosses 는 EUR, JPY, GBP 이다.

Major Currencies (주요 통화)

다음의 8가지 통화를 주요 통화라고 부른다. ABC 순으로 나열했다.

Major Currency Pair

주요 통화 페어 중 미국 달러 (USD)를 포함하는 페어. 가장 활발히 거래된다. 아래 7가지 페어를 말한다.

Markup (이윤)

FX 브로커들이 Primary OTC Market에서 찾은 상품에 붙이는 이윤. 이윤을 붙여 Secondary OTC Market에서 거래가 될 수 있도록 그들의 플랫폼에 올려 놓는다.

Nokie

노르웨이 크로네(NOK)의 별명.

Options (통화 옵션)

통화옵션 거래란 미래의 특정시점(만기일 또는 만기 이전)에 특정 통화를 미리 약정한 가격으로 사거나(call option) 팔수 있는 권리(put option)를 매매하는 거래를 말한다. 유동성이 선물, 현물 시장에 비해 낮은 것이 단점이다.

OTC / Over-the-counter

거래소 밖에서 벌어지는 시장. 장외시장을 뜻한다. 은행의 네트워크 안에서 온라인으로 24시간 지속되는 것이 특징이다.

Pence

Penny 의 복수형

Pip / Percentage in Point / Price Interest Point

두 통화 사이의 변화를 설명하는 단위가 pip 이다. Pip은 보통 소수점 자리의 마지막을 의미한다. 대부분의 페어에서 소수점 네번째 자리를 의미하지만 일본 엔화는 두번째 자리이다.

EUR/USD 의 환율이 1.1050에서 1.1051로 변경되었으면 1 pip이 변경된 것이다.

Pipette / Point / Fractional Pip

pip 의 10분의 1을 의미한다. pip이 소수점 4번째 자리를 의미하면, 5번째 자리가 pipette 가 된다.

Primary OTC Market

인터딜러(interdealer)간에 일어나는 거래 시장.

Required Margin (필요 마진)

트레이더가 새로운 포지션을 열고 유지하는데 필요한 최소 금액.

Retail Forex / Secondary OTC Market

브로커(Trading Providers)가 Primary OTC Market 에서 가능한 최상의 가격을 찾아 "markup"_을 붙여 브로커 자신의 거래 플랫폼에 가격을 올려놓고 거래가 이루어지는 시장을 말한다. 보통 개인 투자자들이기 때문에 _레버리지 개념이 있다.

Reservce Currency (기축 통화)

국제간의 결제나 금융 거래의 기본이 되는 화폐. 현재는 미국의 달러와 일본의 엔 따위가 사용되고 있다.

Rollover

브로커가 정한 마감 시간(cut-off time) 이후 열려있는 포지션에 따라서 "rollover fee" 또는 "swap fee" 라고 하는 것을 매일 지불하거나 지급받아야 한다. 빌린 통화에 대해서는 이자가 지불되고, 구매한 통화에 대해서는 이자가 지급된다. rollover율은 여러가지 요인에 의해 조정되니 계속 확인을 해야한다.

Scandies

덴마크, 노르웨이, 스웨덴을 합쳐 스칸디나비아라고 부르는 것에 유래하여 이들 국가의 통화들을 합쳐서 부르는 말.

Sell

통화를 판다는 것은 사실 Base Currency 를 팔고 Quote Currency 를 구매한다는 말이다. Bid 가격에 Base Currency 를 판다.

Short

Sell과 같은 말이다. Sell 참조.

Speculation (투기)

시세 변동을 예상하여 차익을 얻기 위하여 하는 매매 거래.

Spread (스프레드)

Bid와 Ask의 가격 차를 Spread 라고 부른다.

각 상품은 구매가와 판매가를 가진다. 그 차액(구매가-판매가)을 스프레드라고 부른다.

Spread Bet (스프레드 베팅)

자산에 대한 소유권은 없지만 미래에 해당 자산 가격이 오를지 내릴지 예측하는 파생 상품. 통화 페어에 가격에 방향에 대해 예측을 한다. 미국에서는 도박과 같은 불법 수준으로 여겨진다.

Spot FX / FX Spot

외환 거래를 특정 환율에 따라 교환하기로 약정한 날을 D일(=거래일)이라고 하면, 그 계약에 따라 실제로 통화의 교환이 일어나는 날짜(=결제일)에 따라 상품을 구분해 놓은 것 중 하나이다.

특징은 다음과 같다.

• 중앙 거래소를 통하지 않고 인터딜러간에 다이렉트로 거래가 발생한다.
• 은행, 보험 회사, 연금 기구, 대기업 등이 여기에 해당한다.
• 통화를 거래하는 것이 아닌 그 계약을 거래하는 것이다.
• Spot의 경우 결제일을 T+2("Today plus 2 business days") 라고 부른다.
• 개인 투자자들과는 상관이 없다.

Stockie

스웨덴 크로나(SEK)의 별명.

T+2

Today plus 2 business days. Spot FX 참조.

Value Date / Delivery Date

결제일. Spot FX 참조.

참고 자료

• Babypips
• 네이버 국어사전
• 네이버 영어사전
• 디지털타임스 - 통화옵션시장 의의와 거래구조
• 이코노믹리뷰 - 통화 ETF, 美 달러선물 단기 방향성투자
• 하얀 캔버스 - 결제일별로 분류한 상품유형
• fpmarkets - CFD란?

모두가 아는 '그 내용'

자바스크립트를 처음 공부할 때, 잘 모르겠으면 === 를 쓰라고 배우는 _'그 내용'_에 대해 간단히 짚어보고 가자. 그냥 없으면 허전하니까... 😙

• == 동등 비교는 LHS의 값과 RHS의 값이 같은지 비교한다. 중요한 것은 값을 비교한다는 것이다.
• === 일치 비교는 LHS의 값, 타입과 RHS의 값, 타입이 같은지 비교한다. 중요한 것은 값과 타입 둘다 비교한다는 것이다.

[Optional] LHS / RHS?

내가 평소에 자주 쓰는 용어가 아니지만 공부 중에 등장해서 뜻을 적어본다.

• LHS: Left Hand Side
• RHS: Right Hand Side

V8에서는 어떻게 동작할까? 🤔

사실 오늘 알아보고싶은 내용은 V8엔진에서 두 연산자들이 어떻게 동작하는지이다. 두 연산자들의 실행 코드를 보기전에 _Runtime Functions_에 대해 알아본다.

Runtime Functions

V8 엔진의 빌트인 함수 중 일부는 곧장 자바스크립트로 구현되어 있고, 런타임에 실행가능한(executable) 코드로 컴파일됩니다. 이들 중 일부는 runtime functions 라고 분류되는 것들이 있습니다. C++로 작성되어 있고 자바스크립트에서 %-접두사를 붙여 호출합니다. 이러한 runtime functions은 V8 내부의 자바스크립트 코드에서만 사용됩니다. <생략> 일부 runtime functions는 컴파일러에 의해 생성된 코드에 삽입됩니다.
Built-in functions, V8 doc

내가 이해한 바로는, V8 내부의 자바스크립트 코드를 통해 실행되는 함수 중 그 기능을 온전히 하기 위해 런타임에 C++로 작성된 runtime functions를 삽입해준다는 것이다. 고마운 분께서 V8 런타임 함수의 리스트를 만들어 주셨다. 여기에서 StrictEquality와 Equals, 두 개의 런타임 함수를 찾을 수 있었다.

v8-RuntimeFunctions-list

일치 연산자 (===, Strict Equality)

일단, 코드가 쉬워보이는(짧아서) 이유로 일치 연산자 부터 알아본다.

런타임 함수

일치 연산자에서는 어떤 런타임 함수가 사용되는지 코드를 찾아보았다. 코드는 runtime-operator.cc 파일에서 찾을 수 있다.

RUNTIME_FUNCTION(Runtime_StrictEqual) {
  SealHandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  CONVERT_ARG_CHECKED(Object, x, 0);
  CONVERT_ARG_CHECKED(Object, y, 1);
  return isolate->heap()->ToBoolean(x.StrictEquals(y));
}

코드의 내용을 해석해본다.

• Isolate::Scope 클래스 문서를 참조해보면, 지역 스코프 내에서 실행되는 모든 연산(operation)에 대해 isolate를 설정하는 스택처럼 할당되는 클래스라고 나와있다. 다른 스레드가 함부로 끼어들지 못하도록 락을 거는 것과 같은 느낌이라고 생각을 했다. 단지 내 생각일 뿐이다!
• _DCHECK_EQ_는 인수의 개수가 2개인지 확인한다. 일치 연산자는 두 가지를 가지고 비교하는 것이기 때문에 확인한다.
• 첫 번째 CONVERT_ARG_CHECKED를 해석해보자면, 0번째 인덱스의 인수를 x라는 이름의 변수에 Object 타입으로 캐스팅한다는 얘기이다.
• StrictEquals 함수를 통해 일치 비교를 실행한다.

  비교 코드

  여기까지 일치 연산자에 대한 런타임 함수를 살펴보았고, 실제 비교하는 코드를 살펴본다. objects.cc 파일에서 찾을 수 있다.

bool Object::StrictEquals(Object that) {
  if (this->IsNumber()) {
    if (!that.IsNumber()) return false;
    return StrictNumberEquals(*this, that);
  } else if (this->IsString()) {
    if (!that.IsString()) return false;
    return String::cast(*this).Equals(String::cast(that));
  } else if (this->IsBigInt()) {
    if (!that.IsBigInt()) return false;
    return BigInt::EqualToBigInt(BigInt::cast(*this), BigInt::cast(that));
  }
  return *this == that;
}

위 코드의 주요점은 타입이 다르면 return false;를 한다는 것이다. 그 후에 값을 비교한다.

알고리즘

ECMA가 정의한 일치 연산자 알고리즘(Strict Equality Comparison Algorithm)은 다음과 같다. 그냥 한 번 읽어보는게 좋을 것 같아서 소개해본다.

1. x와 y의 타입이 다르면 false를 리턴한다.
2. x와 y의 타입이 _Undefined_면 true를 리턴한다.
3. x와 y의 타입이 _Null_이면 true를 리턴한다.
4. x의 타입이 Number 일 때, a. x의 값이 NaN이면 false를 리턴한다. b. y의 값이 NaN이면 false를 리턴한다. c. x와 y의 값이 같은 Number 값이면 true를 리턴한다. d. x가 +0이고 y가 -0일 때, true를 리턴한다. e. x가 -0이고 y가 +0일 때, true를 리턴한다. f. false를 리턴한다.
5. x의 타입이 String일 때, x와 y의 문자 순서와 그 값이 정확이 일치하면 true를 리턴하고 아니라면 false를 리턴한다.
6. x의 타입이 Boolean일 때, x와 y가 모두 true이거나 false이면 true를 리턴하고 아니라면 false를 리턴한다.
7. x와 y가 같은 객체를 참조하면 true를 리턴하고, 아니라면 false를 리턴한다.

동등 연산자 연산자 (==, Equality)

이번엔 코드가 길어서 미뤄왔던 동등 연산자에 대해서 알아본다.

런타임 함수

동등 연산자에서도 런타임 함수를 찾아 보았다. 이 코드 또한 runtime-operator.cc 파일에서 찾을 수 있다.

RUNTIME_FUNCTION(Runtime_Equal) {
  HandleScope scope(isolate);
  DCHECK_EQ(2, args.length());
  CONVERT_ARG_HANDLE_CHECKED(Object, x, 0);
  CONVERT_ARG_HANDLE_CHECKED(Object, y, 1);
  Maybe<bool> result = Object::Equals(isolate, x, y);
  if (result.IsNothing()) return ReadOnlyRoots(isolate).exception();
  return isolate->heap()->ToBoolean(result.FromJust());
}

=== 연산자와의 차이와 특징을 살펴본다.

• StrictEquals 대신 Equals 함수를 호출한다.
• Maybe는 값이 있을 수도 없을 수도 있는 객체를 표현한다.
• ReadOnlyRoots 에서 Roots 라는 단어를 정확히 어떤 의미로 사용했는지 모르겠다. 해당 클래스에 주석이 안 달려있다. ReadOnlyHeap 이라는 읽기 전용 공간, 루트, 캐쉬 생성과 파괴를 관리하는 클래스가 있는데, Heap이라는 자료 구조의 Root를 이야기하는 것이 아닐까 추측해본다... 도와주세요 🙇🏾‍♀️

비교 코드

동등 연산자의 실제 비교 코드를 살펴본다. 역시 objects.cc 파일에서 찾을 수 있었다. 꽤 길다 ^^;

Maybe<bool> Object::Equals(Isolate* isolate, Handle<Object> x,
                           Handle<Object> y) {
  while (true) {
    if (x->IsNumber()) {
      if (y->IsNumber()) {
        return Just(StrictNumberEquals(x, y));
      } else if (y->IsBoolean()) {
        return Just(
            StrictNumberEquals(*x, Handle<Oddball>::cast(y)->to_number()));
      } else if (y->IsString()) {
        return Just(StrictNumberEquals(
            x, String::ToNumber(isolate, Handle<String>::cast(y))));
      } else if (y->IsBigInt()) {
        return Just(BigInt::EqualToNumber(Handle<BigInt>::cast(y), x));
      } else if (y->IsJSReceiver()) {
        if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
                 .ToHandle(&y)) {
          return Nothing<bool>();
        }
      } else {
        return Just(false);
      }
    } else if (x->IsString()) {
      if (y->IsString()) {
        return Just(String::Equals(isolate, Handle<String>::cast(x),
                                   Handle<String>::cast(y)));
      } else if (y->IsNumber()) {
        x = String::ToNumber(isolate, Handle<String>::cast(x));
        return Just(StrictNumberEquals(x, y));
      } else if (y->IsBoolean()) {
        x = String::ToNumber(isolate, Handle<String>::cast(x));
        return Just(
            StrictNumberEquals(*x, Handle<Oddball>::cast(y)->to_number()));
      } else if (y->IsBigInt()) {
        return BigInt::EqualToString(isolate, Handle<BigInt>::cast(y),
                                     Handle<String>::cast(x));
      } else if (y->IsJSReceiver()) {
        if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
                 .ToHandle(&y)) {
          return Nothing<bool>();
        }
      } else {
        return Just(false);
      }
    } else if (x->IsBoolean()) {
      if (y->IsOddball()) {
        return Just(x.is_identical_to(y));
      } else if (y->IsNumber()) {
        return Just(
            StrictNumberEquals(Handle<Oddball>::cast(x)->to_number(), *y));
      } else if (y->IsString()) {
        y = String::ToNumber(isolate, Handle<String>::cast(y));
        return Just(
            StrictNumberEquals(Handle<Oddball>::cast(x)->to_number(), *y));
      } else if (y->IsBigInt()) {
        x = Oddball::ToNumber(isolate, Handle<Oddball>::cast(x));
        return Just(BigInt::EqualToNumber(Handle<BigInt>::cast(y), x));
      } else if (y->IsJSReceiver()) {
        if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
                 .ToHandle(&y)) {
          return Nothing<bool>();
        }
        x = Oddball::ToNumber(isolate, Handle<Oddball>::cast(x));
      } else {
        return Just(false);
      }
    } else if (x->IsSymbol()) {
      if (y->IsSymbol()) {
        return Just(x.is_identical_to(y));
      } else if (y->IsJSReceiver()) {
        if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(y))
                 .ToHandle(&y)) {
          return Nothing<bool>();
        }
      } else {
        return Just(false);
      }
    } else if (x->IsBigInt()) {
      if (y->IsBigInt()) {
        return Just(BigInt::EqualToBigInt(BigInt::cast(*x), BigInt::cast(*y)));
      }
      return Equals(isolate, y, x);
    } else if (x->IsJSReceiver()) {
      if (y->IsJSReceiver()) {
        return Just(x.is_identical_to(y));
      } else if (y->IsUndetectable()) {
        return Just(x->IsUndetectable());
      } else if (y->IsBoolean()) {
        y = Oddball::ToNumber(isolate, Handle<Oddball>::cast(y));
      } else if (!JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(x))
                      .ToHandle(&x)) {
        return Nothing<bool>();
      }
    } else {
      return Just(x->IsUndetectable() && y->IsUndetectable());
    }
  }
}

길어서 좀 압박이 있었을 수도 있겠지만, 결국 필요할 때 캐스팅해서 값을 비교하는 것이다. 코드보다는 아래의 알고리즘을 읽어보는게 훨씬 나을 것 같다 😌.

알고리즘

ECMA의 동등 연산자 알고리즘(Abstract Equality Comaprison Algorithm)은 다음과 같다.

1. x와 y의 타입이 같다면, a. x의 타입이 Undefined면 true를 리턴한다. b. x의 타입이 Null이면 true를 리턴한다. c. x의 타입이 Number 라면,

     i. &nbsp&nbspx가 **NaN** 라면, **false**를 리턴한다.
     ii. &nbspy가 **NaN** 라면, **false**를 리턴한다.
     iii. x와 y값이 같으면 **true**를 리턴한다.
     iv.&nbspx가 +0이고 y가 -0일 때, true를 리턴한다.
     v.&nbsp&nbspx가 -0이고 y가 +0일 때, true를 리턴한다.
     vi.&nbsp**false**를 리턴한다.

   d. x의 타입이 String일 때, x와 y의 문자 순서와 그 값이 정확이 일치하면 true를 리턴하고 아니라면 false를 리턴한다. e. x의 타입이 Boolean일 때, x와 y가 모두 true이거나 false이면 true를 리턴하고 아니라면 false를 리턴한다.
2. x가 null이고 y가 undefined면 true를 리턴한다.
3. x가 undefined이고 y가 null이면 true를 리턴한다.
4. x가 Number 타입이고 y가 String 타입일 때, x == ToNumber(y)의 결과를 리턴한다.
5. x가 String 타입이고 y가 Number 타입일 때, ToNumber(x) == y의 결과를 리턴한다.
6. x의 타입이 Boolean 이면, ToNumber(x) == y의 결과를 리턴한다.
7. y의 타입이 Boolean 이면, x == ToNumber(y)의 결과를 리턴한다.
8. x가 String 이나 Number 타입이고 y가 Object 타입일 때, x == ToPrimitive(y)의 결과를 리턴한다.
9. x가 Object 타입이고 y가 String 이나 Number 타입일 때, ToPrimitive(x) == y의 결과를 리턴한다.
10. false를 리턴한다.

[Optional] 재미있는(?) 사이트

내용이 너무 딱딱한 것 같아서 동등, 비교 연산자와 관련한 재미있는(?) 사이트를 소개한다. 비교 연산자를 한 눈에 볼 수 있는 척 하게 해주는 사이트이다 ㅋㅋㅋ. JavaScript Equality Table

소감

지금까지 자바스크립트를 가장한 C++ 코드 블로깅이었다. 자바와 JS의 간단하게 하면 간단하게 끝나는 내용을 깊게 알아보기 위해 C++와 자료구조를 잘 알고 있어야 한다는 느낌을 많이 받았다. 이게 무슨 소용인지 가치가 있는 일인지 헷갈리지만, 그냥 엉덩이 붙히고 앉아서 오랜 시간 하나의 내용을 찾아보는 것을 해내고 있다는 것으로 위안을 삼고있다. 낄낄 😏

참고한 자료

• Github - v8/v8 Repository
• 모던 자바스크립트 Deep Dive, 이웅모, 위키북스
• V8 - Builtin Functions
• V8 - API Reference
• ECMAScript® Language Specification
• JavaScript Equality Table

• [Optional] 이라고 표시된 섹션은 건너뛰어도 읽는데 지장이 없다.
• 의식의 흐름대로 공부 중이니 제목에 어긋나는 내용도 있을 수 있다.

  Integer

  일단 Integer가 어떤 클래스인지 정의를 정확히 보고 싶었다.

  Integer 클래스는 primitive type인 int를 감싸는 객체이다. Integer 객체는 타입이 int인 단일 필드를 포함한다.
  Java 11 공식 문서

[Optional] 공식 문서에서 필드 확인 ✅

_"Integer 객체는 타입이 int인 단일 필드를 포함한다."_라는 문장에 꽂혀서 확인해보고자 공식 문서를 찾아보았다. 그런데... 엥? 없는데요? ㅋㅋㅋㅋ. 시작부터 난관이 예상된다. IntelliJ에서 코드를 찾아보니 AdoptOpenJDK 11 기준으로 1062~1067번 줄에서 찾을 수 있었다.

/**
* The value of the {@code Integer}.
*
* @serial
*/
private final int value;

코드에 멀쩡히 살아있음 + 문서용 주석인데, 왜 공식 문서에는 나오지 않는 걸까?

여러 문서 페이지를 돌아다녀보니 public, protected로 선언된 변수들만 Field Summary 섹션에 나온다. "이럴거면 private 변수에 문서용 주석은 왜 달아놓는데?"라는 생각 + "진짜로 private로 선언되어 있으면 문서에 못 들어가나?"에 대한 의문이 떠오르면서 한 단계 더 나아가 보기로 했다.

[Optional] private 변수를 문서에 포함시키기

항상 궁금한걸 해봐야 직성이 풀리지는 않지만, 한 단계 더 나아가는 습관을 만들기 위해 노오오오오오오오력 해본다 💪! 아래의 코드를 작성했다.

public class Main {

    /**
     * public 으로 선언된 인스턴스 변수
     */
    public int num = 1;

    /**
     * protected 으로 선언된 인스턴스 변수
     */
    protected double doubleNum = 1;

    /**
     * package-private 으로 선언된 인스턴스 변수
     */
    boolean isTrue = true;

    /**
     * private 으로 선언된 인스턴스 변수
     */
    private String str = "Hello";

    public static void main(String[] args) {}
}

그리고 다음과 같이 javadoc 명령어를 실행한다.

$ javadoc Main.java

생성된 파일들 중 패키지명으로된 폴더들을 따라 들어가서 Main.html열어본다. 그럼 Field Summary가 아래와 같이 나타난다. javadoc의 디폴트 동작이 public, protected만 나오게 되어있다는 것을 확인했다.

내가 하고싶은 것은 "private 변수도 문서에 껴주시라요" 이기 때문에, javadoc --help로 옵션질(?)을 해보도록 한다.

여담이지만, 어느순간 자동차 카탈로그의 옵션을 읽는 것보다 커맨드라인 명령어의 옵션을 보는 것이 더 쉬워졌다. 자동차 옵션은 무슨 말인지 하나도 모르겠다.

찾았다!

-private
    Show all types and members. For named modules,
        show all packages and all module details.

보면 쉽지만, 안 찾아보면 평생 모를법한 옵션이다. 적용해보자!

$ javadoc -private Main.java

다시 Main.html을 열어보면 private, package-private 변수가 모두 포함되어 있다!

혹시 여기까지 읽었다면 미안하게 생각한다. 의식의 흐름대로 공부하며 글을 적는 중이다 😜.. 본론으로 돌아가자!

IntegerCache

IntegerCache도 private 클래스이기 때문에 Integer 문서에 나타나지 않는다. IntelliJ에서 코드를 확인해보면 다음과 같은 설명이 나온다.

Cache to support the object identity semantics of autoboxing for values between -128 and 127 (inclusive) as required by JLS
AdoptOpenJDK 11

무슨 말인지 이해는 되는데 한글로 못 적겠는 그런거 내 맘 알지 😜?

-128과 127 사이의 값을 오토박싱한 객체가 유일함을 캐싱한다.
초 간단 번역

번역 피드백 좀 주십쇼... 🙇🏻‍♂️

코드 살펴보기 🕵🏽‍♀️

이거 구글에 검색해보면 다 나오는거지만 나도 한 번 해보겠다. AdoptOpenJDK 11 버전의 코드를 기준으로 한다.

private static class IntegerCache {
    static final int low = -128;
    static final int high;
    static final Integer cache[];

    static {
        // 캐싱 가능한 최대 int 값은 디폴트가 127이다.
        int h = 127;
        // 시스템 프로퍼티 -Djava.lang.Integer.IntegerCache.high 또는
        // JVM 옵션 -XX:AutoBoxCacheMax을 설정한 경우
        // 캐싱 가능한 최대값 설정
        String integerCacheHighPropValue =
            VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
        if (integerCacheHighPropValue != null) {
            try {
                int i = parseInt(integerCacheHighPropValue);
                i = Math.max(i, 127);
                h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
            } catch( NumberFormatException nfe) {
                // int로 파싱이 불가능하면 무시한다.
            }
        }
        high = h;

        // 캐싱 배열에 Integer 객체 미리 만들어 삽입
        // -128부터 127까지 미리 만들어 놓는다!
        cache = new Integer[(high - low) + 1];
        int j = low;
        for(int k = 0; k < cache.length; k++)
            cache[k] = new Integer(j++);

        // 캐싱 가능한 최대 int 값은 127보다 같거나 커야한다.
        // 위의 i = Math.max(i, 127); 코드에서 알아서 걸러준다.
        assert IntegerCache.high >= 127;
    }

    private IntegerCache() {}
}

어떻게 동작하는지 살펴보았다. 다른 Wrapper 클래스들도 이런 캐싱을 하는지 궁금해졌다.

[Optional] 다른 Wrapper 클래스들의 Cache 클래스

확인을 직접해보니 Boolean, Float, Double 형 빼고 정수형 Wrapper 클래스들은 각자의 Cache 클래스가 있다. 구현 코드를 보니 JVM 옵션으로 최대 캐싱값을 설정하는 곳은 없었다. 그냥 -128~127 사이의 값 고정이다.

다음은 ByteCache 의 구현 코드이다. ShortCache, LongCache 의 구현도 타입만 다를 뿐 모두 같다.

private static class ByteCache {
    private ByteCache(){}

    static final Byte cache[] = new Byte[-(-128) + 127 + 1];

    static {
        for(int i = 0; i < cache.length; i++)
            cache[i] = new Byte((byte)(i - 128));
    }
}

CharacterCache는 구현 코드가 조금 다르다. 근본은 정수 타입이지만 문자를 표현하기 위한 타입이므로 음수값을 캐싱하지 않는다.

private static class CharacterCache {
    private CharacterCache(){}

    static final Character cache[] = new Character[127 + 1];

    static {
        for (int i = 0; i < cache.length; i++)
            cache[i] = new Character((char)i);
    }
}

Integer로 메모리를 터트려보자 💣

갑자기 왠 메모리를 터트려보자? ㅋㅋㅋㅋ 실제로 Integer 객체를 캐싱하는지 알아보려면 같은 값의 Integer 객체 2개를 선언하고 ==로 비교해보면 쉽게 알 수 있다. 하지만 뭔가 밋밋하고 재미가 없어서 메모리를 터트려보려고 한다. 목표는 java.lang.OutOfMemoryError 이다!

가비지 컬렉션 동작 금지! ✋🏻

아무리 무한 루프로 열심히 객체를 생성한다 한들 가비지 컬렉터가 싹 정리해 버리면 소용이 없다. 그래서 가비지 컬렉팅을 금지시켜야 겠다고 생각을 했다. 그래서 열심히 찾아낸 것이 Epsilon GC이다.

Epsilon: A No-Op Garbage Collector

메모리 할당을 처리하지만 회수 메커니즘을 구현하지 않는 GC를 개발해보세요. 사용 가능한 Heap이 소진되면 JVM이 종료됩니다.
OpenJDK JEP 381 - Epsilon GC

와우! 할당은 하지만 회수를 하지 않는 지금 나의 실험에 꼭 필요한 도구이다! 엡실론 가비지 컬렉터를 적용하려면 다음과 같은 옵션을 주면된다.

-XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC

Baeldung의 Attila Fejér 선생님(?)은 도대체 이런걸 어떻게 알았는지 정말 신기하다... 🤪

최소 & 최대 메모리 옵션

빠른 폭파를 위해 추가적으로 최소, 최대 메모리 옵션을 똑같이 작게 할당했다.

-Xms128m -Xmx128m

무한 루프를 돌려보자

프로그래밍에서 무한 루프 작성은 위험 덩어리라고 배우지만 OutOfMemoryError가 목표이므로 돌려보도록 하겠다. 돌려돌려 돌림판~!

코드는 정말로 별거 없음 그 자체이다.

public class Main {
    public static void main(String[] args) {
        while(true) {
            // Integer i = 1;
            Integer i = 999;
            System.out.println(i);
        }
    }
}

먼저 Integer 객체의 값을 999로 놓고 돌려본다. -XX:AutoBoxCacheMax 옵션을 따로 주지 않았으니 캐싱이 안될 것 이므로 메모리 폭파를 예상했고 결과는 다음과 같다.

...
999
999
999
Terminating due to java.lang.OutOfMemoryError: Java heap space

굿 👍

다음은 값을 1로 놓고 돌려본다. 캐싱이 되는 범위에 있으므로 프로그램이 계속 살아있음을 예상했고 결과는 다음과 같다.

...
1
1
1
Terminating due to java.lang.OutOfMemoryError: Java heap space

?! 저기요 님은 왜 터지시죠..? 정말 한참 고민했다. 생각해보니 System.out.println(i); 이 코드에서 PrintStream에서 Output Stream들이 할당된다는 것을 깨달았다. Epsilon GC가 메모리 공간 해제를 안 해주니 이것들이 쌓여서 이런 결과가 나왔음을 발견했다.

코드를 다시 수정했다.

while(true) {
    Integer i = 1;
    // Integer i = 999;
}

안 터지고 계속 돌아간다 :D

999의 주석을 해제하고 실행시켜보았다. 안 터지고 계속 돌아간다... 어얽... 터져야 되는데?? 😓 그럼 앞에서 터진 것도 Integer 값이 999인 객체를 계속 생성해서 그런 것이 아니었다는 말이다. 에효효효효효효

5시간의 고민 끝에...

위의 코드를 계속 돌렸다 멈췄다 디버깅했다가 검색했다가 생각했다가를 반복하니 5시간이 흘렀다. 진짜 뜬금없이 옛날에 Visual Studio에서 C++ 코딩을 할 때, 컴파일러 최적화 옵션을 줄 수 있고 기본적으로 최적화를 해주었던게 기억이 났다. 혹시나 하는 마음에 자바 컴파일러도 최적화를 해주는지 찾아보았다.

JIT 컴파일러 최적화 4단계

다음의 코드를 작성하면 JIT 컴파일러가 어떻게 최적화하는지 예제와 함께 매우 간단하게만 알아본다.

class A {
    B b;
    public void foo() {
        y = b.get();
        ...do stuff...
        z = b.get();
        sum = y + z;
    }
}
class B {
    int value;
    final int get() {
        return value;
    }
}

1. Inline final method

1단계를 거치면 b.get() 메소드를 호출하는 대신 바로 값으로 치환한다. 접근 시간을 조금이라도 줄일 수 있다.

public void foo() {
    y = b.value; // 바뀐 부분
    ...do stuff...
    z = b.value; // 바뀐 부분
    sum = y + z;
}

2. Remove redundant loads

b.value 코드에 접근하는 것보다 지역 변수에 접근하게 하여 속도를 빠르게 한다.

public void foo() {
    y = b.value;
    ...do stuff...
    z = y; // 바뀐 부분
    sum = y + z;
}

3. Copy propagation

굳이 z라는 추가적인 변수를 사용할 필요가 없기 때문에 y로 바꿔버렸다.

public void foo() {
    y = b.value;
    ...do stuff...
    y = y; // 바뀐 부분
    sum = y + z;
}

4. Eliminate dead code

y = y는 불필요한 동작이므로 지워버렸다.

public void foo() {
    y = b.value;
    ...do stuff...
    // 바뀐 부분
    sum = y + z;
}

JIT 컴파일러가 4단계를 거쳐 코드 최적화를 해주는 것을 보았다. 물론 더 깊게 봤으면 하는 아쉬움이 있지만 글이 너무나도 길어질 것 같아 따로 주제를 빼서 해야할 것 같다.

JIT 컴파일러 비활성화 하기

나의 실험 코드 Integer i = 999;가 JIT 컴파일러에 의해 제거되므로 JIT 컴파일러를 비활성화 하기로 마음먹었다. 다음과 같은 옵션을 주면 된다.

-Djava.compiler=NONE

다시 코드를 돌려보자!

while(true) {
    // Integer i = 1;
    Integer i = 999;
}

Terminating due to java.lang.OutOfMemoryError: Java heap space

ㅅㄱ... 드디어 끝났다!

결론

IntegerCache가 동작한다는 것을 내부 구현 코드만 봐도 알 수 있지만 뭔가 색다르게 증명해보고 싶었다. 그 와중에 알게된 것도 많고 깊게 공부하려는 습관을 만드는데 많은 도움이 된 것 같다. 재미있는 시간이었다! 💪

참고한 자료

• Javadoc - Integer
• javadoc --help
• Github - AdoptOpenJDK/openjdk-jdk11
• Baeldung - An Introduction to Epsilon GC
• EJP 318: Epsilon: A No-Op Garbage Collector
• Cameron McKenzie - How to Stop Java GC and Prevent Garbage Collection on the JVM
• StackOverFlow - How to disable compiler and JVM optimizations?
• Oracle - Understanding JIT Compilation and Optimizations

자바 책을 펼쳤다. Hello World 예제가 나오면서 main 메소드는 이렇게 생겨먹은거니 일단 넘어가란다. 내가 펼친 책은 자바를 처음 배우는 사람을 위해 쓰여졌지만, 나는 처음 배우는 사람이 아니므로 "그러라 그래~" 식으로 넘어가면 안될 것 같았다. 보통은 프로그래밍 공부하면서 통하지 않는 방법이다. 하지만 이번에는 "그냥 그래라" 하긴 해야한다.

어떻게 생겨먹었나

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

psvm으로 외워보고 public static void main(String[] args)라고도 외워보고 자바를 처음 배울때 왜 이렇게 안 외워졌는지 모르겠다. 그런데 한가지 표현법이 더 있다. 별건 아니고 가변인자(variable arguments; varargs)를 사용하는 것이다.

public static void main(String... args)

저렇게 적어두면 실행해보지 않아도 IDE가 먼저 반응할 것이다.

public

흔히 알고있는 접근 제어자(access modifier) public이다. 어디에서나 누구나 main 메서드에 접근 가능하다는 뜻이라는 것은 대부분 알 것이다. 그럼 왜 꼭 public 이어야할까? 사실 JVM을 만드는 사람이 어떤 접근 제어자에 상관없이 하려면 그렇게 만들 수 있을 것이다. 하지만 public이어야 한다고 JVM 코드에 못박혀져있다.

JVM에서의 main 메소드 호출

나도 public에 대해 쓰려다가 JVM에서 main 메소드가 어떻게 호출되는지 쓰게될지 전혀 몰랐다 🤣. OpenJDK7의 java.c라는 파일에 적힌 내용을 살펴보았다. C언어를 잘 몰라도 고수님들이 함수이름을 예쁘게 적어두었기 때문에 흐름을 파악하는 수준에서는 큰 무리가 없었다. 읽기 쉬운 코드 작성의 필요성을 다시 한 번 느낀다.

// 중간에 생략된 코드가 많습니다.

// main 메소드가 있는 클래스를 로딩한다.
mainClassName = GetMainClassName(env, jarfile);
mainClass = LoadClass(env, classname);

// main 메소드의 아이디를 찾는다.
mainID = (*env)->GetStaticMethodID(env, mainClass, "main", "([Ljava/lang/String;)V");

/*
  mainClass, mainID를 가지고 
  java.lang.reflect.Method 객체로 변환한다.
  JNI_TRUE면 static 메소드를 찾는다.
*/
jbject obj = (*env)->ToReflectedMethod(env, mainClass, mainID, JNI_TRUE);

/*
  위에서 찾은 Method 객체를 이용하여 
  getModifiers라는 메소드의 아이디를 찾는다.
*/
mid = (*env)->GetMethodID(env, (*env)->GetObjectClass(env, obj), "getModifiers", "()I");

// getModifiers 메소드를 이용하여 
// main 메소드의 접근지시자를 알아낸다.
// public이 아니면 안된다!
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
    message = "Main method not public.";
    messageDest = JNI_TRUE;
    goto leave;
}

// String[] args를 가져온다.
mainArgs = NewPlatformStringArray(env, argv, argc);

// 드디어 실행시킨다!
(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

OpenJDK7 이라 미안하다. 여기 코드가 하나의 파일에 모여있어서 찾아보기 쉬워서 그랬다... 시간이 되면 11버전으로 업데이트를 해보겠다.

다시 public

JVM이 main 메소드는 public이라고 강제한다는 것까지 알아보았다. 그럼 실제로 다른 접근 지시자를 적으면 어떻게 될까?

private static void main(String[] args) {
    System.out.println("Hello World");
}

private 키워드로 실행해보면...

Error: Main method not found in class com.choonghee.MainMethod, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

main 메소드를 찾을 수 없다고 에러를 발생시킨다! 다른 접근 지시자들도 마찬가지의 에러를 뱉어낸다. 물론, 실행전에 IDE가 먼저 반응할 것 이다. 👅

static

static 키워드는 _인스턴스 생성없이 메서드를 호출할 수 있음_을 의미한다. JVM 코드에서 살펴봤듯이 main 메소드 실행시 JNI_TRUE로 static 메소드를 찾는다. 이건 납득이 간다. 굳이 메모리 공간 차지해가면서 main 메소드를 실행시킬 인스턴스를 만들 이유가 없기 때문이다.

이번에는 static 키워드를 없애고 실행해봤다.

Error: Main method is not static in class com.choonghee.MainMethod, please define the main method as:
   public static void main(String[] args)

main 메소드에 static 키워드가 없다고 에러를 발생시킨다.

void

void는 메소드의 리턴 값이 없음을 의미한다. JVM이 CallStaticVoidMethod 함수를 호출시킨다. 그러므로 void 키워드여야 한다. 이것도 이해가 간다. 자바는 메소드에 리턴 타입이 있을 때 암묵적으로 값을 알아서 넘겨주는 언어가 아니다. 그리고 프로그램이 끝나는 마당에 리턴값을 넘겨줄 필요가 없다. 물론 정상적인 종료를 판단하기 위해 int를 리턴하는 C같은 언어도 있다.

리턴 타입을 다른 타입으로 변경하고 실행해봤다.

Error: Main method must return a value of type void in class com.choonghee.MainMethod, please 
define the main method as:
   public static void main(String[] args)

main 메소드의 리턴 타입을 void로 해달라고 에러를 발생시킨다.

main

JVM이 main 메소드 아이디를 찾는 부분에서 메소드명 인수에 "main"이라고 하드 코딩이 되어있다. 이것은 Java가 C언어의 영향을 받았기 때문에 협상의 여지가 없다.

여담이지만 C언어는 B언어의 영향을 받았다. B언어 튜토리얼을 보면, 프로그램의 시작은 main 부터 시작이라고 적혀있다.

-- General Layout of B Programs -- 

main( ) {
-- statements --
}
newfunc(arg1, arg2) {
-- statements --
}
fun3(arg) {
-- more statements --
}

main이라는 이름 대신 다른 이름을 적으면, main 메서드를 찾을 수 없다는 에러가 발생한다.

String[] args

커맨드 라인의 argument들을 의미한다. JVM이 main 메소드의 변수명을 강제하지 않으니 변수명은 마음대로 바꿔도 잘 동작한다. JVM의 main 함수에서 arguments들을 가져와서 main 메소드까지 여러 과정을 거쳐서 보내준다.

// 여기서 커맨드 라인의 인자들을 받아온다.
int main(int argc, char ** argv)

/*
struct JavaMainArgs {
  int     argc;
  char ** argv;
  char *  jarfile;
  char *  classname;
  InvocationFunctions ifn;
};
*/

// JavaMain 함수를 호출하기 위해 인자를 세팅한다.
struct JavaMainArgs args;
args.argc = argc;
args.argv = argv;
args.jarfile = jarfile;
args.classname = classname;
args.ifn = ifn;

// JavaMain을 새로운 스레드에서 호출한다.
ContinueInNewThread(JavaMain, threadStackSize, (void*)&args);

// JavaMain이다.
int JNICALL JavaMain(void * _args)

// 문자열 배열로 변신!
int argc = args->argc;
char **argv = args->argv;
mainArgs = NewPlatformStringArray(env, argv, argc);

역시나 JVM이 문자열 배열이여야 한다고 했기 때문에 String[]여야 한다.

다른 타입으로 바꿔보고 실행해봤다.

Error: Main method not found in class com.choonghee.MainMethod, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

main 메소드를 알아보지 못 한다!

결론

제목에 [Java]_라고 적어놨지만 C 코드를 더 많이 봤다. main 메소드에 대한 나의 결론은 JVM이 _"그러라 그래"_라고 말해주는 것이다. 왜 JVM이 그렇게 동작하도록 만들었는지 이유를 찾아서 알려주고 싶지만 고슬링 선생님을 만나봐야 알 것 같다. 답장을 줄지는 모르겠지만 DM을 한 번 날려보겠다. 응답이 있다면 다시 블로깅을 해보겠다!! _I miss you ~ 💪

DM 보냈습니다. 답장 기다려봅니다!

참고한 자료

• Java Language Specification - SE 8 Edition
• OpenJDK 7 Hotspot Launcher - Java.c
• Oracle JNI Functions
• Java T Point- Java Main Method
• A TUTORIAL INTRODUCTION TO THE LANGUAGE B
• Wikipedia - Java