어제도그랬어

ktlint (kotlin lint) 적용

길순이 — Thu, 31 Mar 2022 22:45:20 +0900

소스 코드를 분석하여 프로그램 오류, 버그, 스타일 오류, 의심스러운 구조체에 표시를 달아놓기 위한 도구입니다.

개발 팀원들이 비지니스 로직에만 집중하도록 이외의 것들은 표준화 시킬 수 있습니다.
때에 따라 커스텀하게 디벨롭 시켜나갈 수 있습니다.
비지니스 로직 이외의 것들에 대한 표준화가 되면 유지보수 및 장애대응의 퍼포먼스를 가져갈 수 있습니다.

.editorconfig 설정

.editorconfig 파일을 기반으로 스타일 검사를 진행합니다. 자세한 내용은 EditorConfig에 설명되어 있습니다. .editorconfig 파일이 없는 경우 기본룰 Ktlint 버전에 따라서 Standard rules를 기본적으로 따르지만 버전이 변경이 되면 Standard rules로 변경이 될 수 있기 때문에 root 디렉터리에 .editorconfig파일을 설정하는 것을 권장합니다.

사용 방법

아래의 formatting의 ktlint format 은 auto로 잡아 주지만 간헐적으로 소스파일을 삭제하기 때문에 조심히 사용하는 것을 권장드립니다.

빌드 성공 시:

빌드 실패 시:

IntelliJ kotlin style guide 적용 방법

IntelliJ > Preferences(MacOS 기준 Command + ,) > Editor > Code Style > kotlin 메뉴로 진입
우측 상단의 (Set from...) 클릭
kotlin style guide 클릭
그 다음 중간 상단 탭의 Imports 클릭
Top-Level Symbols 클릭 -> Use single name import 클릭
Java Statics and Enum Members -> Use single name import 클릭
아래의 Packages to Use Import with 에서 import java.util.* remove
apply 후 ok 클릭

reference:

datadog apm setup

길순이 — Thu, 31 Mar 2022 22:41:38 +0900

Amazon Linux Agent set
apm agent set
jvm args set

위와 같이 현재는 Host-Based 이기 때문에 Host 내부에 data-dog agent를 설치해주셔야 합니다.

위의 datadog apm docs에 가시면 친절히 설명되어있습니다.

현재 배포는 서비스 스크립트를 이용해서 shop-api-dogpre-prod.conf 을 읽어서 pid, log, java_opts 등을 설정하고 있습니다. 여기에 추가적으로 등록해주시면 됩니다.

매트릭 결과

매트릭 확인 목록

why datadog?

길순이 — Thu, 31 Mar 2022 22:37:03 +0900

DataDog은 어떻게 가장 큰 APM (성능 분석 솔루션) 회사가 되었나?

datadog 장점

MSA 시대에 맞는 새로운 뷰

2. 다양한 오픈소스 기술을 지원하는 에이전트, 커스텀마이징한 뷰

3. 결정적 한 방 - 멀티 클라우드 환경도 한 곳에서.. / 빠른 기술 변화를 흡수..

물론 지금은 다른 업체들도 되지만, 멀티 클라우드 (AWS, Azure, GCP) 특화된 기능을 가장 빠르게 제공하고 이걸 통합해서 볼 수 있는 뷰를 누구보다 빠르게 제공했다. 또한 빠른 기술 스택의 변화를 따라가면서 Agent들을 쏟아내고 있다.

infrastructure architecture

길순이 — Thu, 31 Mar 2022 22:32:50 +0900

[ 2019 ~ 21.12.13(월) 기준 Funnc infrastructure architecture ]

현 상황의 인프라 아키텍처의 문제점:

db 보안관련
가용영역 관련
오케스트레이션 사용하지 않고 있다는 점.

[ 개선된 infrastructure architecture ]

# Reference

reference :

https://devocean.sk.com/search/techBoardDetail.do?ID=163244
https://owin2828.github.io/devlog/2020/01/10/aws-2.html

https://tech.cloud.nongshim.co.kr/2018/10/16/4-%EB%84%A4%ED%8A%B8%EC%9B%8C%ED%81%AC-%EA%B5%AC%EC%84%B1%ED%95%98%EA%B8%B0vpc-subnet-route-table-internet-gateway/

Deploying to Amazon Elastic Container Service

길순이 — Thu, 31 Mar 2022 22:28:01 +0900

현 상황의 배포 시스템을 컨테이너 기반 배포시스템으로 빠르게 구축합니다. 추후 필요에 따라 k8s 기반으로 넘어갈 것이지만 현재 당면한 배포시스템의 문제로 인해 일단 빠르게 시스템을 구축하는 것을 목표로 합니다.

개요:

오늘 오전 10:50 부터 약 3~40분 동안 강대 서비스 장애가 있었습니다. 장애 진행 상황, 원인 및 대응책을 말씀드리려고 합니다.원인 및 대응책 요약:
장애 원인은 요약하면 낙후된 배포 시스템과, 실수, 빠른 롤백이 불가한 배포 환경이라고 볼 수 있습니다. 다양한 프로젝트와 이슈 대응으로 배포 시스템 개선이 아직 이루어지지 못했는데 이번 스프린트에서 개발팀은 무조건 최신 기술을 활용한 배포 시스템을 도입하려고 합니다.timeline:

10:40 경 강대 백엔드-1 서버 배포 완료: 문제가 있었지만 배포 시스템에 오류 표시 안됨

10:50 경 강대 백엔드-2 서버 배포 완료. 오류 메시지 없이 전체 서비스 장애 시작

11:00 원인 파악. 12/8 릴리즈를 위해 신규로 추가된 데이터베이스 테이블의 권한 설정에 문제가 있었음

11:30 경 수정 백엔드 배포 및 이슈 해결

장애 원인:

우선적으로는 데이터베이스 테이블 권한 설정에 대한 실수

그럼에도 불구하고 동시 다발적으로 진행되는 많은 이슈로 인한 실수 가능성이 높은 상황인 것은 해결책을 생각할 때 고려 해야 함

배포 시스템에서 심각한 배포 문제에 대한 오류 메시지가 표시 되지 않는 것도 배포 중 사고 위험을 높이는 이유

action items:

빠르고 안전한 롤백을 가능하게하는 배포 시스템이 절실함. Docker를 사용하는 이미지 기반 배포 시스템이 있었으면 장애 시간을 10분 미만으로 할 수 있었음

프로덕션 배포를 하기 전에 stage 단계를 만들어서 백엔드 서버에 문제가 없는지 확인할 수 있는 배포 시스템 기능이 필요함

배포 중 서버 로그 및 메트릭을 손쉽게 확인할 수 있는 모니터링 시스템 추가 필요

메트릭은 좋은 상용 솔루션을 활용할 수 있음

서버 로그는 내부 tool을 개선하여 개발자가 쉽게 배포 서버 로그를 확인할 수 있게 개선할 필요 있음

실수를 줄이기 위해 사전 리뷰 및 테스트에 좀더 개발 시간을 사용할 필요가 있음

그럼에도 불구하고 실수는 언제나 발생할 수 있기 때문에 그것을 확인 및 방지할 수 있는 다중의 안전책을 마련 해야함배포 시스템도 다양한 옵션이 있으나 가장 빠른 시간 안에 도입하여 배포 관련 안정성을 크게 높일 수 있는 방향으로 신속히 대응하도록 하겠습니다.

감사합니다.

하나의 os에서 격리된 컨테이너 실행 환경을 제공합니다.

매번 실행환경을 셋팅 할 필요도 없다.
간편하게 이미지라는 작업으로 가능하게 됩니다.

ECS의 클러스터는 도커 컨테이너를 실행할 수 있는 논리적인 공간이라고 볼 수 있는데요, 우리가 사용하는 도커 컨테이너는 도커가 설치된 컨테이너 인스턴스에서 컨테이너가 실행되며 이 인스턴스들을 목적에 따라 하나로 묶어주는 것이 바로 클러스터라고 할 수 있습니다.

- 구현 된 아키텍처

ElastiCache(Redis) 구축

길순이 — Wed, 30 Mar 2022 16:37:49 +0900

ElastiCache for Redis를 구축할 때 고민해야 하는 것 중 하나가 클러스터 구성입니다.

클러스터 구성에 세 가지 옵션이 있습니다.

싱글 클러스터 노드
클러스터 모드 없이 Replication만 지원 (클러스터 모드 X )
클러스터 모드와 Replication 모두 지원 (클러스터 모드 O)

Redis는 Primary Node와 Replica Node로 구성하는게 일반적이며, 이런 구성을 shard로 여러 벌 준비하여 data parinioning을 수행하는 것이 클러스터 모드(clsuter mode)입니다.

Redis의 쓰임새에 맞게 위 구성 중 하나를 선택해야 합니다. 선택의 기준은 최종 애플리케이션의 신뢰성, 사용성, 확장성에 기인합니다.

ex)

주 노드(Primary Node) 문제 발생 → Replica Nodes 사용 → 복제 지연으로 인해 일부 데이터 손실 가능
특정 가용 영역에 문제 발생 → Multi-AZ 구성으로 타 가용 영역의 Replica Node 사용

각각의 특징은 다음과 같습니다.

클러스터 모드는 언제 유용합니까?

일단 가용성이 중요한 상용 프로덕션 환경이라면 Replication은 필수적이라 할 수 있습니다. 다만 Replication은 수직 확장만 지원한다는 단점이 있습니다.

클러스터 모드는 위 테이블에서 볼 수 있듯이 샤드를 이용한 수평 확장(scaling)이 가장 큰 특징입니다. 이를 이용해 최대 90개 샤드에서 100TB 용량의 큰 데이터 규모로 스케일 확장이 가능합니다. 이는 새로운 서비스의 워크 로드의 저장 용량 산정이 어려울 경우에 대한 대비도 가능합니다.

read 작업이 많을 때는 하나의 샤드 안에 read replica를 추가하는 방식(최대 5개)을 사용하고 write 작업이 많을 때엔 클러스터 모드를 통해 추가적인 write endpoints(추가적인 primart node)를 새로운 샤드를 통해 얻어오는 방식이 바람직합니다.

데이터 샤딩(Data Sharding)

Redis는 모든 캐시 키가 해시 슬롯(hash slot)에 매핑하는 방식으로 샤딩을 활용한다. 1개의 클러스터는 16,384개의 해시 슬롯을 사용할 수 있고 일반적으로 클러스터 내 총 샤드에 균등하게 배포한다.

이는 동일한 캐시키를 사용하는 데이터는 모든 Redis 노드에 read/write가 가능하다는 의미입니다. 워크 로드가 증가하면 가용성을 확보하고 성능 지연을 줄이기 위해 복수 노드에 워크 로드를 분산합니다. 이때에도 redis 클라이언트는 하나의 endpoint에 접속하며 redis 내부에서 로드를 분산하는 구조입니다.

아래는 캐시키 foo인 데이터를 찾는 알고리즘을 보여줍니다.

e.g.) CRC16(“foo”) mod 16384 = 12182 → 3번째 샤드

AWS 구축

search에서 elasticache를 선택합니다.

redis tab에서 create를 눌러줍니다.

클러스터 모드를 활성화 해줍니다.

일반적인 노드유형을 선택했습니다.

위의 해당 유형으로1개의 샤드에 primary node1, replica node2를 배치했을 경우

아래와 같이 계산이 됩니다.

참고 가격정책: https://aws.amazon.com/ko/elasticache/pricing/

고급 Redis 설정(log, 백업, maintenance)은 defalut로 설정해놓았습니다.이는 상황에 따라 설정 가능합니다.

Bastion 서버를 통해 Redis 접속

먼저 ElastiCache 보안그룹에서의 redis 6379 port와 ecs에서의 인바운드 규칙 작업을 선행해야 합니다.

Bastion 서버에 SSH를 통해서 접속

pem 파일의 경우 Bastion 인스턴스 생성 시 마지막 단계에서 생성한 Key Pair
pem 파일이 있는 경로에서 아래 명령어를 실행
주소의 경우 Bastion 서버의 퍼블릭 아이피 정보

shpo-api-dev로 들어옵니다.

Bastion 서버에 접속 후 redis cli 설치

# make를 위한 gcc 설치
[bation]$ sudo yum install -y gcc

# redis-cli 다운로드 & 설치
[bation]$ wget http://download.redis.io/redis-stable.tar.gz && tar xvzf redis-stable.tar.gz && cd redis-stable && make

# 모든 위치에서 사용 가능하도록 /user/bin에 파일 복사
[bation]$ sudo cp src/redis-cli /usr/bin

redis-cli 관련 바이너리 파일들을 설치했습니다.

Bastion 서버에서 redis-cli로 ElastiCache 접속

[기본 엔드포인트] 정보가 funnc-catpre-redis.xxxxxxxxxx.clustercfg.apn2.cache.amazonaws.com:인 경우 아래와 같이 url과 port 번호 설정

redis-cli -h funnc-catpre-redis.xxxxxxxxxx.clustercfg.apn2.cache.amazonaws.com -p 6379

위와 같이 cluster slots를 확인할 수 있습니다.

해당 캐쉬의 데이터 등을 확인하고 컨트롤 하려면 redis-cli 명령어를 통해 할 수 있습니다.

redis 공식 docs를 이용하거나 redis-cli의 help 커멘드로 자세하게 확인할 수 있지만,

https://freeblogger.tistory.com/10 아래의 한국어로 정리되어 있는 글을 첨부해놓겠습니다.

Tuning

위의 tuning options 을 주어 master, replica

aws elasti-cache의 write to master, read from replica로 설정할 수 있습니다. aws elasti-cache의 cluster-mode의 또 하나의 특징은 각 샤드 내부의 노드들을 알고 있는 수퍼 구성 엔드포인트를 제공합니다. ( 다른 모드들은 node를 일일이 하나씩 주입을 시켜줘야 합니다. 물론 aws elasti-cache 관련 library를 사용하면 푸는 방법은 존재합니다. )

Monitoring

위와 같이 cloudwatch를 이용할 수 있습니다.

참고

what is redis?

길순이 — Wed, 30 Mar 2022 16:27:29 +0900

레디스란?

Redis(Remote Dictionary Server)는 오픈 소스 인메모리 키-값 데이터 저장소로 주로 인메모리 데이터베이스, 캐시, 메시지 브로커, 큐로 사용됩니다. 오늘날 대부분의 최신 애플리케이션은 Redis를 캐시 서버로 사용합니다.

캐싱이 필요한 이유는 무엇입니까?

캐싱은 불필요한 네트워크 호출, 데이터베이스 호출 및 하드 디스크에 대한 반복적인 읽기-쓰기 작업을 방지하여 응용 프로그램 성능을 향상시키는 데 주로 사용됩니다.

예를 들어 애플리케이션이 국가 마스터, 언어 마스터, 애플리케이션 구성 등과 같은 일부 정적 데이터를 자주 사용하고 일부 파일이나 내부적으로 하드 디스크를 사용하는 데이터베이스에 저장되어 있다고 가정해 보겠습니다.

그래서 이들은 가장 자주 사용되는 데이터이므로 응용 프로그램이 필요할 때마다 내부적으로 하나의 요청이 데이터베이스 또는 파일로 이동하여 밑줄이 있는 하드 디스크로 입출력 작업을 증가시키고 성능 문제를 일으킵니다.

이제 성능을 향상시키기 위해 자주 사용하는 정적 데이터를 하드 디스크에서 인메모리(예: RAM)로 한 번 로드한 다음 후속 요청에 대해 디스크가 아닌 RAM에서 제공할 수 있습니다.

Redis의 인기 있는 사용 사례

데이터 캐싱
세션 저장소
Pub/Sub 메시징 시스템

Who uses Redis?

왜 Collection이 중요한가요?

레디스는 In-Memory 데이터베이스입니다. 즉, 모든 데이터를 메모리에 저장하고 조회합니다. 기존 관계형 데이터베이스(Oracle, MySQL) 보다 훨씬 빠른데 그 이유는 메모리 접근이 디스크 접근보다 빠르기 때문입니다. 하지만 빠르다는 것은 레디스의 여러 특징 중 일부분입니다. 다른 In-Memory 데이터베이스(ex. Memcached) 와의 가장 큰 차이점은 다양한 자료구조 를 지원한다는 것입니다. 레디스는 아래처럼 다양한 자료구조를 Key-Value 형태로 저장합니다.

레디스는 기본적으로 String, Bitmap, Hash, List, Set, Sorted Set 를 제공했고, 버전이 올라가면서 현재는 Geospatial Index, Hyperloglog, Stream 등의 자료형도 지원하고 있습니다.

그렇다면 이렇게 다양한 자료구조를 제공하는게 왜 중요할까요?
바로 개발의 편의성과 난이도 때문입니다.

예를 들어 실시간 랭킹 서버를 구현할 때 관계형 DBMS를 이용한다면 DB에 데이터를 저장하고, 저장된 SCORE 값으로 정렬하여 다시 읽어오는 과정이 필요할 것입니다. 개수가 많아지면 속도가 느려질 텐데요, 이 과정에서 디스크를 사용하기 때문입니다. In-memory 기반으로 서버에서 데이터를 처리하도록 직접 코드를 짤 수도 있겠지만.. 레디스의 Sorted-Set을 이용하는게 더 빠르고 간단한 방법일 것입니다.

레디스는 트랜잭션의 문제도 해결해 줄 수 있습니다. 싱글 스레드로 동작하는 서버의 모든 자료구조는 atomic 하기 때문에, race condition을 피해 데이터의 정합성을 보장하기 쉽습니다.

즉, 외부의 Collections을 잘 이용하는 것만으로 개발 시간 단축이 가능하고, 생각하지 못한 여러가지 문제를 줄여줄 수 있으므로 개발자는 비즈니스 로직에 집중할 수 있다는 큰 장점이 존재합니다.

reference:

https://redis.io/

https://meetup.toast.com/posts/224

https://www.steps2code.com/post/how-to-improve-api-performance-by-using-redis-cache

infinispan? redis ?

길순이 — Wed, 30 Mar 2022 16:23:47 +0900

펀엔씨 프로젝트에서는 infinispan 이라는 로컬캐쉬를 클러스터 모드를 적용이 시켜 글로벌 캐쉬처럼 사용하여 적용되어 있는 상태입니다.

이를 도커 컨테이너 환경에서의 사용이 되도록 알아보던 도중 관련된 캐쉬를 간략하게 알아보고 정리를 했습니다.

infinispan

선택적 스키마가 있는 분산 인메모리 키/값 데이터 저장소.

https://youtu.be/qA2MGwz8vD4

redis

Redis는 선택적 내구성이 있는 분산형 인메모리 키-값 데이터베이스를 구현하는 오픈 소스 인메모리 데이터 구조 프로젝트입니다.

Redis는 데이터베이스, 캐시 및 메시지 브로커로 사용되는 오픈 소스(BSD 라이선스), 인메모리 데이터 구조 저장소입니다. 문자열, 해시, 목록, 집합, 범위 쿼리가 있는 정렬된 집합, 비트맵, 하이퍼로그 로그, 반경 쿼리 및 스트림이 있는 지리 공간 인덱스와 같은 데이터 구조를 지원합니다. Redis에는 복제, Lua 스크립팅, LRU 축출, 트랜잭션 및 다양한 수준의 디스크 지속성이 내장되어 있으며 Redis Sentinel 및 Redis 클러스터를 통한 자동 파티셔닝을 통해 고가용성을 제공합니다.
https://www.youtube.com/watch?v=Wxd6sMUhgBg

infinispan vs redis ?

redis는 memcached와 주로 비교되지만 현재 funnc 프로젝트에서는 infinispan을 적용 된 상태이기 때문에 비교 글을 서치해보았습니다.

https://developers.redhat.com/devnation/tech-talks/redis-vs-infinispan

https://www.saashub.com/compare-infinispan-vs-redis

reference:
https://infinispan.org/introduction/
https://jsonobject.tistory.com/441

DB트랜잭션의 격리 수준(isolation Level)

길순이 — Wed, 7 Apr 2021 01:20:49 +0900

ACID란?

ACID(원자성, 일관성, 고립성, 지속성)는 데이터베이스 트랜잭션이 안전하게 수행된다는 것을 보장하기 위한 성질을 가리키는 약어

원자성(Atomicity)은 트랜잭션과 관련된 작업들이 부분적으로 실행되다가 중단되지 않는 것을 보장하는 능력이다. 예를 들어, 자금 이체는 성공할 수도 실패할 수도 있지만 보내는 쪽에서 돈을 빼 오는 작업만 성공하고 받는 쪽에 돈을 넣는 작업을 실패해서는 안된다. 원자성은 이와 같이 중간 단계까지 실행되고 실패하는 일이 없도록 하는 것이다.
일관성(Consistency)은 트랜잭션이 실행을 성공적으로 완료하면 언제나 일관성 있는 데이터베이스 상태로 유지하는 것을 의미한다. 무결성 제약이 모든 계좌는 잔고가 있어야 한다면 이를 위반하는 트랜잭션은 중단된다.
독립성(Isolation)은 트랜잭션을 수행 시 다른 트랜잭션의 연산 작업이 끼어들지 못하도록 보장하는 것을 의미한다. 이것은 트랜잭션 밖에 있는 어떤 연산도 중간 단계의 데이터를 볼 수 없음을 의미한다. 은행 관리자는 이체 작업을 하는 도중에 쿼리를 실행하더라도 특정 계좌간 이체하는 양 쪽을 볼 수 없다. 공식적으로 고립성은 트랜잭션 실행내역은 연속적이어야 함을 의미한다. 성능관련 이유로 인해 이 특성은 가장 유연성 있는 제약 조건이다. 자세한 내용은 관련 문서를 참조해야 한다.
지속성(Durability)은 성공적으로 수행된 트랜잭션은 영원히 반영되어야 함을 의미한다. 시스템 문제, DB 일관성 체크 등을 하더라도 유지되어야 함을 의미한다. 전형적으로 모든 트랜잭션은 로그로 남고 시스템 장애 발생 전 상태로 되돌릴 수 있다. 트랜잭션은 로그에 모든 것이 저장된 후에만 commit 상태로 간주될 수 있다.

Transaction Isolation Level

ACID의 원칙을 너무 타이트하기 지키면 동시성(Concurrency)에 대한 퍼포먼스가 너무 떨어지기 때문에 Isolation Level별로 차등을 두어 동시성에 대한 이점을 가질 수 있게 하지만 아무래도 문제가 발생할 가능성이 있습니다.

이와 연관되어 데이터베이스에서 데이터를 읽은 다음 애플리케이션에서 처리 후 다시 쓰는 경우에 주의가 필요한데 왜 그런지 정리해봅니다.

ANSI/ISO SQL Standard 에서 정의한 Isolation Level은 다음과 같습니다.

READ UNCOMMITTED
READ COMMITTED
REPEATABLE READ
SERIALIZABLE

READ UNCOMMITTED

SELECT 쿼리 실행시에 다른 트랜잭션에서 COMMIT 되지 않은 데이터를 읽어올 수 있습니다.
COMMIT 되지 않은 데이터를 읽는 현상을 Dirty read라고 말합니다.
INSERT만 진행되고 ROLLBACK 될 수도 있는, 즉 한번도 COMMIT 되지 않은 데이터를 읽을 수 있어 유의해야합니다.

READ COMMITTED

Read Committed에서는 COMMIT이 완료된 데이터만 SELECT시에 보이는 수준을 보장하는 Level이며 대부분의 DBMS에서 Read Committed를 기본으로 설정합니다.

Read Committed에서는 Read Uncommitted에서 발생하는 Dirty read가 발생하지 않도록 보장해줍니다.

트랜잭션에서 COMMIT을 수행하지 않더라도 DB에 이미 값이 반영이 되어있는 상태인데 COMMIT이전의 데이터를 보장 받기 위해서는 COMMIT 되지 않은 쿼리를 복구하는 과정이 필요하게 됩니다.
즉, 이 시점에서는 Consistent Read를 수행해야 함을 의미합니다.

Read Committed의 문제는 하나의 트랜잭션 안에서 SELECT를 수행 할 때마다 데이터가 동일하다는 보장을 해주지 않습니다. 그 이유는 다른 트랜젝션에서 해당 데이터를 COMMIT 했을 경우에는 COMMIT된 데이터를 반환해주는게 Read Committed의 특징이기 때문입니다.
위와 같은 이유로 Read Committed를 Non-repeatable Read 라고도 합니다.

REPEATABLE READ

Read Committed와는 다르게 Repeatable Read는 한 트랜잭션 안에서 반복해서 SELECT를 수행하더라도 읽어 들이는 값이 변화하지 않음을 보장합니다.

Repeatable Read 트랜잭션은 처음으로 SELECT을 수행한 시간을 기록한 뒤 그 이후에는 모든 SELECT 마다 해당 시점을 기준으로 Consistent Read를 수행하여줍니다.
그러므로 트랜잭션 도중 다른 트랜잭션이 COMMIT 되더라도 새로이 COMMIT 된 데이터는 보이지 않게됩니다.
그 이유는 첫 SELECT 시에 생성된 SNAPSHOT을 읽기 때문입니다.

해당하는 Row를 INSERT하는 것은 가능합니다. 따라서 동일 트랜잭션에서 Read되는 데이터 수가 달라질 수 있습니다.

SERIALIZABLE

Serializable은 모든 작업을 하나의 트랜젝션에서 처리하는 것과 같은 가장 높은 고립수준을 제공합니다.

Read Committed, Repeatable Read 두개의 공통적인 이슈는 Phantom Read가 발생한다는 점입니다.

Transaction Isolation Level 은 Read Uncommited 에서 Serializable 순으로 Concurrency 는 높아지고 속도는 느려진다. 따라서 이 둘의 균형을 잘 맞추는 것이 중요합니다.

위 네가지 Isolation Level 에 따라 나타나는 현상이 세가지가 있습니다.

Dirty Read
Repeatable Read
Phantom Read

Dirty Read

어떤 트랜잭션에서 아직 실행이 끝난지 않은 다른 트랜잭션에 의한 변경 사항을 보게 되는 되는 경우를 dirty read 라고 합니다. 만약 원래 트랜잭션에서 그 변경 사항을 롤백하면 그 데이터를 읽은 트랜잭션은 dirty 데이터를 가지고 있다고 말합니다.

Repeatable Read

어떤 트랜잭션에서 같은 질의를 사용했을 때 질의를 아무리 여러번 해도 그리고 다른 트랜잭션에서 아무리 여러 번 그 행을 변경해도 항상 같은 데이터만 읽어드리는 경우를 repeatable read 라고 합니다. 즉 repeatable read 가 요구되는 트랜잭션에서는 다른 트랜잭션에 의한 변경 사항을 볼 수가 없습니다. 그러한 변경 사항을 보고 싶으면 어플리케이션에서 트랜잭션을 새로 시작해야 합니다.

Phantom Read

phantom read 는 다른 트랜잭션에 의한 변경 사항으로 인해 현재 사용 중인 트랜잭션의 WHERE 절의 조건에 맞는 새로운 행이 생길 수 있는 경우에 관한 것입니다. 예를 들어, 잔고가 $100 미만인 계좌를 모두 찾아내는 트랜잭션이 있고, 이 트랜잭션에서 그 데이터를 두 번 읽는다고 가정합시다. 처음 데이터를 읽어들이고 난 후에 다른 트랜잭션에서 잔고가 $0인 계좌를 새로 만들면 이 계좌도 잔고가 $100 이하라는 조건에 맞게 됩니다. 트랜잭션 격리 수준(Transaction Isolation Level)에서 phantom read 를 지원하면 새로운 “유령(phantom)”행이 나오지만 지원하지 않으면 새로 생긴 행을 볼 수 없습니다.

결론 : SERIALIZABLE이 아니면 UPDATE, DELETE에 주의

참고 : ko.wikipedia.org/wiki/ACID

velog.io/@lsb156/Transaction-Isolation-Level#%EC%9B%90%EC%9E%90%EC%84%B1--atomicity-

blog.sapzil.org/2017/04/01/do-not-trust-sql-transaction/

suhwan.dev/2019/06/09/transaction-isolation-level-and-lock/

Lock으로 이해하는 Transaction의 Isolation Level

개요 내게 transaction의 isolation level은 개발할 때 항상 큰 찝찝함을 남기게 하는 요소였다. row를 읽기만 할 때는 REPEATABLE READ로, row를 삽입 / 수정 / 삭제할 때는 SERIALIZABLE로 isolation level을 지정했지

suhwan.dev

SQL 트랜잭션 - 믿는 도끼에 발등 찍힌다

RDBMS를 쓰는 이유 중 하나는 트랜잭션입니다. 하지만 RDBMS의 트랜잭션을 너무 믿다가는 깜짝 놀랄 일이 벌어질 수도 있습니다.

blog.sapzil.org

Transaction Isolation Level 정리

Isolation을 알기전에 먼저 트랜잭션이 중요시 여기는 ACID라는 것을 먼저 알아야 합니다.Atomicity, Consistency, Isolation, Durability의 앞글자를 따서 ACID라고 불리웁니다.하나의 트랜잭션이 작업이 그중에

velog.io

ACID - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 다른 뜻에 대해서는 애시드 문서를 참조하십시오. ACID(원자성, 일관성, 고립성, 지속성)는 데이터베이스 트랜잭션이 안전하게 수행된다는 것을 보장하기 위한

ko.wikipedia.org

[기술 면접 질문] 기술 면접 예상 질문 대비하기 - Java편

길순이 — Thu, 24 Sep 2020 15:06:14 +0900

java 프로그래밍이란

Java SE와 Java EE 애플리케이션 차이

https://www.ibm.com/support/knowledgecenter/ko/SSQP76_8.9.1/com.ibm.odm.dserver.rules.res.managing/topics/con_javase_javaee_applis.html

java와 c/c++의 차이점

java와 c/c++의 가장 큰 차이점은 실행 환경이다.
java에서의 개발: 컴파일 혹은 컴파일 + jar압축
- 자바는 링크 과정이 없이 컴파일러가 바로 바이트 코드를 생성
c/c++에서의 개발: 컴파일 + 링크

java 언어의 장단점

장점
- 운영체제에 독립적이다.
  - JVM에서 동작하기 때문에, 특정 운영체제에 종속되지 않는다.
- 객체지향 언어이다.
  - 객체지향적으로 프로그래밍 하기 위해 여러 언어적 지원을 하고있다. (캡슐화, 상속, 추상화, 다형성 등)
  - 객체지향 패러다임의 특성상 비교적 이해하고 배우기 쉽다.
- 자동으로 메모리 관리를 해준다.
  - JVM에서 Garbage Collector라고 불리는 데몬 쓰레드에 의해 GC(Garbage Collection)가 일어난다. GC로 인해 별도의 메모리 관리가 필요 없으며 비지니스 로직에 집중할 수 있다. (참고)
- 오픈소스이다.
  - 정확히 말하면 OpenJDK가 오픈소스이다. OracleJDK는 사용 목적에 따라서 유료가 될 수 있다.
    - OracleJDK의 유료화 이슈는 다음을 참고. (참고)
  - 많은 Java 개발자가 존재하고 생태계가 잘 구축되어있다. 덕분에 오픈소스 라이브러리가 풍부하며 잘 활용한다면 짧은 개발 시간 내에 안정적인 애플리케이션을 쉽게 구현할 수 있다.
- 멀티스레드를 쉽게 구현할 수 있다.
  - 자바는 스레드 생성 및 제어와 관련된 라이브러리 API를 제공하고 있기 때문에 실행되는 운영체제에 상관없이 멀티 스레드를 쉽게 구현할 수 있다.
- 동적 로딩(Dynamic Loading)을 지원한다
  - 애플리케이션이 실행될 때 모든 객체가 생성되지 않고, 각 객체가 필요한 시점에 클래스를 동적 로딩해서 생성한다. 또한 유지보수 시 해당 클래스만 수정하면 되기 때문에 전체 애플리케이션을 다시 컴파일할 필요가 없다. 따라서 유지보수가 쉽고 빠르다.
단점
- 비교적 속도가 느리다.
  - 자바는 한 번의 컴파일링으로 실행 가능한 기계어가 만들어지지 않고 JVM에 의해 기계어로 번역되고 실행하는 과정을 거치기 때문에 C나 C++의 컴파일 단계에서 만들어지는 완전한 기계어보다는 속도가 느리다. 그러나 하드웨어의 성능 향상과 바이트 코드를 기계어로 변환해주는 JIT 컴파일러 같은 기술 적용으로 JVM의 기능이 향상되어 속도의 격차가 많이 줄어들었다.
- 예외처리가 불편하다.
  - 프로그래머 검사가 필요한 예외가 등장한다면 무조건 프로그래머가 선언을 해줘야 한다.

http://yolojeb.tistory.com/17

http://huhghiza.tistory.com/7

java의 접근 제어자의 종류와 특징

java의 데이터 타입

기본 데이터 타입(Primitive Data Type)
- 기본 타입의 종류는 byte, short, char, int, float, double, boolean이 있다.
  - 정수형 : byte, short, int, long
  - 실수형 : float, double
  - 논리형 : boolean(ture/false)
  - 문자형 : char
- 기본 타입의 크기가 작고 고정적이기 때문에 메모리의 Stack 영역에 저장된다.
참조 타입(Reference Data Type)
- 참조 타입의 종류는 class, array, interface, Enumeration이 있다.
  - 기본형을 제외하고는 모두 참조형이다.
  - new 키워드를 이용하여 객체를 생성하여 데이터가 생성된 주소를 참조하는 타입이다.
  - String, StringBuffer, List, 개인이 만든 클래스 등
  - String과 배열은 참조 타입과 달리 new 없이 생성이 가능하지만 기본 타입이 아닌 참조 타입이다.
- 참조 타입의 데이터의 크기가 가변적, 동적이기 때문에 동적으로 관리되는 Heap 영역에 저장된다.
- 더 이상 참조하는 변수가 없을 때 가비지 컬렉션에 의해 파괴된다.
- 참조 타입은 값이 저장된 곳의 주소를 저장하는 공간으로 객체의 주소를 저장한다. (Call-By-Value)

http://robyncloud.tistory.com/entry/

https://m.blog.naver.com/PostView.nhn?blogId=roropoly1&logNo=220649338545&proxyReferer=https%3A%2F%2Fwww.google.co.kr%2F

OOP의 4가지 특징

추상화(Abstraction)
- 구체적인 사물들의 공통적인 특징을 파악해서 이를 하나의 개념(집합)으로 다루는 것
캡슐화(Encapsulation)
- 정보 은닉(information hiding): 필요가 없는 정보는 외부에서 접근하지 못하도록 제한하는 것
일반화 관계(Inheritance, 상속)
- 여러 개체들이 가진 공통된 특성을 부각시켜 하나의 개념이나 법칙으로 성립시키는 과정
다형성(Polymorphism)
- 서로 다른 클래스의 객체가 같은 메시지를 받았을 때 각자의 방식으로 동작하는 능력

https://gmlwjd9405.github.io/2018/07/05/oop-features.html

OOP의 5대 원칙

"SOLID" 원칙

S: 단일 책임 원칙(SRP, Single Responsibility Principle)
- 객체는 단 하나의 책임만 가져야 한다.
O: 개방-폐쇄 원칙(OCP, Open Closed Principle)
- 기존의 코드를 변경하지 않으면서 기능을 추가할 수 있도록 설계가 되어야 한다.
L: 리스코프 치환 원칙(LSP, Liskov Substitution Principle)
- 일반화 관계에 대한 이야기며, 자식 클래스는 최소한 자신의 부모 클래스에서 가능한 행위는 수행할 수 있어야 한다.
I: 인터페이스 분리 원칙(ISP, Interface Segregation Principle)
- 인터페이스를 클라이언트에 특화되도록 분리시키라는 설계 원칙이다.
D: 의존 역전 원칙(DIP, Dependency Inversion Principle)
- 의존 관계를 맺을 때 변화하기 쉬운 것 또는 자주 변화하는 것보다는 변화하기 어려운 것, 거의 변화가 없는 것에 의존하라는 것이다.

https://gmlwjd9405.github.io/2018/07/05/oop-solid.html

객체지향 프로그래밍과 절차지향 프로그래밍의 차이

절차지향 프로그래밍
- 실행하고자 하는 절차를 정하고, 이 절차대로 프로그래밍하는 방법
- 목적을 달성하기 위한 일의 흐름에 중점을 둔다.
객체지향 프로그래밍
- 실세상의 물체를 객체로 표현하고, 이들 사이의 관계, 상호 작용을 프로그램으로 나타낸다.
- 객체를 추출하고 객체들의 관계를 결정하고 이들의 상호 작용에 필요한 함수(메서드)와 변수(필드)를 설계 및 구현하다.
- 객체 지향의 핵심은 연관되어 있는 변수와 메서드를 하나의 그룹으로 묶어서 그룹핑하는 것이다.
- 사람의 사고와 가장 비슷하게 프로그래밍을 하기 위해서 생성된 기법
- 하나의 클래스를 바탕으로 서로 다른 상태를 가진 인스턴스를 만들면 서로 다른 행동을 하게 된다. 즉, 하나의 클래스가 여러 개의 인스턴스가 될 수 있다는 점이 객체 지향이 제공하는 가장 기본적인 재활용성이라고 할 수 있다.

java의 non-static 멤버와 static 멤버의 차이

non-static 멤버
- 공간적 특성: 멤버는 객체마다 별도로 존재한다.
  - 인스턴스 멤버 라고 부른다.
- 시간적 특성: 객체 생성 시에 멤버가 생성된다.
  - 객체가 생길 때 멤버도 생성된다.
  - 객체 생성 후 멤버 사용이 가능하다.
  - 객체가 사라지면 멤버도 사라진다.
- 공유의 특성: 공유되지 않는다.
  - 멤버는 객체 내에 각각의 공간을 유지한다.
static 멤버
- 공간적 특성: 멤버는 클래스당 하나가 생성된다.
  - 멤버는 객체 내부가 아닌 별도의 공간에 생성된다.
  - 클래스 멤버 라고 부른다.
- 시간적 특성: 클래스 로딩 시에 멤버가 생성된다.
  - 객체가 생기기 전에 이미 생성된다.
  - 객체가 생기기 전에도 사용이 가능하다. (즉, 객체를 생성하지 않고도 사용할 수 있다.)
  - 객체가 사라져도 멤버는 사라지지 않는다.
  - 멤버는 프로그램이 종료될 때 사라진다.
- 공유의 특성: 동일한 클래스의 모든 객체들에 의해 공유된다.

https://gmlwjd9405.github.io/2018/08/04/java-static.html

❓java의 main 메서드가 static인 이유

static 키워드
- static 멤버는 클래스 로딩(프로그램 시작) 시 메모리에 로드되어 인스턴트를 생성하지 않아도 호출이 가능하다.
main 메서드가 static인 이유
- public static void main(String[] args){...}
- 위와 같은 형식은 java에서의 main() 관례이다. 위와 같은 시그니처를 가진 메소드가 없으면 실행되지 않는다.
- JVM은 인스턴스가 없는 클래스의 main()을 호출해야하기 때문에 static이어야 한다.
JVM과 static
- 코드를 실행하면 컴파일러가 .java 코드를 .class(byte code)로 변환한다.
- 클래스 로더가 .class파일을 메모리 영역(Runtime Data Area)에 로드한다.
- Runtime Data Area 중 Meathod Area(= Class area = Static area)라고 불리는 영역에 Class Variable이 저장되는데, static 변수 또한 여기에 포함된다.
- JVM은 Meathod Area에 로드된 main()을 실행한다.

JVM의 Runtime Data Area - Minhyeok Jung

Why is the Java main method static? - Stack Overflow

main에 static 사용하는이유 :: public static void main(String[] args) - PYH

[자바]static, JVM memory의 기본(1편) - ITPangPang

JAVA :: 자바의 메모리 구조 - 1. 메소드 영역(Method Area) - WANZARGEN

java의 final 키워드

final 키워드
- 개념: 변수나 메서드 또는 클래스가 '변경 불가능'하도록 만든다.
- 원시(Primitive) 변수에 적용 시
  - 해당 변수의 값은 변경이 불가능하다.
- 참조(Reference) 변수에 적용 시
  - 참조 변수가 힙(heap) 내의 다른 객체를 가리키도록 변경할 수 없다.
- 메서드에 적용 시
  - 해당 메서드를 오버라이드할 수 없다.
- 클래스에 적용 시
  - 해당 클래스의 하위 클래스를 정의할 수 없다.
finally 키워드
- 개념: try/catch 블록이 종료될 때 항상 실행될 코드 블록을 정의하기 위해 사용한다.
- finally는 선택적으로 try 혹은 catch 블록 뒤에 정의할 때 사용한다.
- finally 블록은 예외가 발생하더라도 항상 실행된다.
  - 단, JVM이 try 블록 실행 중에 종료되는 경우는 제외한다.
- finally 블록은 종종 뒷마무리 코드를 작성하는 데 사용된다.
- finally 블록은 try와 catch 블록 다음과, 통제권이 이전으로 다시 돌아가기 전 사이에 실행된다.
finalize() 메서드
- 개념: 쓰레기 수집기(GC, Garbage Collector)가 더 이상의 참조가 존재하지 않는 객체를 메모리에서 삭제하겠다고 결정하는 순간 호출된다.
- Object 클래스의 finalize() 메서드를 오버라이드해서 맞춤별 GC를 정의할 수 있다.
  - protected void finalize() throws Throwable { // 파일 닫기, 자원 반환 등등 }

https://gmlwjd9405.github.io/2018/08/06/java-final.html

java의 제네릭과 c++의 템플릿의 차이

java의 제네릭(Generic)
- 개념: 모든 종류의 타입을 다룰 수 있도록 일반화된 타입 매개 변수(generic type)로 클래스나 메서드를 선언하는 기법
- 처리 방법: 타입 제거(type erasure)라는 개념에 근거한다.
  - 소스 코드를 JVM이 인식하는 바이트 코드로 변환할 때 인자로 주어진 타입을 제거하는 기술이다.
  - 제네릭이 있다고 해서 크게 달라지는 것은 없다. 단지 코드를 좀 더 예쁘게 할 뿐이다.
  - 그래서 java의 제네릭(Generic)은 때로는 문법적 양념(syntactic sugar) 이라고 부른다.

Vector<String> vector = new Vector<String>();
vector.add(new String("hello"));
String str = vector.get(0);

// 컴파일러가 아래와 같이 변환
Vector vector = new Vector();
vector.add(new String("hello"));
String str = (String) vector.get(0);

c++의 템플릿(Template)
- 개념: 템플릿은 하나의 클래스를 서로 다른 여러 타입에 재사용할 수 있도록 하는 방법
  - 예를 들어 여러 타입의 객체를 저장할 수 있는 연결리스트와 같은 자료구조를 만들 수 있다.
- 처리 방법: 컴파일러는 인자로 주어진 각각의 타입에 대해 별도의 템플릿 코드를 생성한다.
  - 예를 들어 MyClass가 MyClass와 정적 변수(static variable)를 공유하지 않는다.
  - 하지만 java에서 정적 변수는 제네릭(Generic) 인자로 어떤 타입을 주었는지에 관계없이 MyClass로 만든 모든 객체가 공유한다.
  - 즉, 템플릿은 좀 더 우아한 형태의 매크로 다.

/** MyClass.h **/
template<class T> class MyClass {
  public:
    static int val;
    MyClass(int v) { val = v; }
};

/** MyClass.cpp **/
template<typename T>
int MyClass<T>::bar;
template class MyClass<Foo>;
template class MyClass<Bar>;

/** main.cpp **/
MyClass<Foo> * foo1 = new MyClass<Foo>(10);
MyClass<Foo> * foo2 = new MyClass<Foo>(15);
MyClass<Bar> * bar1 = new MyClass<Bar>(20);
MyClass<Bar> * bar2 = new MyClass<Bar>(35);
int f1 = foo1->val; // 15
int f2 = foo2->val; // 15
int b1 = bar1->val; // 35
int b2 = bar2->val; // 35

java의 제네릭과 c++의 템플릿의 차이
1. List처럼 코드를 작성할 수 있다는 이유에서 동등한 개념으로 착각하기 쉽지만 두 언어가 이를 처리하는 방법은 아주 많이 다르다.
2. c++의 Template에는 int와 같은 기본 타입을 인자로 넘길 수 있지만, java의 Generic에서는 Integer을 대신 사용해야 한다.
3. c++의 Template은 인자로 주어진 타입으로부터 객체를 만들어 낼 수 있지만, java에서는 불가능하다.
4. java에서 MyClass로 만든 모든 객체는 Generic 타입 인자가 무엇이냐에 관계없이 전부 동등한 타입이다.(실행 시간에 타입 인자 정보는 삭제된다.)
  - c++에서는 다른 Template 타입 인자를 사용해 만든 객체는 서로 다른 타입의 객체이다.
5. java의 경우 Generic 타입 인자를 특정한 타입이 되도록 제한할 수 있다.
  - 예를 들어 CardDeck을 Generic 클래스로 정의할 때 CardGame의 하위 클래스만 사용되도록 제한할 수 있다.
6. java에서 Generic 타입의 인자는 정적 메서드나 변수를 선언하는 데 사용될 수 없다.
  - 왜냐하면 MyClass나 MyClass가 이 메서드와 변수를 공유하기 때문이다.
  - c++ Template은 이 두 클래스를 다른 클래스로 처리하므로 Template 타입 인자를 정적 메서드나 변수를 선언하는 데 사용할 수 있다.

코딩 인터뷰 완전 분석, 프로그래밍인사이트

java 직렬화와 역직렬화란 무엇인가

자바 직렬화(Serialization)란
- 자바 시스템 내부에서 사용되는 객체 또는 데이터를 외부의 자바 시스템에서도 사용할 수 있도록 바이트(byte) 형태로 데이터 변환하는 기술
- 시스템적으로 이야기하자면 JVM(Java Virtual Machine 이하 JVM)의 메모리에 상주(힙 또는 스택)되어 있는 객체 데이터를 바이트 형태로 변환하는 기술
자바 직렬화 조건
1. 자바 기본(primitive) 타입
2. java.io.Serializable 인터페이스를 상속받은 객체
직렬화 방법
- java.io.ObjectOutputStream 객체를 이용

자바 역직렬화(Deserialization)란
- 바이트로 변환된 데이터를 다시 객체로 변환하는 기술
- 직렬화된 바이트 형태의 데이터를 객체로 변환해서 JVM으로 상주시키는 형태의 기술
자바 역직렬화 조건
1. 직렬화 대상이 된 객체의 클래스가 클래스 패스에 존재해야 하며 import 되어 있어야 한다.
  - 중요한 점은 직렬화와 역직렬화를 진행하는 시스템이 서로 다를 수 있다는 것을 반드시 고려해야 한다. (같은 시스템 내부이라도 소스 버전이 다를 수 있다.)
2. 자바 직렬화 대상 객체는 동일한 serialVersionUID 를 가지고 있어야 한다.
  - private static final long serialVersionUID = 1L;
역직렬화 방법
- java.io.ObjectInputStream 객체를 이용

http://woowabros.github.io/experience/2017/10/17/java-serialize.html

http://woowabros.github.io/experience/2017/10/17/java-serialize2.html

https://nesoy.github.io/articles/2018-04/Java-Serialize

클래스 객체 인스턴스의 차이

클래스(Class)
- 객체를 만들어 내기 위한 설계도 혹은 틀
- 연관되어 있는 변수와 메서드의 집합
객체(Object)
- 소프트웨어 세계에 구현할 대상
- 클래스에 선언된 모양 그대로 생성된 실체
- '클래스의 인스턴스(instance)' 라고도 부른다.
- 객체는 모든 인스턴스를 대표하는 포괄적인 의미를 갖는다.
- oop의 관점에서 클래스의 타입으로 선언되었을 때 '객체'라고 부른다.
인스턴스(Instance)
- 설계도를 바탕으로 소프트웨어 세계에 구현된 구체적인 실체
  - 즉, 객체를 소프트웨어에 실체화 하면 그것을 '인스턴스'라고 부른다.
  - 실체화된 인스턴스는 메모리에 할당된다.
- 인스턴스는 객체에 포함된다고 볼 수 있다.
- oop의 관점에서 객체가 메모리에 할당되어 실제 사용될 때 '인스턴스'라고 부른다.
- 추상적인 개념(또는 명세)과 구체적인 객체 사이의 관계 에 초점을 맞출 경우에 사용한다.
  - '~의 인스턴스' 의 형태로 사용된다.
  - 객체는 클래스의 인스턴스다.
  - 객체 간의 링크는 클래스 간의 연관 관계의 인스턴스다.
  - 실행 프로세스는 프로그램의 인스턴스다.
- 즉, 인스턴스라는 용어는 반드시 클래스와 객체 사이의 관계로 한정지어서 사용할 필요는 없다.
- 인스턴스는 어떤 원본(추상적인 개념)으로부터 '생성된 복제본'을 의미한다.

/* 클래스 */
public class Animal {
  ...
}
/* 객체와 인스턴스 */
public class Main {
  public static void main(String[] args) {
    Animal cat, dog; // '객체'

    // 인스턴스화
    cat = new Animal(); // cat은 Animal 클래스의 '인스턴스'(객체를 메모리에 할당)
    dog = new Animal(); // dog은 Animal 클래스의 '인스턴스'(객체를 메모리에 할당)
  }
}

Q. 클래스 VS 객체
- 클래스는 '설계도', 객체는 '설계도로 구현한 모든 대상'을 의미한다.
Q. 객체 VS 인스턴스
- 클래스의 타입으로 선언되었을 때 객체라고 부르고, 그 객체가 메모리에 할당되어 실제 사용될 때 인스턴스라고 부른다.
- 객체는 현실 세계에 가깝고, 인스턴스는 소프트웨어 세계에 가깝다.
- 객체는 '실체', 인스턴스는 '관계'에 초점을 맞춘다.
  - 객체를 '클래스의 인스턴스'라고도 부른다.
- '방금 인스턴스화하여 레퍼런스를 할당한' 객체를 인스턴스라고 말하지만, 이는 원본(추상적인 개념)으로부터 생성되었다는 것에 의미를 부여하는 것일 뿐 엄격하게 객체와 인스턴스를 나누긴 어렵다.
추상화 기법
1. 분류(Classification)
  - 객체 -> 클래스
  - 실재하는 객체들을 공통적인 속성을 공유하는 범부 또는 추상적인 개념으로 묶는 것
2. 인스턴스화(Instantiation)
  - 클래스 -> 인스턴스
  - 분류의 반대 개념. 범주나 개념으로부터 실재하는 객체를 만드는 과정
  - 구체적으로 클래스 내의 객체에 대해 특정한 변형을 정의하고, 이름을 붙인 다음, 그것을 물리적인 어떤 장소에 위치시키는 등의 작업을 통해 인스턴스를 만드는 것을 말한다.
  - '예시(Exemplification)'라고도 부른다.

https://www.slipp.net/questions/126

https://opentutorials.org/course/1223/5400

http://cerulean85.tistory.com/149

https://www.ijemin.com/blog/%EC%98%A4%EB%B8%8C%EC%A0%9D%ED%8A%B8%EC%99%80-%EC%9D%B8%EC%8A%A4%ED%84%B4%EC%8A%A4%EC%9D%98-%EC%B0%A8%EC%9D%B4-difference-between-obect-and-instance/

오버로딩과 오버라이딩의 차이

오버로딩(Overloading)
- 두 메서드가 같은 이름을 갖고 있으나 인자의 수나 자료형이 다른 경우
- Ex)
  - public double computeArea(Circle c) { ... }
  - public double computeArea(Circle c1, Circle c2) { ... }
  - public double computeArea(Square c) { ... }
오버라이딩(Overriding)
- 상위 클래스의 메서드와 이름과 용례(signature)가 같은 함수를 하위 클래스에 재정의하는 것
- 상속 관계에 있는 클래스 간에 같은 이름의 메서드를 정의
- Ex) Circle에서 printMe() 메서드를 재정의한다.

public abstract class Shape {
    public void printMe() { System.out.println("Shape"); }
    public abstract double computeArea();
}
public class Circle extends Shape {
    private double rad = 5;
    @Override // 개발자의 실수를 방지하기 위해 @Override(annotation) 쓰는 것을 권장
    public void printMe() { System.out.println("Circle"); }
    public double computeArea() { return rad * rad * 3.15; }
}
public class Ambiguous extends Shape {
    private double area = 10;
    public double computeArea() { return area; }

https://gmlwjd9405.github.io/2018/08/09/java-overloading-vs-overriding.html

Call by Reference와 Call by Value의 차이

Call by Value (값에 의한 호출)
- 함수가 호출될 때, 메모리 공간 안에서는 함수를 위한 별도의 임시 공간이 생성된다.
- 함수 호출시 인자로 전달되는 변수의 값을 복사하여 함수의 인자로 전달한다.
- 복사된 인자는 함수 안에서 지역적으로 사용되는 local value의 특성을 가진다.
- 따라서 함수 안에서 인자의 값이 변경되어도, 외부의 변수의 값은 변경되지 않는다.
Call by Reference (참조에 의한 호출)
- 함수가 호출될 때, 메모리 공간 안에서는 함수를 위한 별도의 임시 공간이 생성된다.
- 함수 호출시 인자로 전달되는 변수의 레퍼런스를 전달한다. (해당 변수를 가리킨다.)
- 따라서 함수 안에서 인자의 값이 변경되면, 인자로 전달된 변수의 값도 함께 변경된다.
Java는 Call by Value 일까? Call by Reference 일까?

class Person {
  private String name;
  public Person(String name) {
    this.name = name;
  }
  public setName(String name) {
    this.name = name;
  }
  @Override
  public String toString() {
    return "name is " + this.name;
  }
}

public class FunctionCallTest {
  public static void assignNewPerson(Person p) {
    p = new Person("hee");
  }
  public static void changeName(Person p) {
    p.setName("hee");
  }

  public static void main(String[] args) {
    Person p = new Person("doy");

    assignNewPerson(p);
    System.out.println(p); // name is doy

    changeName(p);
    System.out.println(p); // name is hee
  }
}

public class FunctionCallTest2 {
    /* parameter는 참조변수 array 자체의 Reference가 아닌 array가 "저장하고 있는 주소값(Value)" */
    public static void changeContent(int[] array) {
        // If we change the content of arr,
        array[0] = 10;  // Will change the content of array in main()
        array[1] = 11;
    }
    public static void changeRef(int[] array) {
        // If we change the reference,
        array = new int[2];  // Will not change the array in main()
        array[0] = 20;
        array[1] = 21;
    }

    public static void main(String[] args) {
        int[] array = new int[2];
        array[0] = 0;
        array[1] = 1;

        changeContent(array);
        for (int i = 0; i < array.length; i++) {
            // Will print 10 11
            System.out.print(array[i] + " ");  // 10 11
        }
        changeRef(array);
        for (int i = 0; i < array.length; i++) {
            // Will still print 10 11
            // (Change the reference doesn't reflect change here)
            System.out.print(array[i] + " ");  // 10 11
        }
    }
}

기본자료형은 Call By Value이고, 참조자료형은 Call By Reference이다??
오해 1. 특정 메서드 내에서 전달 받은 객체의 상태를 변경 할 수 있다.
- changeName 메서드는 참조변수 p가 가리키는 [이름 속성이 "doy"인 Person 객체]를 [이름 속성이 "hee"인 새로운 Person 객체]로 변경한 것이 아니라, 단지 이름 속성만 변경했을 뿐이다.
오해 2. 참조변수는 임의의 객체에 대한 레퍼런스를 저장하므로 메서드로 전달한 값이 레퍼런스(Call by Reference)이다.
- 전달된 레퍼런스는 참조변수 p 자체의 레퍼런스가 아닌 p가 저장하고 있는 값(이것도 레퍼런스)이다.
- 만약 Java가 Call by Reference를 지원한다면 assignNewPerson 메서드 실행 후에 p 참조변수가 가리키는 객체가 [이름 속성이 "hee"인 새로운 Person 객체]로 변경되어야 한다.
- 또한 참조변수 p 자체의 레퍼런스를 얻을 수 있는 방법이 있어야 한다. 그러나 Java는 이 방법을 지원하지 않는다.
따라서 Java는 항상 Call by Value 이다.
- 여기서 value 란?
  - 기본자료형의 값 또는 객체에 대한 레퍼런스
- 기본자료형의 경우 해당하는 변수의 값을 복사해서 전달한다.
- 참조자료형의 경우 해당하는 변수가 가지는 값이 레퍼런스이므로 인자로 넘길 때 Call by Value에 의해 변수가 가지고 있는 레퍼런스가 복사되어 전달된다.

https://wayhome25.github.io/cs/2017/04/11/cs-13/

http://wonwoo.ml/index.php/post/1679

https://brunch.co.kr/@kd4/2

http://mussebio.blogspot.com/2012/05/java-call-by-valuereference.html

https://code.i-harness.com/ko-kr/q/c2ab51

인터페이스와 추상 클래스의 차이

추상 메서드(Abstract Method)
- abstract 키워드와 함께 원형만 선언되고, 코드는 작성되지 않은 메서드

public abstract String getName(); // 추상 메서드
public abstract String fail() { return "Fail"; } // 추상 메서드 아님. 컴파일 오류 발생

추상 클래스(Abstract Class)
- 개념: abstract 키워드로 선언된 클래스
  1. 추상 메서드를 최소 한 개 이상 가지고 abstract로 선언된 클래스
    - 최소 한 개의 추상 메서드를 포함하는 경우 반드시 추상 클래스로 선언하여야 한다.
  2. 추상 메서드가 없어도 abstract로 선언한 클래스
    - 그러나 추상 메서드가 하나도 없는 경우라도 추상 클래스로 선언할 수 있다.
- 추상 클래스의 구현
  - 서브 클래스에서 슈퍼 클래스의 모든 추상 메서드를 오버라이딩하여 실행가능한 코드로 구현한다.
- 추상 클래스의 목적
  - 객체(인스턴스)를 생성하기 위함이 아니며, 상속을 위한 부모 클래스로 활용하기 위한 것이다.
  - 여러 클래스들의 공통된 부분을 추상화(추상 메서드) 하여 상속받는 클래스에게 구현을 강제화하기 위한 것이다. (메서드의 동작을 구현하는 자식 클래스로 책임을 위임)
  - 즉, 추상 클래스의 추상 메서드를 자식 클래스가 구체화하여 그 기능을 확장하는 데 목적이 있다.

/* 개념 a의 예시 */
abstract class Shape { // 추상 클래스
  Shape() {...}
  void edit() {...}
  abstract public void draw(); // 추상 메서드
}

/* 개념 b의 예시 */
abstract class Shape { // 추상 클래스
  Shape() {...}
  void edit() {...}
}

/* 추상 클래스의 구현 */
class Circle extends Shape {
  public void draw() { System.out.println("Circle"); } // 추상 메서드 (오버라이딩)
  void show() { System.out.println("동그라미 모양"); }
}

인터페이스(Interface)
- 개념: 추상 메서드와 상수만을 포함하며, interface 키워드를 사용하여 선언한다.
- 인터페이스의 구현
  - 인터페이스를 상속받고, 추상 메서드를 모두 구현한 클래스를 작성한다.
  - implements 키워드를 사용하여 구현한다.
- 인터페이스의 목적
  - 상속받을 서브 클래스에게 구현할 메서드들의 원형을 모두 알려주어, 클래스가 자신의 목적에 맞게 메서드를 구현하도록 하는 것이다.
  - 구현 객체의 같은 동작을 보장하기 위한 목적이 있다.
  - 즉, 서로 관련이 없는 클래스에서 공통적으로 사용하는 방식이 필요하지만 기능을 각각 구현할 필요가 있는 경우에 사용한다.
- 인터페이스의 특징
  1. 인터페이스는 상수 필드와 추상 메서드만으로 구성된다.
  2. 모든 메서드는 추상 메서드로서, abstract public 속성이며 생략 가능하다.
  3. 상수는 public static final 속성이며, 생략하여 선언할 수 있다.
  4. 인터페이스를 상속받아 새로운 인터페이스를 만들 수 있다.
    - interface MobilePhone extends Phone { }

/* 인터페이스의 개념 */
interface Phone { // 인터페이스
  int BUTTONS = 20; // 상수 필드 (public static final int BUTTONS = 20;과 동일)
  void sendCall(); // 추상 메서드 (abstract public void sendCall();과 동일)
  abstract public void receiveCall(); // 추상 메서드
}

/* 인터페이스의 구현 */
class FeaturePhone implements Phone {
  // Phone의 모든 추상 메서드를 구현한다.
  public void sendCall() {...}
  public void receiveCall() {...}

  // 추가적으로 다른 메서드를 작성할 수 있다.
  public int getButtons() {...}
}

추상 클래스와 인터페이스의 공통점
- 인스턴스(객체)는 생성할 수 없다.
- 선언만 있고 구현 내용이 없다.
- 자식 클래스가 메서드의 구체적인 동작을 구현하도록 책임을 위임한다.
추상 클래스와 인터페이스의 차이점
- 서로 다른 목적을 가지고 있다.
  - 추상 클래스는 추상 메서드를 자식 클래스가 구체화하여 그 기능을 확장하는 데 목적이 있다. (상속을 위한 부모 클래스)
  - 인터페이스는 서로 관련이 없는 클래스에서 공통적으로 사용하는 방식이 필요하지만 기능을 각각 구현할 필요가 있는 경우에 사용한다. (구현 객체의 같은 동작을 보장)
- 추상 클래스는 클래스이지만 인터페이스는 클래스가 아니다.
- 추상 클래스는 단일 상속이지만 인터페이스는 다중 상속이 가능하다.
- 추상 클래스는 “is a kind of” 인터페이스는 “can do this”
  - Ex) 추상 클래스: Appliances(Abstract Class) - TV, Refrigerator
  - Ex) 인터페이스: Flyable(Interface) - Plane, Bird

http://loustler.io/languages/oop_interface_and_abstract_class/

http://alecture.blogspot.com/2011/05/abstract-class-interface.html

JVM 구조

http://www.itworld.co.kr/news/110837

http://hoonmaro.tistory.com/19

Java Collections Framework

Map
- 검색할 수 있는 인터페이스
- 데이터를 삽입할 때 Key와 Value의 형태로 삽입되며, Key를 이용해서 Value를 얻을 수 있다.
Collection
- List
  - 순서가 있는 Collection
  - 데이터를 중복해서 포함할 수 있다.
- Set
  - 집합적인 개념의 Collection
  - 순서의 의미가 없다.
  - 데이터를 중복해서 포함할 수 없다.
Collections Framework 선택 과정
1. Map과 Collection 인터페이스 중 선택 1-1. Collection 선택 시 사용 목적에 따라 List와 Set중 선택
2. 사용 목적에 따라 Map, List, Set 각각의 하위 구현체를 선택 2-1. Map: HashMap, LinkedHashMap, HashTable, TreeMap 2-2. List: LinkedList, ArrayList 2-3. Set: TreeSet, HashSet
Collections Framework 동기화
- https://madplay.github.io/post/java-collection-synchronize

java Map 인터페이스 구현체의 종류

HashMap
- Entry<K,V>의 배열로 저장되며, 배열의 index는 내부 해쉬 함수를 통해 계산된다.
- 내부 hash값에 따라서 키순서가 정해지므로 특정 규칙없이 출력된다.
- key와 value에 null값을 허용한다.
- 비동기 처리
- 시간복잡도: O(1)
LinkedHashMap
- HaspMap을 상속받으며, Linked List로 저장된다.
- 입력 순서대로 출력된다.
- 비동기 처리
- 시간복잡도: O(n)
TreeMap
- 내부적으로 레드-블랙 트리(Red-Black tree)로 저장된다.
- 키값이 기본적으로 오름차순 정렬되어 출력된다.
- 키값에 대한 Compartor 구현으로 정렬 방법을 지정할 수 있다.
- 시간복잡도: O(logn)
ConCurrentHashMap
- multiple lock
- update할 때만 동기 처리
- key와 value에 null값을 허용하지 않는다.
HashTable
- single lock
- 모든 메서드에 대해 동기 처리
- key와 value에 null값을 허용하지 않는다.

java Set 인터페이스 구현체의 종류

HashSet
- 저장 순서를 유지하지 않는 데이터의 집합이다.
- 해시 알고리즘(hash algorithm)을 사용하여 검색 속도가 매우 빠르다.
- 내부적으로 HashMap 인스턴스를 이용하여 요소를 저장한다.
LinkedHashSet
- 저장 순서를 유지하는 HashSet
TreeSet
- 데이터가 정렬된 상태로 저장되는 이진 탐색 트리(binary search tree)의 형태로 요소를 저장한다.
- 이진 탐색 트리 중에 성능을 향상시킨 레드-블랙 트리(Red-Black tree)로 구현되어 있다.
- Compartor 구현으로 정렬 방법을 지정할 수 있다.

java List 인터페이스 구현체의 종류

ArrayList
- 단방향 포인터 구조로 각 데이터에 대한 인덱스를 가지고 있어 데이터 검색에 적합하다.
- 데이터의 삽입, 삭제 시 해당 데이터 이후 모든 데이터가 복사되므로 삽입, 삭제가 빈번한 데이터에는 부적합하다.
LinkedList
- 양방향 포인터 구조로 데이터의 삽입, 삭제 시 해당 노드의 주소지만 바꾸면 되므로 삽입, 삭제가 빈번한 데이터에 적합하다.
- 데이터의 검색 시 처음부터 노드를 순회하므로 검색에는 부적합하다.
- 스택, 큐, 양방향 큐 등을 만들기 위한 용도로 쓰인다.
Vector
- 내부에서 자동으로 동기화 처리가 일어난다.
- 성능이 좋지 않고 무거워 잘 쓰이지 않는다.

String StringBuilder StringBuffer

String
- 새로운 값을 할당할 때마다 새로 클래스에 대한 객체가 생성된다.
- String에서 저장되는 문자열은 private final char[]의 형태이기 때문에 String 값은 바꿀수 없다.
  - private: 외부에서 접근 불가
  - final: 초기값 변경 불가
- String + String + String...
  - 각각의 String 주솟값이 Stack에 쌓이고, Garbage Collector가 호출되기 전까지 생성된 String 객체들은 Heap에 쌓이기 때문에 메모리 관리에 치명적이다.
- String을 직접 더하는 것보다는 StringBuffer나 StringBuilder를 사용하는 것이 좋다.
StringBuilder, StringBuffer
- memory에 append하는 방식으로, 클래스에 대한 객체를 직접 생성하지 않는다.
- StringBuilder
  - 변경가능한 문자열
  - 비동기 처리
- StringBuffer
  - 변경가능한 문자열
  - 동기 처리
  - multiple thread 환경에서 안전한 클래스(thread safe)
Java 버전별 String Class 변경 사항
- JDK 1.5 버전 이전에서는 문자열 연산(+, concat)을 할 때 조합된 문자열을 새로운 메모리에 할당하여 참조해 성능상의 이슈 존재
- JDK 1.5 버전 이후에는 컴파일 단계에서 String 객체를 StringBuilder로 컴파일 되도록 변경됨
- 그래서 JDK 1.5 이후 버전에서는 String 클래스를 사용해도 StringBuilder와 성능 차이가 없어짐
- 하지만 반복 루프를 사용해서 문자열을 더할 때에는 객체를 계속 새로운 메모리에 할당함
- String 클래스를 사용하는 것 보다는 스레드와 관련이 있으면 StringBuffer, 스레드 안전 여부와 상관이 없으면 StringBuilder를 사용하는 것을 권장

https://12bme.tistory.com/42

java에서 ==와 equals()의 차이

"=="
- 항등 연산자(Operator) 이다.
  - <--> !=
- 참조 비교(Reference Comparison) ; (주소 비교, Address Comparison)
  - 두 객체가 같은 메모리 공간을 가리키는지 확인한다.
- 반환 형태: boolean type
  - 같은 주소면 return true, 다른 주소면 return false
- 모든 기본 유형(Primitive Types)에 대해 적용할 수 있다.
  - byte, short, char, int, float, double, boolean
"equals()"
- 객체 비교 메서드(Method) 이다.
- <--> !(s1.equals(s2));
- 내용 비교(Content Comparison)
  - 두 객체의 값이 같은지 확인한다.
  - 즉, 문자열의 데이터/내용을 기반으로 비교한다.
- 기본 유형(Primitive Types)에 대해서는 적용할 수 없다.
- 반환 형태: boolean type
  - 같은 내용이면 return true, 다른 내용이면 return false
"==" VS "equals()" 예시

public class Test {
    public static void main(String[] args) {
        // Thread 객체
        Thread t1 = new Thread();
        Thread t2 = new Thread(); // 새로운 객체 생성. 즉, s1과 다른 객체.
        Thread t3 = t1; // 같은 대상을 가리킨다.
        // String 객체
        String s1 = new String("WORLD");
        String s2 = new String("WORLD");
        /* --print-- */
        System.out.println(t1 == t3); // true
        System.out.println(t1 == t2); // false(서로 다른 객체이므로 별도의 주소를 갖는다.)
        System.out.println(t1.equals(t2)); // false
        System.out.println(s1.equals(s2)); // true(모두 "WORLD"라는 동일한 내용을 갖는다.)
    }
}

https://gmlwjd9405.github.io/2018/10/06/java-==-and-equals.html

java의 리플렉션 이란

리플렉션(Reflection) 이란?
- 자바에서 이미 로딩이 완료된 클래스에서 또 다른 클래스를 동적으로 로딩(Dynamic Loading)하여 생성자(Constructor), 멤버 필드(Member Variables) 그리고 멤버 메서드(Member Method) 등을 사용할 수 있는 기법이다.
- 클래스의 패키지 정보, 접근 지정자, 수퍼 클래스, 어노테이션(Annotation) 등을 얻을 수 있다.
- 컴파일 시간(Compile Time)이 아니라 실행 시간(Run Time)에 동적으로 특정 클래스의 정보를 객체화를 통해 분석 및 추출해낼 수 있는 프로그래밍 기법이다.
사용 방법
- Class.forName("클래스이름")
- 클래스의 이름으로부터 인스턴스를 생성할 수 있고, 이를 이용하여 클래스의 정보를 가져올 수 있다.

public class DoHee {
    public String name;
    public int number;
    public void setDoHee (String name, int number) {
      this.name = name;
      this.number = number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public void sayHello(String name) {
      System.out.println("Hello, " + name);
  }
}

import java.lang.reflect.Method;
import java.lang.reflect.Field;

public class ReflectionTest {
    public void reflectionTest() {
        try {
            Class myClass = Class.forName("DoHee");
            Method[] methods = myClass.getDeclaredMethods();

            /* 클래스 내 선언된 메서드의 목록 출력 */
            /* 출력 : public void DoHee.setDoHee(java.lang.String,int)
                     public void DoHee.setNumber(int)
                     public void DoHee.sayHello(java.lang.String) */
            for (Method method : methods) {
                System.out.println(method.toString());
            }

            /* 메서드의 매개변수와 반환 타입 확인 */
            /* 출력 : Class Name : class DoHee
                     Method Name : setDoHee
                     Return Type : void */
            Method method = methods[0];
            System.out.println("Class Name : " + method.getDeclaringClass());
            System.out.println("Method Name : " + method.getName());
            System.out.println("Return Type : " + method.getReturnType());

            /* 출력 : Param Type : class java.lang.String
                     Param Type : int */
            Class[] paramTypes = method.getParameterTypes();
            for(Class paramType : paramTypes) {
                System.out.println("Param Type : " + paramType);
            }

            /* 메서드 이름으로 호출 */
            Method sayHelloMethod = myClass.getMethod("sayHello", String.class);
            sayHelloMethod.invoke(myClass.newInstance(), new String("DoHee")); // 출력 : Hello, DoHee

            /* 다른 클래스의 멤버 필드의 값 수정 */
            Field field = myClass.getField("number");
            DoHee obj = (DoHee) myClass.newInstance();
            obj.setNumber(5);
            System.out.println("Before Number : " + field.get(obj)); // 출력 : Before Number : 5
            field.set(obj, 10);
            System.out.println("After Number : " + field.get(obj)); // 출력 : After Number : 10
        } catch (Exception e) {
            // Exception Handling
        }
    }

    public static void main(String[] args) {
        new ReflectionTest().reflectionTest();
    }
}

왜 사용할까?
- 실행 시간에 다른 클래스를 동적으로 로딩하여 접근할 때
- 클래스와 멤버 필드 그리고 메서드 등에 관한 정보를 얻어야할 때
- 리플렉션 없이도 완성도 높은 코드를 구현할 수 있지만 사용한다면 조금 더 유연한 코드를 만들 수 있다.
주의할 점
- 외부에 공개되지 않는 private 멤버도 Field.setAccessible() 메서드를 true로 지정하면 접근과 조작이 가능하기 때문에 주의해야 한다.

https://madplay.github.io/post/java-reflection

참고 : github.com/WeareSoft/tech-interview/blob/master/contents/java.md#java-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D%EC%9D%B4%EB%9E%80

--------------------------------------------------------------------

* 업데이트 해야함

동기화와 비동기화의 차이

객체란 무엇인가? (Object란?)

Java의 가비지 컬렉션 처리 방법

객체지향(Object-Oriented)이란?

Wrapper Class