[Kotlin] Sequence를 이용한 컬렉션 지연 계산, 항상 효율적일까?

👀 컬렉션 함수를 연쇄하는 경우 임시 컬렉션이 생성된다. 

map이다 filter같은 컬렉션 함수를 연쇄하면 매 단계마다 중간 계산 결과를 새로운 임시 컬렉션에 저장된다. 즉, 매 단계 마다 불필요한 컬렉션이 생성된다.

📌 동작 과정

val resultList = people.map(Person::name).filter { it.startsWith("A") }

1. 위 예제에서 map에 대한 결과를 저장하는 임시 컬렉션이 생성되고 
2. 그 임시 컬렉션에 대한 filter 실행 결과를 resultList로 저장한다.

👀 sequence를 사용하면 임시 컬렉션이 생성되지 않는다.

코틀린에서 제공하는 시퀀스를 사용하면 중간 임시 컬렉션을 사용하지 않고, 컬렉션 연산을 연쇄할 수 있다.

📌 동작 과정

people.asSequence().map(Person::name).filter { it.startsWith("A") }.toList()

1. 중간 연산 (map)의 처리는 연기된다. 
2. 최종 연산을 호출했을 때 연기됐던 모든 계산이 수행된다. 

결과를 얻을 필요가 생기면(최종 연산 호출), 그 때 중간 연산을 적용한다. 

(java에서 Stream객체의 동작과 같다.)

📌사용 방법  

✅ asSequence

val resultListFromSequence =
    people.asSequence().map(Person::name).filter { it.startsWith("A") }.toList()

컬렉션에 대하여 asSequence를 호출하면 어떤 컬렉션이든 시퀀스로 바꿀 수 있다. 

✅ generateSequence

generageSquence는 일반 함수처럼 호출한다. 이전 원소를 인자로 받아 다음 원소를 계산한다.

val naturalNumbers = generateSequence(0) { it + 1 }
val numbersTo100 = naturalNumbers.takeWhile { it <= 100 }
println(naturalNumbers) // kotlin.sequences.GeneratorSequence@5034c75a
println(numbersTo100) // kotlin.sequences.TakeWhileSequence@396a51ab
println(numbersTo100.sum()) // 5050

중간에 generateSequence가 리턴한 객체를 출력해보면 알겠지만, 컬렉션이 아니라 sequence 자체를 반환한다.

즉, 결과 중간에는 컬렉션이 생성되지 않고, 최종 연산에 해당하는 sum을 호출했을 때 결과 컬렉션을 반환한다.

📌 sequence의 장점

1. 앞서 말했듯이 중간 결과를 저장할 임시 컬렉션을 생성하지 않는다. 
2. 원소에 연산을 차례대로 적용하다가 결과가 얻어지면 그 이후 원소에 대해서는 연산을 하지 않는다.

println(listOf(1, 2, 3, 4, 5, 6).map { it * it }.find { it > 10 })

위와 같은 계산이 있을 때, 우리가 기대하는 결과는 4이다. (find는 람다로 지정한 연산에 해당하는 첫번째 원소를 반환함)

✅ sequence를 사용하지 않을 때

일반적인 컬렉션 연산 연쇄 동작 과정

1. 전체 컬렉션 원소들에 대하여 map연산 실행
2. map연산 결과에 대하여 find실행 ( > 10 인 첫 번째 원소 찾기)

✅ sequence를 사용할 때

sequence를 사용할 때 동작 과정

1. 각 원소에 대하여 순차적으로 map 연산을 실행한 다음 -> find 연산을 실행한다. 
2. 4번째 원소가 원하는 결과이기 때문에 뒤 원소 5, 6에 대해서는 아무 연산도 실행하지 않는다. 

🤔 그럼 항상 sequence를 사용해야 하는 것 아닌가? 

이 질문에 대한 답은 NO!

📌 코틀린 람다의 주요한 특징 

코틀린에서 람다를 인자로 전달할 때 주의해야 하는 특징이 있다. 

void postponeComputation(int delay, Runnable computation)

예를 들어 위와 같은 자바 메소드가 있을 때, Runnable 타입은 Runnable을 구현한 무명 클래스의 인스턴스이고 이 부분에 람다를 전달할 수 있다. 

만약 저 부분을 람다가 아닌 object로 전달한다면 아래와 같이 사용할 수 있다.

postponeComputation(1000, object :Runnable{
    override fun run(){
        println(42)
    }
}

위와 같이 object로 Runnable을 전달하면 매번 postponeComputation 호출할 때마다 새로은 object가 생성된다! 

동일한 구현을 람다로 한다면

postponeComputation(1000) { println(42) }

매번 postponeComputation를 호출할 새로운 object를 생성하지 않는다. 즉, 아래와 같이 구현한 것과 동일한 의미이다. 매번 이미 생성된 runnable객체를 사용하는 것이다. (싱글톤으로 유지)

val runnable = Runnable { println(42) }
fun handleComputation() {
	postponeComputation(1000, runnable)
}

✅ 항상 그런 것은 아니다!

람다가 람다 외부의 변수를 사용한다면 매번 호출할 때마다 객체를 생성해야 한다. (object로 구현했을 때 처럼)

이렇게 람다에서 외부 변수를 사용하는 것을 '변수 캡쳐'라고 한다. 

fun handleComputation(id: String) { // 람다 안에서 id 변수 사용
	postponeComputation(1000) { println(id) } // 람다 호출 시 마다 매번 새로운 Runnable 인스턴스 생성 
}

✅ 인라이닝을 통해 변수 캡쳐시 부가비용 없애기

아래 처럼 inline키워드를 붙이면 호출할 때마다 객체를 생성하지 않고, 실행할 때 람다로 전달한 함수가 본문에 코드로 컴파일된다. 

즉 아래와 같이 코드를 작성하면 sum을 호출하는 부분에서 sum을 구현한 코드가 들어간다. 

inline fun sum(a: Int, b: Int) = a + b
fun main() {
    val a = 1
    val b = 2
    val result = sum(a, b)
}

작성한 코드

inline fun sum(a: Int, b: Int) = a + b
fun main() {
    val a = 1
    val b = 2
    val result = a + b
}

컴파일된 코드

📌 그래서 sequence랑은 무슨 상관인데?

돌고 돌아.. 다시 sequence! 

코틀린에서 컬렉션의 함수는 인라인 함수이다. 인라인 함수이기 때문에 호출했을 때 추가 객체나 클래스 생성은 없다.

컬렉션 일반 호출	시퀀스
컬렉션의 중간 결과 값을 저장하기 위한 임시 컬렉션을 만든다.	중간 임시 컬렉션을 만들지 않는다.
람다가 인라이닝 된다. → 호출 시 추가 객체나 클래스 생성은 없다	람다가 인라이닝 되지 않는다 → 호출 시 별도 객체 생성

그러니까 시퀀스를 사용하면 중간 임시 컬렉션은 만들지 않지만, 호출할 때마다 별도 객체를 생성한다는 소리다.

👀 그럼 sequence는 언제 쓸까?

위와 같은 이유로 성능을 향상시키기 위해 모든 컬렉션 연산에 asSequence를 붙여서는 안된다.

시퀀스 연산에서는 람다가 인라이닝되지 않기 때문에 크기가 작은 컬렉션은 오히려 일반 컬렉션 연산이 더 성능이 나을 수도 있다. 시퀀스를 통해 성능을 향상시킬 수 있는 경우는 컬렉션 크기가 큰 경우 뿐이다. 

 

출처 : Kotlin in action