Shuu’s archive

코틀린 코루틴 정석 2

킹숮 — Mon, 11 Aug 2025 13:17:00 +0900

섹션3. CoroutineDispatcher 완전 정복

1. Dispatchers.IO는 입출력 작업을 위한 CoroutineDispatcher이다.
2. Dispatchers.Default는 CPU 바운드 작업을 위한 CoroutineDispatcher이다.

3. Dispatchers.IO와 Dispatchers.Default는 코루틴 라이브러리의 공유 스레드풀을 사용한다.
4. Dispatchers.Default의 limitedParallelism 함수를 사용하면, Dispatchers.Default의 스레드 중 일부만을 사용하는 CoroutineDispatcher를 만들 수 있다.
5. Dispatchers.IO의 limitedParallelism 함수를 사용하면 공유 스레드풀의 별도 스레드를 사용하는 CoroutineDispatcher를 만들 수 있다.

6. Dispatchers.Main은 메인 스레드를 사용하기 위한 디스패처이다.
7. Dispatchers.Main.immediate는 코루틴을 요청하는 스레드가 메인 스레드일 경우 작업 대기열에 적재되지 않고 곧바로 메인 스레드에서 실행된다.

7. CoroutineContext의 구성요소

CoroutineContext의 구성요소

CoroutineContext 객체는 네 가지 주요한 구성요소를 가진다.

CoroutineName: 코루틴의 이름 설정에 사용되는 객체
복사편집

val coroutineName: CoroutineName = CoroutineName(name = "코루틴 이름 설정")
kotlin
CoroutineDispatcher: 코루틴을 스레드에 보내서 실행하는 객체
kotlin

복사편집

val dispatcher: CoroutineDispatcher = Dispatchers.IO
Job: 코루틴의 추상체로 코루틴을 조작하는데 사용되는 객체
kotlin

복사편집

val job: Job = Job()
CoroutineExceptionHandler: 코루틴에서 발생된 예외를 처리
kotlin

복사편집

val coroutineExceptionHandler: CoroutineExceptionHandler = CoroutineExceptionHandler { coroutineContext, throwable -> // 예외 처리 }

6. CoroutineContext

: CoroutineName, CoroutineDispatcher, Job, CoroutineExceptionHandler

코틀린 코루틴의 정석

킹숮 — Tue, 28 May 2024 01:09:29 +0900

개인 학습 및 기록용입니다. 책의 전반적인 내용보다는 제가 기억할만한 내용 위주로 정리되어 있습니다.

모든 내용의 출처는 '코틀린 코루틴의 정석' (조세영 지음) 입니다.

Chapter 1. 스레드 기반 작업의 한계와 코루틴의 등장

본격적으로 코루틴에 알아보기 전에 멀티스레드 프로그래밍이 어떻게 발전해왔고, 멀티스레드 프로그래밍의 단점을 코루틴이 어떻게 극복하였는지를 알아본다.

1.1 JVM 프로세스와 스레드

애플리케이션이 실행되면 JVM 은 프로세스를 시작하고 메인 스레드를 생성하며 main 함수 내부 코드를 모두 실행하면 애플리케이션은 종료된다.

fun main() {
	println("Hello world")
}

/* 결과 :
Hello world

Process finished with exit code 0
*/

0 : 프로세스가 정상적으로 종료

fun main() {
	println("Hello world")
    throw Exception("Dummy exception")
    println("main thread 종료")
}
/* 결과 :
Hello world
Exception in thread "main" java.lang.Exception : Dummy Exception
	at chapter1.code1.Code1_2Kt.main
    ..

Process finished with exit code 1
*/

1 : 프로세스가 비정상적으로 종료

JVM 의 프로세스는 기본적으로 Main 쓰레드를 단일 쓰레드로 실행되며 메인 스레드가 종료되면 종료된다.

단일 쓰레드 애플리케이션은 동시에 다른 작업을 수행하지 못하기 때문에 응답성에 문제를 가진다.

안드로이드 애플리케이션의 경우, 멈추거나 버벅이는 주요 이유가 될 수 있으며 서버사이드 작업의 경우도 처리 속도와 응답 속도에 문제가 생긴다.

1.2.2

멀티 스레드 프로그래밍을 통한 단일 스레드의 한계 극복

멀티 스레드 프로그래밍 기본 예시

fun main() {
	println("[${Thread.currentThread().name}] 메인 스레드 시작")
    ExampleThread().start()
    Thread.sleep(1000L)
    println("[${Thread.currentThread().name}] 메인 스레드 종료")
}

class ExampleThread: Thread() {
	override fun run() {
    	println("[${Thread.currentThread().name}] 새로운 스레드 시작")
        Thread.sleep(2000L)
    	println("[${Thread.currentThread().name}] 새로운 스레드 종료")
    }
}

/* 결과 :
[main] 메인 스레드 시작
[Thread-0] 새로운 스레드 시작
[main] 메인 스레드 종료
[Thread-0] 새로운 스레드 종료
*/

사용자 스레드와 데몬 스레드

- User thread : 우선도가 높은 스레드

- Demon thread : 우선도가 낮은 스레드

Single thread 를 사용하는 경우, 메인 스레드만 사용자 스레드이기 때문에 메인 스레드가 종료될 때 프로세스가 종료된다. 하지만 멀티 스레드를 사용하는 프로세스에서는 thread 중 사용자 스레드가 모두 종료되는 시점에 프로세스가 종료된다.

fun main() {
	println("[${Thread.currentThread().name}] 메인 스레드 시작")
    ExampleThread().apply {
    	isDaemon = true
    }.start()
    Thread.sleep(1000L)
    println("[${Thread.currentThread().name}] 메인 스레드 종료")
}
/* 결과 : 
[main] 메인 스레드 시작
[Thread-0] 새로운 스레드 시작
[main] 메인 스레드 종료

Process finished with exit code 0
*/

사용자 스레드인 main 스레드가 종료될 때 프로세스가 종료되어 Thread-0은 실행 중에 강제 종료된다.

데몬 스레드는 중요한 스레드가 아니기 때문에 강제 종료되더라도 프로세스가 정상 종료된다.

1.3.1.2. Thread 클래스를 직접 다루는 방법의 한계

1. Thread를 상속한 클래스를 인스턴스화해 실행할 때마다 새 Thread가 생성된다. (Thread의 생성 비용은 비싸다)

2. 프로그램이 크고 복잡해지면 Memory leak 등의 문제를 발생시킬 수 있다.

1.3.2 Executor 프레임웍을 통해 스레드풀 사용하기

Executor 프레임웍을 사용하여 개발자가 스레드를 직접 관리하는 문제를 해결하고 생성된 Thread 를 재사용 할 수 있다.

Executor 프레임웍을 이용한 스레드풀 예시

fun main() {
	val startTime = System.currentTimeMillis()
    val executorService: ExecutorService = Executors.newFixedThreadPool(2)
    
    executorService.submit {
    	println("[${Thread.currentThread().name}][${getElapsedTime(startTime)}] 작업 1 시작")
        Thread.sleep(1000L)
        println("[${Thread.currentThread().name}][${getElapsedTime(startTime)}] 작업 1 완료")
    }
    
	executorService.submit {
    	println("[${Thread.currentThread().name}][${getElapsedTime(startTime)}] 작업 2 시작")
        Thread.sleep(1000L)
        println("[${Thread.currentThread().name}][${getElapsedTime(startTime)}] 작업 2 완료")
    }
    
    fun getElapsedTime(startTime: Long): Seting =
    "지난 시간 : ${System.currentTimeMillis() - startTime}ms"
}

/* 결과 : 서로 다른 스레드에서 실행되기 때문에, 출력 순서, 사용 스레드는 다를 수 있다.
[pool-1-thread-1][지난 시간 : 4ms] 작업1 시작
[pool-1-thread-2][지난 시간 : 4ms] 작업2 시작
[pool-1-thread-1][지난 시간 : 1009ms] 작업1 완료
[pool-1-thread-2][지난 시간 : 1009ms] 작업2 완료
*/

1.3.2.3 Executor 프레임웍의 의의와 한계

이렇게 알아서 Thread를 관래해주는 Executor 프레임웍 또한 한계점을 가지고 있다.

이는 바로, 스레드 블로킹 Thread Blocking (스레드가 아무것도 하지 못하고 멈춰있는 상태)로 여러 Thread가 synchronized 블록에 동시에 접근하는 경우, Mutex나 Semaphore로 인해 공유되는 자원에 접근할 수 있는 스레드가 제한 되는 경우 발생할 수 있다.

ex. Future 객체는 미래에 언제 올지 모르는 값을 기다리는 함수인 get 함수를 갖고 있고, get gㅏㅁ수를 호출하면 get 함수를 호출한 스레드가 결과값이 반환될 때까지 블로킹 된다.

1.3.3 이후의 멀티 스레드 프로그래밍과 한계

Java 1.8에서는 기존 Future 객체의 단점을 보완하기 위해 CompletableFuture를 개발하기도 하고, 리액티브 프로그래밍 패러다임을 제공하는 RxJava가 등장해 결과값을 데이터 스트림으로 처리하여 스레드 블로킹을 방지하고 작업이 실행되는 스레드풀을 손쉽게 전환할 수 있게 만들기도 했다.

그러나 여전히 멀티스레드 프로그래밍은 스레드 기반이라는 한계점을 가지고 있다.

스레드는 생성 비용과 작업을 전환하는 비용이 비싸다.

1.4.2. 코루틴은 스레드 블로킹 문제를 어떻게 극복하는가

코루틴은 작업 단위 코루틴을 통해 스레드 블로킹 문제를 해결한다.

작업 단위 코루틴은 스레드에서 작업 실행 도중 일시 중단할 수 있는 작업 단위이다. 코루틴은 작업이 일시 중단되면 더 이상 스레드 사용이 필요하지 않으므로 스레드의 사용 권한을 양보하며, 양보된 스레드는 다른 작업을 실행하는 데 사용할 수 있고, 재개 시점에 새로 스레드를 할당하여 실행한다.( 새로 할당된 스레드는 다른 스레드일 수도 있고, 그 스레드가 될 수도 있다.)

Chapter2. 코루틴 개발 환경 설정

2.4.2. 실행중인 코루틴 이름 출력하기

Edit configurations... - Run/Debug configuration 창이 뜨면 VM options에 -Dkotlinx.coroutines.debug를 입력후 OK

fun main() {
	println("[${Thread.currentThread().name}] 실행")
}
/* 결과 : 
[main @coroutine#1] 실행
*/

2.4.4 CoroutineName 사용해 코루틴에 이름 추가하기

fun main() = runBlocking<Unit>(CoroutineName("main")) {
	println("[${Thread.currentThread().name}] 실행")
	launch(CoroutineName("Co1")) {
    	println("[${Thread.currentThread().name}] 실행")
    }
    launch(CoroutineName("Co2")) {
    	println("[${Thread.currentThread().name}] 실행")
    }
}
/* 결과 : 
[main @Main#1] 실행
[main @Co1#2] 실행
[main @Co2#2] 실행
*/

Chapter 3. CoroutineDispatcher

Coroutine Dispatcher 의 동작 방식은 책 참고

3.2 제한된 디스패처 vs. 무제한 디스패처

무제한 디스패처는 사용할 수 있는 스레드나 스레드 풀이 제한되지 않는다.

보통 제한된 디스패처를 사용한다.

3.3 제한된 디스패처 생성하기

3.3.1 단일 스레드 디스패처

val dispatcher: CoroutineDispatcher = newSingleThreadContext(name = "SingleThread")

3.3.2 멀티 스레드 디스패처

val multiThreadDispatcher : CoroutineDispatcher = newFixedThreadPoolContext(
	nThread = 2,
    name = "MultiThread"
)

각 thread의 이름은 MultiThread-1, MultiThread-2가 된다.

3.4.1. CoroutineDispatcher를 통해 코루틴 실행하기

fun main() = runBlocking<Unit> {
	val multiThreadDispatcher = newFixedThreadPoolContext(
    	nThread = 2,
        name = "MultiThread"
    )
    launch(context = multiThreadDispatcher) {
    	println("[${Thread.currentThread().name}] 실행")
    }
    launch(context = multiThreadDispatcher) {
    	println("[${Thread.currentThread().name}] 실행")
    }
}

3.4.2 부모 코루틴의 CoroutineDispatcher를 사용해 자식 코루틴 실행

fun main() = runBlocking<Unit> {
	val multiThreadDispatcher = newFixedThreadPoolContext(
    	nThread = 2,
        name = "MultiThread"
    )
    launch(context = multiThreadDispatcher) {
    	println("[${Thread.currentThread().name}] 부모 코루틴 실행")
        launch(context = multiThreadDispatcher) {
    		println("[${Thread.currentThread().name}] 자식 코루틴 실행")
  	  	}
        launch(context = multiThreadDispatcher) {
    		println("[${Thread.currentThread().name}] 자식 코루틴 실행")
  	  	}
    }
}

/* 결과 :
[MultiThread-1 @coroutine#2] 부모 코루틴 실행
[MultiThread-2 @coroutine#3] 자식 코루틴 실행
[MultiThread-1 @coroutine#4] 자식 코루틴 실행
*/

코루틴이 어떤 쓰레드에서 실행될지는 실행시마다 달라질 수 있다.

3.5 미리 정의된 CoroutineDispatcher

newFixedThreadPoolContext()를 사용하여 CoroutineDispatcher 객체를 생성하는건 비효율적일 수 있다.

이를 직접 생성하는 대신 우리는 미리 정의된 CoroutineDispatcher를 사용한다.

- Dispatcher.IO : 네트워크 요청이나 파일 입출력 등의 입출력(I/O) 작업을 위한 CoroutineDispatcher

- Dispatcher.Default: CPU를 많이 사용하는 연산 작업을 위한 CoroutineDispatcher

- Dispatcher.Main : 메인 스레드를 사용하기 위한 CoroutineDispatcher

3.5.1 Dispatcher.IO

네트워크 통신을 위한 HTTP 요청, DB 작업 등

fun main() = runBlocking<Unit> {
	launch(Dispatcher.IO) {
    	println("[${Thread.currentThread().name}] 코루틴 실행")
    }
}

/* 결과 실행 :
[DefaultDispatcher-worker-1 @coroutine#2] 코루틴 실행
*/

DefaultDispatcher-worker- ㅇㅇㅇ

: Dispatcher.IO 사용 시 공유 Thread pool 에 속한 스레드를 사용한다.

3.5.2 Dispatcher.Default

대용량 데이터 처리처럼 CPU 연산이 필요한 작업을 CPU 바운드 작업이라고 한다.

Dispatcher.Default는 CPU 바운드 작업에 사용한다.

fun main() = runBlocking<Unit> {
	launch(Dispatcher.Default) {
    	println("[${Thread.currentThread().name}] 코루틴 실행")
    }
}

/*
[DefaultDispatcher-worker-1 @coroutine#2] 코루틴 실행
*/

입출력 작업 vs. CPU 바운드 작업

입출력 작업과 CPU 바운드 작업의 중요한 차이는 작업이 실행됐을 때 스레드를 지속적으로 사용하는지 여부이다.

일반적으로 I/O 작업은 작을 실행 후 결과를 받을 때까지 스레드를 사용하지 않고, CPU 바운드 작업은 작업을 하는 동안 지속적으로 스레드를 사용한다.

그렇기 때문에 I/O 작업에 코루틴 사용하면 훨씬 효율적으로 작업을 처리할 수 있고,

CPU 바운드 작업은 스레드나 코루틴을 사용할 때나 비슷하다.

3.5.3 limitedParallelism 사용해 Dispatcher.Default 스레드 사용 제한하기

Dispatcher.Default를 사용해 무거운 연산을 처리하다 특정 연산을 위해 Dispatcher.Default의 모든 스레드가 사용될 수 있다. 이를 방지하기 위해 limitedParallelism() 을 사용하여 Dispatcher.Default의 스레드 중 일부만 사용할 수 있다.

fun main = runBlocking<Unit> {
	launch(Dispathtcher.Default.limitedParallelism(2)) {
    	repeat(10) {
        	println("[${Thread.currentThread().name}] 코루틴 실행")
        }
    }
}

/* 결과 :
[DefaultDispatcher-worker-2 @coroutine#3] 코루틴 실행
[DefaultDispatcher-worker-1 @coroutine#4] 코루틴 실행
[DefaultDispatcher-worker-2 @coroutine#5] 코루틴 실행
...
[DefaultDispatcher-worker-2 @coroutine#11] 코루틴 실행
[DefaultDispatcher-worker-2 @coroutine#12] 코루틴 실행
*/

Dispatcher.IO의 limitedParallellism은 완전히 다른 동작을 한다.

공유 스레드 풀 상에서 Dispatcher.IO 나 Dispatcher.Default 와 관계없는 스레드로 구성된 새 스레드풀을 만들며 개수의 제한도 없다.

특정 작업이 다른 작업에 영향을 받지 않아야 할 때 사용할 수 있으나 새 스레드를 만드는건 비싼 작업이므로 남용해서는 안된다.

3.5.5 Dispatcher.Main

UI 가 있는 앱에서 메인 스레드의 사용을 위한 사용한다.

기본 Kotlin 이 아닌 별도 라이브러리를 추가해야 사용 가능하다.

[Kotlin] Coroutine 코루틴

킹숮 — Tue, 26 Mar 2024 12:59:49 +0900

Kotlin Flow, Live date 를 보다가 문득 깨달은 것.. "나는 아직 Coroutine 도 잘 모르는구나..!"

기초부터 다시 차근차근 쌓아보자

본 포스팅은 개인 학습용 정리 자료입니다.

참고한 내용에 대해서 각 내용 상단에 출처를 기입 하였습니다.

Coroutines basics | Kotlin Documentation (kotlinlang.org)

Coroutines basics | Kotlin

kotlinlang.org

Coroutine 은 컨셉적으로 하나의 thread 랑 비슷하다.

그러나 Coroutine은 특정 thread 에 binding 되는게 아니라서 한 thread에서 실행을 suspend하고 다른 thread에서 실행될 수 있다.

fun main() = runBlocking { // this: CoroutineScope
    launch { // launch a new coroutine and continue
        delay(1000L) // non-blocking delay for 1 second (default time unit is ms)
        println("World!") // print after delay
    }
    println("Hello") // main coroutine continues while a previous one is delayed
}

Hello
World!

- launch : Coroutine builder.

- delay : 정지 함수. 일정 시간동안 정지하게 하며 정지하고 있는 동안 thread를 잡고 있지 않는다(다른 coroutine이 thread 사용 가능)

- runBlocking : runBlocking 또한 Coroutine builder 이며 CoroutineScope를 만든다.

structured concurrency

Coroutine 은 structed concurrency를 원칙으로 하기 때문에 CoroutineScope 안에서만 새 Coroutine을 실행할 수 있다.

만약 runBlocking {} 없이 launch를 호출 시 Coroutine scope이 아니기 때문에 아래처럼 에러가 발생한다

Unresolved reference: launch

suspending function

IDE 에서 "Extract function" 기능을 통해 함수 추출을 해보면 suspend 키워드가 붙은 함수가 생성된다.

정지함수는 Coroutine 안에서 일반 함수처럼 사용할 수 있고, delay 처럼 정지함수를 호출할 수 있다

Scope builder

runBlocking, coroutineScope와 같은 builder를 통해 coroutine scope를 만들 수 있고, 생성된 coroutine scope는 모든 child가 실행될 때까지 종료되지 않는다.

runBlocking 과 coroutineScope의 차이점은 runBlocking 은 현재 thread를 잡고 block 하고 있고, coroutineScope는 suspend 하고 다른 작업에 쓸 수 있도록 thread를 release한다. 그렇기 때문에 runBlocking 은 regular function, coroutineScope는 suspend function 이다.

An explicit job

launch coroutine builder는 Job을 리턴한다. job은 실행된 Coroutine 에 대한 handle 이며 명시적으로 작업이 끝날때까지 기다리게 코드를 짤 수 있다.

아래 코드를 실행시켜보면 job.join() 에서 child 코루틴이 완료될때까지 기다렸다가 Done을 찍는 걸 확인 할 수 있다.

val job = launch { // launch a new coroutine and keep a reference to its Job
    delay(1000L)
    println("World!")
}
println("Hello")
job.join() // wait until child coroutine completes
println("Done")

Hello
World!
Done

Coroutines are light-weight
아래 예시처럼 50000개의 Coroutine을 만들어도 적은 memory 를 소비한다.

import kotlinx.coroutines.*

fun main() = runBlocking {
    repeat(50_000) { // launch a lot of coroutines
        launch {
            delay(5000L)
            print(".")
        }
    }
}

같은 코드를 Thread로 만들면 매우 많은 memory consumption을 만든다.

Kotlin coroutines on Android | Android Developers

Android의 Kotlin 코루틴 | Android Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. Android의 Kotlin 코루틴 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 코루틴은 비동기적으로 실행되는

developer.android.com

Coroutine은 여러가지 언어에서 여러가지 작업을 동시에 처리하기 위한 사용하며 Kotlin에서는 Kotlin 1.3에 추가되었다.

Coroutine을 사용하면 오래 걸리는 작업이 main thread를 잡아 앱이 반응하지 않는 문제를 방지할 수 있다.

Noteworthy features 주목할만한 특징

- 경량

- 적은 Memory leak 발생

- Built-in cancellation support

- Jetpack 지원

Live data와 Mutable Live data

킹숮 — Tue, 26 Mar 2024 11:45:51 +0900

안녕하세요, 이 곳은 개인 학습을 위한 정리용 공간입니다.

각 내용 상단에 내용의 출처를 기입 해두었습니다.

[MVVM] MutableLiveData와 LiveData 차이 (tistory.com)

[MVVM] MutableLiveData와 LiveData 차이

MVVM으로 코드를 리팩토링하던 중 LiveData와 MutableLiveData라는 이름이 비슷한 두 클래스를 알게 됐다. 앞에 Mutable이 붙었을 뿐이고 사용법도 비슷하지만 둘의 차이를 알고 넘어가고 싶어서 이 포스

onlyfor-me-blog.tistory.com

LiveData를 다루기 전에 Observer pattern과 MVVM(Model-View-ViewModel)의 ViewModel이 뭔지부터 알아보자.

Observer pattern?

구독을 등록한 Subscriber들에게 변경이 있을때마다 Notify 해주는 구조

Observer (refactoring.guru)

Customer 가 상품 정보를 알기 위해서는 수시로 상점에 들러서 확인했어야 하는 번거로움이 있는데

Customer가 행사 정보를 구독해놓으면 updates가 있을 때마다 구독자들에게 정보를 받아볼 수 있게 개선 가능하다.

AS-IS.

TO-BE
observer pattern.

신문을 구독하는 것과 비슷한 Observer pattern.

ViewModel 이란?

ViewModel 개요 | Android 개발자 | Android Developers

ViewModel이란 무엇인가? ViewModel 초보를 위한 가이드 | by Charlezz | Medium

ViewModel이란 무엇인가? ViewModel 초보를 위한 가이드

ViewModel이란?

charlezz.medium.com

MVVM 패턴 관점에서 ViewModel는 View로 부터 독립적이며, View 가 필요로 하는 데이터를 가지고 있다.

MVVM 패턴을 적용하면 ViewModel이 Activity나 Fragment 와 같은 UI controller 의 역할을 분담하여 클래스가 방대해지는 것을 막을 수 있고 유지보수, 재사용성, 테스트에 유리하다는 장점이 있다.

Android Jetpack 에서 ViewModel 클래스를 제공한다. (AAC ViewModel. Android Architecture ViewModel)

* Android Jetpack Compose : 구글에서 발표한 개발자를 돕는 Library 모음

LiveData란?

LiveData는 Observe 가능한 Data holder이다.

Lifecycle와 관련이 있어 Activity, Fragment, Service 등 Lifecycle이 있는 앱 구성요소들이 LiveData에 Observer로 등록 가능하다.

LiveData 개요 | Android 개발자 | Android Developers

LiveData를 사용하여 수명 주기를 인식하는 방식으로 데이터를 처리합니다.

developer.android.com

- Live Data 의 장점

Ensures your UI matches your data state

LiveData는 observe pattern 을 따르고, Data의 변경이 있으면 Observer에게 알려주고 Observer 객체에서 UI를 업데이트 하여 항상 Data 와 UI sync 됨 (상태 일치 보장)

No memory leaks

Lifecycle이 종료되면 알아서 삭제된다.

No crashes due to stopped activities

stopped activities는 어떠한 LiveData event도 받지 않음. 이로 인한 비정상 종료도 없음

No more manual lifecycle handling

lifecycle 상태를 인지하고 알아서 관리된다.

Always up to date data

항상 최신 데이터

Proper configuration changes

Screen ratate 등 configuration 이 바뀌면 즉시 최신 Data를 수신한다.

Sharing resources

Singleton 패턴을 활용하여 데이터를 공유하도록 구현 가능하다

LiveData 사용해보기

LiveData는 일반적으로 ViewModel 객체 내에 저장한다.

class NameViewModel : ViewModel() {

    // Create a LiveData with a String
    val currentName: MutableLiveData<String> by lazy {
        MutableLiveData<String>()
    }

}

onCreate은 LiveData 의 observe를 시작하기에 적절한 시점이다.

(왜냐하면 onResume 에서 중복 호출 방지 + Actiivity나 Fragment가 활성화되는 즉시 표시할 데이터를 포함하기 위해)

class NameActivity : AppCompatActivity() {

    // Use the 'by viewModels()' Kotlin property delegate
    // from the activity-ktx artifact
    private val model: NameViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Other code to setup the activity...

        // Create the observer which updates the UI.
        val nameObserver = Observer<String> { newName ->
            // Update the UI, in this case, a TextView.
            nameTextView.text = newName
        }

        // Observe the LiveData, passing in this activity as the LifecycleOwner and the observer.
        model.currentName.observe(this, nameObserver)
    }
}

기본적으로 LiveData는 활성상태의 observer에만 업데이트를 보내지만, 예외적으로 비활성상태에서 활성상태로 변환될 때 Observer는 업데이트를 받는다.

비활성상태 > 활성상태 > 비활성상태 > 활성상태로 변경되면 마지막 활성상태 이후 변경된 경우에만 업데이트를 받는다.

드디어 이 글의 시작점이 된 LiveData와 Mutable LiveData의 차이점에 대해 알아보자.

LiveData vs. Mutable LiveData

android - Difference between LiveData, MutableLiveData - Stack Overflow

Difference between LiveData, MutableLiveData

I know that the MutableLiveData extends LiveData, but what is the difference between them (in usage). What are appropriate use cases, means when to use the correct one from the two?

stackoverflow.com

LiveData는 immutable 하지만(변하지않음) Mutable LiveData는 변경 가능하다.

Mutable LiveData는 LiveData 를 상속받으며 추가로 setValue(), postValue()같은 메서드를 제공한다.

https://developer.android.com/topic/libraries/architecture/livedata?hl=ko#update_livedata_objects

LiveData 개요 | Android 개발자 | Android Developers

LiveData를 사용하여 수명 주기를 인식하는 방식으로 데이터를 처리합니다.

developer.android.com

button.setOnClickListener {
    val anotherName = "John Doe"
    model.currentName.setValue(anotherName)
}

예제에서는 버튼을 클릭해서 name값을 변경하기 위해 Mutable LiveData를 사용했는데

DB load 완료, 네트워크 통신에 의한 data 업데이트 등 다양한 상황에서 사용된다.

Kotlin - Coroutine flow

킹숮 — Thu, 22 Feb 2024 16:22:49 +0900

반응형 프로그래밍

[RxJava] 반응형 프로그래밍 이해하기 — 조세영의 Kotlin World

[RxJava] 반응형 프로그래밍 이해하기

예제 링크: https://github.com/seyoungcho2/RxJavaExample 경로 : example/example1 명령형 프로그래밍과 반응형 프로그래밍 명령형 프로그래밍 명령형 프로그래밍은 컴퓨터에게 무엇을 하라고 명령하는 것이다.

kotlinworld.com

개인 공부를 위한 정리 문서입니다.

모든 내용의 출처는 아래 링크입니다. 좋은 내용 감사합니다.

출처 : [Coroutine Flow] 1. Flow란 무엇인가? — 조세영의 Kotlin World

[Coroutine Flow] 1. Flow란 무엇인가?

Coroutine의 Flow는 데이터 스트림이며, 코루틴 상에서 리액티브 프로그래밍 지원 하기 위한 구성요소이다. 이를 이해하기 위해서는 먼저 리액티브(반응형) 프로그래밍이 무엇인지, 그리고 Flow가 리

kotlinworld.com

리액티브 프로그래밍에는 데이터를 발행하는 발행자가 있고 발행자는 데이터의 소비자에게 지속적으로 데이터를 전달하는 역할을 한다. 우리는 이것을 데이터 스트림이라고 한다.

코루틴에서 데이터 스트림을 구현하기 위해서는 Flow를 사용해야 한다.

flow의 핵심 구성요소 3개

Producer생산자 / Intermediary중간 연산자 / Consumer소비자

Producer 생산자

flow{} 블록 내부에서의 emit()을 통해 데이터를 생성한다.

이때의 Data source 는 주로 서버의 데이터를 REST API를 통해 가져오거나, DB에서 가져온다.

class DustREmoteDataSource(
	private val dustApi:DustApi
) {
	fun getDustInfoFlow() : FLow<List<DustInfo>> = flow {
    	while(true) {
        	val dustInfos = dustApi.fetchLastedDustInfo()
            emit(dustInfos)
            delay(INTERVAL_REFRESH)
            // 60초 마다 반복해서 데이터를 생성
        }
    }
}

Imtermediary 중간 연산자

생성된 데이터를 수정한다.

Flow에서 지원하는 중간 연산자를 이용해 A객체를 B객체로 바꿀 수 있다.

map / filter / onEach 등의 중간 연산자가 있다.

class DustRepository(
	private val dustRemoteDataSource: DustRemoteDataSource,
) {
	fun getDustsInfoOfViewItem(locale: Locale) =
    	dustRemoteDataSource.getDustInfoFlow().map{ it.filter{ this.locale == locale }}
}

Consumer 소비자

Android 상에서 Consumer는 주로 UI 구성요소이다.

Flow에서 collect를 이용해 전달된 데이터를 소비할 수 있다.

class DustViewModel(
	private val dustRepository: DustRepository
) : ViewModel() {
	fun collectDustInfoOf(locale: Locale) =
    	viewModelScope.launch {
        	dustRepository.getDustInfoOf(locale).collect {
            	dustInfors -> /* ... */
            }
        }
}

코루틴 공식문서 번역 자료

Kotlin Coroutines 공식 문서 번역을 시작하며 · GitBook (seyoungcho2.github.io)

Kotlin Coroutines 공식 문서 번역을 시작하며 · GitBook

Kotlin Coroutines 공식 문서 번역을 시작하며 Kotlin Coroutines는 Kotlin을 위한 강력한 비동기 솔루션이다. 안드로이드 실무에서는 한동안 높은 점유율을 자랑한 RxJava를 Coroutines가 대체하고 있으며, 새로

seyoungcho2.github.io

[Coroutine Flow] 2. Flow와 StateFlow의 차이는 무엇인가? — 조세영의 Kotlin World

Flow는 데이터의 흐름이다. Flow는 데이터의 흐름을 발생시키지만 할 뿐 데이터를 저장하지 않는다.

화면이 재구성될 때마다 Data를 가져오는건 비효율 적이므로 collect 한 데이터를 ViewModel에 저장해놓고 사용한다.

((ViewModel은 onDestroy가 불리더라더도 살아있다)

ViewModel이 데이터를 저장하고 있으려면 별도의 데이터 홀더 변수를 만들어야 한다.

그리고 데이터 홀더 변수는 Reactive하지 않기 때문에 UI에서 해당 데이터 홀더 변수를 구독하기 위해 별도의 fetching 로직을 만들어야 한다.

이를 위해 ViewModel에서 데이터 홀더 변수와 flow를 같이 사용한다. 이 방법이 가장 정합하다.

하지만 둘 모두 보일러 플레이트 코드(비슷한 코드가 반복됨)를 만들어 낸다는 문제가 있다.

이러한 문제를 해결하기 위해 등장한 것이 바로 StateFlow이다.

StateFlow는 데이터 홀더(저장소) 역할과 Data stream 역할을 모두 한다.

UI단에서 StateFlow를 구독해 UIState를 업데이트하면 화면이 재구성될때마다 서버에 데이터를 요청할 필요가 없어진다.

[Coroutine Flow] 3. stateIn 사용하여 Flow를 StateFlow로 변환하기 — 조세영의 Kotlin World

[Coroutine Flow] 3. stateIn 사용하여 Flow를 StateFlow로 변환하기

Flow와 StateFlow 우리는 리액티브 프로그래밍을 할 때 여러 데이터 흐름(flow)를 하나로 합쳐 하나의 데이터 흐름(Flow)으로 만들어낸다. 예를 들어 아래의 그림3에서는 Flow가 3개 있고 이것이 합쳐져

kotlinworld.com

Flow를 UI에서 사용하기 위해 StateFlow로 변환해야한다. UI는 StateFlow를 구독하여 항상 최신 데이터를 발행받는다.

StateFlow가 항상 Flow를 구독하고 있다면 메모리누수가 생기므로 StateFlow가 살아있어야 하는 Coroutine scope를 명시할 수 있어야한다.

StateFlow는 Cold stream 이 아니라 Hot Stream이다. 마지막에 홀딩하고 있는 데이터를 구독하는 구독자에게 전달할 뿐, 구독자가 구독할 때 발행을 위한 로직을 trigger하지는 않는다.

Cold Stream vs Hot Stream 이란? (tistory.com)

Cold Stream vs Hot Stream 이란?

Coroutine Cold Stream vs Hot Stream 코루틴에서 Scope와 몇 가지 연산자 등의 학습을 거쳐 flow와 channel이라는 것을 학습하게 되었는데 이 2개의 정확한 차이점은 무엇일까? stream은 정확히 무엇인가?.. 둘 다

sjoongh.tistory.com

마지막으로 Cold Stream 은 Lazy Stream (게으른 스트림)이라고 말할 수 있다. 누군가가 구독할 때만 값의 방출이 시작되기 때문이다. 다시 말해서 누군가가 “내가 듣고 있으니까 방출해 줘”라고 말해줘야만 시작한다는 것이다.

stateIn 사용하여 Flow를 StateFlow로 변환하기

public fun <T> Flow<T>.stateIn(
	scope: CoroutineScope,
    started: SharingStarted,
    initialValue: T
): StateFlow<T> {
	val config = configureSharing(1)
    val state = MutableStateFlow(initialValue)
    val job = scope.launchSharing(config.context, config.upstream, state, started, initialValue)
    return ReadonlyStateFlow(state, job)
}

scope : StateFlow가 Flow로 부터 데이터를 구독받을 CoroutineScope을 명시한다.

started : Flow 로부터 언제부터 구독을 할지 명시할 수 있다.

initialValue : StateFlow에 저장될 초기

Sample

val stringFlow: Flow<String> = flow {
	for (i in 0..1000) {
    	emit("integer: $i")
        delay(1000)
    }
}

Groovy?

킹숮 — Wed, 3 Jan 2024 16:50:24 +0900

흔히 봐왔던 gradle 파일은 groovy 로 작성되어 있다.

현재는 gradle 파일을 groovy 또는 kotlin으로 작성할 수 있고 각 차이점, 장단점은 아래 링크에서 자세히 볼 수 있다.

Gradle, Groovy Gradle vs Kotlin Gradle

[Java] Gradle, Groovy Gradle, Kotlin Gradle — 일단은 내 이야기 (tistory.com)

[Java] Gradle, Groovy Gradle, Kotlin Gradle

서론 이번 Project 에서 코드는 java를 사용하고, 빌드툴은 Kotlin Gradle DSL 을 사용하기로 하였습니다. Gradle에 대해서도 한 번 정리하면 좋을 것 같아서 글을 적어봅니다. 본론 Gradle 이란? https:

kdhyo98.tistory.com

Groovy 기본 문법

BuildTool - Groovy란? (Groovy 문법과, 초간단 build.gradle 작성 예제) (tistory.com)

BuildTool - Groovy란? (Groovy 문법과, 초간단 build.gradle 작성 예제)

Gradle의 스크립트 파일 구조 Groovy란JVM에서 실행되는 스크립트 언어문법이 Java와 아주 가깝다Java와 호환이 되며 Java 클래스 파일을 그대로 Groovy 클래스로 사용할 수 있다 1. Gradle 설치https://galid1.ti

galid1.tistory.com

- 형 생략

def num = 1

- 메소드 호출 (인자 하나면 괄호 생략)

id('org.jetbrains.kotiln.android')

id 'org.jetbrains.kotiln.android'

groovy 에서 한칸 띄고 인자가 나오면 함수 호출이구나 생각해야함

- 클로저 Closure

The Apache Groovy programming language - Closures (groovy-lang.org)

The Apache Groovy programming language - Closures

This chapter covers Groovy Closures. A closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. A closure may reference variables declared in its surrounding scope. In opposition to the f

groovy-lang.org

Closure는 익명의 코드 블럭으로 아래처럼 쓸 수 있다

{ item++ }                                          
{ println it }                                                              
{ String x, int y ->                                
    println "hey ${x} the value is ${y}"
}

def closureExample = { println "hello!"}
closureExample()

Kotlin | action bar 에 메뉴 표시하기 (MenuItem.setShowAsAction)

킹숮 — Thu, 23 Nov 2023 16:50:04 +0900

MenuItem | Android Developers

showAsAction 속성

SHOW_AS_ACTION_ALWAYS / SHOW_AS_ACTION_IF_ROOM /SHOW_AS_ACTION_NEVER / SHOW_AS_ACTION_WITH_TEXT

이거 굉장히 매우 기본적인 내용인데 모르고 최근에 실수를 해서 아주 반성중이다...

Action bar에 메뉴를 추가하기 위해서는 아래 파일을 수정한다

(xml 을 이용한 방식, programmatically 구현도 가능)

first, second, third 3개의 메뉴를 추가

xml 파일에서는 item에 showAsAction 속성을 줄 수 있는데

이 속성에 따라 action bar에 표시될 수도 있고, 액션바 우측 ':' 버튼 안으로 들어갈 수도 있다.

always

항상 표시 (Action bar에 버튼)

never

':' 버튼 클릭 시 메뉴가 표시됨

ifRoom

action bar 에 공간이 있으면 버튼으로 표시, 충분하지 않으면 ':' 클릭시 메뉴가 표시됨

아래 코드 실행 시, 오른쪽 처럼 표시되는 것을 볼 수 있다.

First는 always라서 버튼으로 표시됨

Second 는 ifRoom 인데 공간이 있어 버튼으로 표시됨

Third는 ifRoom 인데 더이상 공간이 없어 ':' 하단에 위치함

Fourth 는 never 이기 때문에 항상 ':' 하단에 위치함

[React] 지도위에 custom marker 표시하기 (Google Map API)

킹숮 — Fri, 18 Aug 2023 16:57:25 +0900

링크에서 볼 수 있듯이 Google map API를 사용하여 다양한 방식으로 Custom marker를 만들 수 있습니다.

- 맞춤 그래픽 파일 사용
- 인라인 SVG 사용
- 그래픽 파일을 글리프로 사용
- 장소 아이콘 이미지를 글리프로 사용
- 아이콘 글꼴 사용

그래픽으로 마커 만들기 | Maps JavaScript API | Google for Developers

의견 보내기 그래픽으로 마커 만들기 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 이 제품 또는 기능은 미리보기(GA 이전) 버전입니다. GA 이전 제품과 기

developers.google.com

그 중 가장 간단하게 png 파일을 사용해서 marker를 표시하는 예제를 테스트 해보겠습니다.

맞춤 그래픽 파일 사용
그래픽 파일(예: PNG)을 참조하는 img 요소를 AdvancedMarkerView.content 옵션에 전달하여 맞춤 이미지를 사용하여 마커를 만들 수 있습니다.

지도에 marker를 표시하는 기본 예제에서 이어서 해보겠습니다. (https://helloshuu.tistory.com/9)

프로젝트 경로에 marker 로 쓸 store.png 파일을 추가해주었고

index.js에서 storeImg를 읽어와 marker에 content 로 설정해주면 완성

import StoreImage from './store.png'
let map;

async function initMap() {
  const position = { lat: 37.578, lng: 126.976 };

  const { Map } = await window.google.maps.importLibrary("maps");
  const { AdvancedMarkerView } = await window.google.maps.importLibrary("marker");


  const storeImg = document.createElement("img");
  storeImg.src = StoreImage;


  map = new Map(document.getElementById("map"), {
    zoom: 16,
    center: position,
    mapId: "DEMO_MAP_ID",
  });

  const marker = new AdvancedMarkerView({
    map: map,
    position: position,
    content: storeImg,
    title: "경복궁",
  });
}

initMap();

[React] 지도에 클릭 이벤트로 위경도 받기 (Google map api)

킹숮 — Fri, 18 Aug 2023 16:28:52 +0900

딱 내가 해보고 싶었던 예제가 Google developers에 있었고, 예제만 그대로 따라하였을 때 문제없이 구현 가능하였다.

Getting Lat/Lng from a Click Event

https://developers.google.com/maps/documentation/javascript/examples/event-click-latlng#maps_event_click_latlng-javascript

Google map 을 띄우고 지도를 클릭하면 marker가 옮겨가면서 클릭한 위치의 위경도를 표시해준다.

Getting Lat/Lng from a Click Event | Maps JavaScript API | Google for Developers

Send feedback Getting Lat/Lng from a Click Event Stay organized with collections Save and categorize content based on your preferences. This example listens for the click event, gets the latitude and longitude coordinates of the click from google.maps.MapM

developers.google.com

최종 코드

index.html

<html>
  <head>
    <title>Marker on map</title>
    <script src="https://polyfill.io/v3/polyfill.min.js?features=default"></script>

    <link rel="stylesheet" type="text/css" href="./style.css" />
    <script type="module" src="./index.js"></script>


</script>
  </head>
  <body>
    <div id="map" style="height: 400px; width: 500px"></div>

          <script
             src="https://maps.googleapis.com/maps/api/js?key=MY_API_KEY&callback=initMap&v=weekly"
             defer
           ></script>
  </body>
</html>

index.js

function initMap() {
  const myLatlng = { lat: 37.578, lng: 126.976 };
  const map = new window.google.maps.Map(document.getElementById("map"), {
    zoom: 10,
    center: myLatlng,
  });
  // Create the initial InfoWindow.
  let infoWindow = new window.google.maps.InfoWindow({
    content: "Click the map to get Lat/Lng!",
    position: myLatlng,
  });

  infoWindow.open(map);
  // Configure the click listener.
  map.addListener("click", (mapsMouseEvent) => {
    // Close the current InfoWindow.
    infoWindow.close();
    // Create a new InfoWindow.
    infoWindow = new window.google.maps.InfoWindow({
      position: mapsMouseEvent.latLng,
    });
    infoWindow.setContent(
      JSON.stringify(mapsMouseEvent.latLng.toJSON(), null, 2),
    );
    infoWindow.open(map);
  });
}

window.initMap = initMap;

Google map API로 받을 수 있는 다양한 이벤트들

이벤트 | Maps JavaScript API | Google for Developers

[React] Google Map API를 사용하여 지도위에 marker pin 표시하기

킹숮 — Fri, 18 Aug 2023 16:05:51 +0900

Google developer 에 나온 예제를 따라 지도에 marker를 표시해 보았다.

웹사이트에 마커가 포함된 Google 지도 추가 | Maps JavaScript API | Google for Developers

의견 보내기 웹사이트에 마커가 포함된 Google 지도 추가 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. 소개 이 튜토리얼에서는 마커가 포함된 간단한 Google

developers.google.com

#troubleshooting

ERROR
AdvancedMarkerView is not a constructor
TypeError: AdvancedMarkerView is not a constructor
at initMap (http://localhost:3000/static/js/bundle.js:37:18)

해결 :

이전 예제에서 map 을 init 하는 index.js 만 수정하고, index.html 수정하는 것을 놓침

index.html <body> 에 v: "beta"가 포함된 script 추가 (Advanced Marker는 beta에서만 사용가능)

https://developers.google.com/maps/documentation/javascript/reference/3.51/advanced-markers?hl=ko

Advanced Markers (beta) | Maps JavaScript API | Google for Developers

이 페이지는 Cloud Translation API를 통해 번역되었습니다. Switch to English 의견 보내기 Advanced Markers (beta) 컬렉션을 사용해 정리하기 내 환경설정을 기준으로 콘텐츠를 저장하고 분류하세요. google.maps.m

developers.google.com

최종 코드

index.html

<html>
  <head>
    <title>Add Map</title>
    <script src="https://polyfill.io/v3/polyfill.min.js?features=default"></script>

    <link rel="stylesheet" type="text/css" href="./style.css" />
    <script type="module" src="./index.js"></script>
  </head>
  <body>
    <!--The div element for the map -->
    <div id="map"  style="height: 400px; width: 500px"></div>

    <!-- prettier-ignore -->
    <script>(g=>{var h,a,k,p="The Google Maps JavaScript API",c="google",l="importLibrary",q="__ib__",m=document,b=window;b=b[c]||(b[c]={});var d=b.maps||(b.maps={}),r=new Set,e=new URLSearchParams,u=()=>h||(h=new Promise(async(f,n)=>{await (a=m.createElement("script"));e.set("libraries",[...r]+"");for(k in g)e.set(k.replace(/[A-Z]/g,t=>"_"+t[0].toLowerCase()),g[k]);e.set("callback",c+".maps."+q);a.src=`https://maps.${c}apis.com/maps/api/js?`+e;d[q]=f;a.onerror=()=>h=n(Error(p+" could not load."));a.nonce=m.querySelector("script[nonce]")?.nonce||"";m.head.append(a)}));d[l]?console.warn(p+" only loads once. Ignoring:",g):d[l]=(f,...n)=>r.add(f)&&u().then(()=>d[l](f,...n))})
        ({key: "MY_API_KEYYYYYY", v: "beta"});</script>
  </body>
</html>

index.js

let map;

async function initMap() {
  // The location of 경복궁
  const position = { lat: 37.578, lng: 126.976 };
  // Request needed libraries.
  //@ts-ignore
  const { Map } = await window.google.maps.importLibrary("maps");
  const { AdvancedMarkerView } = await window.google.maps.importLibrary("marker");

  // The map, centered at 경복궁
  map = new Map(document.getElementById("map"), {
    zoom: 16,
    center: position,
    mapId: "DEMO_MAP_ID",
  });

  // The marker, positioned at Uluru
  const marker = new AdvancedMarkerView({
    map: map,
    position: position,
    title: "경복궁",
  });
}

initMap();

아래와 같이 지도에 marker 를 표시하고 '경복궁' 이란 태그도 추가하는데 성공하였다.