RxJava, RxKotlin - timer

[출처 - RxJava 프로그래밍 : 리액티브 프로그래밍 기초부터 안드로이드 까지 한번에]

본 글은 'RxJava 프로그래밍 : 리액티브 프로그래밍 기초부터 안드로이드 까지 한번에' 를 학습하면서 정리한 글입니다

마블다이어그램 참고 - http://reactivex.io/RxJava/javadoc/io/reactivex/Flowable.html#timer-long-java.util.concurrent.TimeUnit-

 

timer는 interval 함수와 유사하지만 한번만 실행하는 함수입니다. 일정 시간 지난 후 한번만 발행하고 onComplete 이벤트를 발생시킵니다.

timer의 원본 code를 보면

@SchedulerSupport(SchedulerSupport.COMPUTATION)
public static Observable<Long> timer(long delay, TimeUnit unit) {
    return timer(delay, unit, Schedulers.computation());
}

interval 함수와 유사함을 확인 할 수 있습니다.

 

그럼 예제code를 확인 해보겠습니다.

JAVA

import io.reactivex.Observable;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class Timer_test{
    public static void main(String[] args){

        CommonUtils.exampleStart();
        Observable<String> source = Observable.timer(500L, TimeUnit.MILLISECONDS).map(it -> {
            return new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date());
        });

        source.subscribe(it-> {
            long time = System.currentTimeMillis() - CommonUtils.startTime;
            System.out.println(getThreadName() + " | " + time + " | " + "value = " + it);
        });
        CommonUtils.sleep(1000);

    }
    private static String getThreadName() {
        String threadName = Thread.currentThread().getName();
        if (threadName.length() > 30) {
            threadName = threadName.substring(0, 30) + "...";
        }
        return threadName;
    }
}

public class CommonUtils{
    public static long startTime;
    public static void exampleStart(){
        startTime = System.currentTimeMillis();
    }
    public static void sleep(int mills){
        try{
            Thread.sleep(mills);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}

Kotlin

import io.reactivex.Observable
import java.text.SimpleDateFormat
import java.util.*
import java.util.concurrent.TimeUnit

fun main(){
    CommonUtilsk.exampleStart()
    val source = Observable.timer(500L, TimeUnit.MILLISECONDS).map { it ->
        SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(
            Date()
        )
    }

    source.subscribe { it ->
        val time = System.currentTimeMillis() - CommonUtilsk.startTime
        println(getThreadName() + " | " + time + " | " + "value = " + it)
    }
    CommonUtilsk.sleep(1000)
    
}
fun getThreadName() : String{
    var threadName = Thread.currentThread().name
    if (threadName.length > 30) {
        threadName = threadName.substring(0, 30) + "..."
    }
    return threadName
}

internal object CommonUtilsk {
    var startTime: Long = 0
    fun exampleStart() {
        startTime = System.currentTimeMillis()
    }

    fun sleep(mills: Int) {
        try {
            Thread.sleep(mills.toLong())
        } catch (e: InterruptedException) {
            e.printStackTrace()
        }

    }
}

 실행 하면

RxComputationThreadPool-1 | 686 | value = 2019/11/20 18:03:08

이렇게 1개의 결과만 약 500millis 있다가 나타나는 것을 확인 할 수 있습니다.