[Kotlin] Coroutine (1)

티스토리 뷰

Android/Kotlin

[Kotlin] Coroutine (1)

혀가 길지 않은 개발자 2020. 7. 23. 17:13

build.gradle (Module: app)

dependencies {
    // Coroutine
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7'
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-androidx:1.3.4'
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        GlobalScope.launch {        // launch a new coroutine in background and continue
            delay(1000)     // non-blocking delay for 1 second (default time unit is ms)
            Log.e("result : ", "World!")
        }
        Log.e("result : ","Hello,") // main thread continues while coroutine is delayed
        Thread.sleep(2000)      // block main thread for 2 seconds to keep JVM alive
    }

}

delay is a special suspending function that does not block a thread, but suspends the coroutine, and it can be only used from a coroutine.

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        GlobalScope.launch {    // launch a new coroutine in background and continue
            delay(1000)
            Log.e("result : ", "World!")
        }
        Log.e("result : ", "Hello,")    // main thread continues here immediately
        runBlocking {           // but this expression blocks the main thread
            delay(2000) // ... while we delay for 2 seconds to keep JVM alive
        }

    }

}

The result is the same, but this code uses only non-blocking delay. The main thread invoking runBlockingblocks until the coroutine inside runBlocking completes.

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            GlobalScope.launch {        // launch a new coroutine in background and continue
                delay(1000)
                Log.e("result : ", "World!")
            }
            Log.e("result : ", "Hello,")    // main coroutine continues here immediately
            delay(2000)     // delaying for 2 seconds to keep JVM alive
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val job = GlobalScope.launch { 
                // launch a new coroutine and keep a reference to its Job
                delay(1000)
                Log.e("result : ", "World!")
            }
            Log.e("result : ", "Hello,")
            job.join()      // wait until child coroutine completes
        }

    }
}

The result is still the same, but the code of the main coroutine is not tied to the duration of the background job in any way. Much better.

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {               // this: CoroutineScope
            launch {                // launch a new coroutine in the scope of runBlocking
                delay(1000)
                Log.e("result : ", "World!")
            }
            Log.e("result : ", "Hello,")
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.GlobalScope
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {              
            GlobalScope.launch {
                delay(1000)
                Log.e("result : ", "World!")
            }
            Log.e("result : ", "Hello,")
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {   // this: CoroutineScope
            launch {
                delay(200)
                Log.e("result : ", "Task from runBlocking")
            }

            coroutineScope {    // Creates a coroutine scope
                launch {
                    delay(500)
                    Log.e("result : ", "Task from nested launch")
                }

                delay(100)
                // This line will be printed before the nested launch
                Log.e("result : ", "Task from coroutine scope")
            }

            // This line is not printed until the nested launch completes
            Log.e("result : ", "Coroutine scope is over")
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {   // this: CoroutineScope
            launch {
                doWorld()
            }
            Log.e("result : ", "Hello,")
        }

    }

    // this is your first suspending function
    suspend fun doWorld() {
        delay(1000)
        Log.e("result : ", "World!")
    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {   // this: CoroutineScope
            var i = 0
            repeat(1000) {   // launch a lot of coroutines
                launch {
                    delay(5000)
                    Log.e("result : ", "${i++}")
                }
            }
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {   // this: CoroutineScope
            var i = 0
            repeat(1000) {   // launch a lot of coroutines
                GlobalScope.launch {
                    delay(5000)
                    Log.e("result : ", "${i++}")
                }
            }
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {  
            GlobalScope.launch {
                repeat(10) {
                    Log.e("result : ", "I'm sleeping $it ...")
                    delay(500)
                }
            }
            delay(1300)	// just quit after delay
        }

    }
}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val job = launch {
                repeat(1000) {
                    Log.e("job: ", "I'm sleeping $it ...")
                    delay(500)
                }
            }
            delay(1300)
            Log.e("main: ", "I'm tired of waiting!")
            job.cancel()
            job.join()
            Log.e("main : ", "Now I can quit.")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val job = launch(Dispatchers.Default) {
                var startTime = System.currentTimeMillis()
                var i = 0
                while (i < 5) {     // computation loop, just wastes CPU
                    // print a message twice a second
                    if (startTime < System.currentTimeMillis()) {
                        Log.e("job: ", "I'm sleeping ${i++} ...")
                        startTime += 500
                    }
                }
            }
            delay(1300)     // delay a bit
            Log.e("main: ", "I'm tired of waiting!")
            job.cancelAndJoin()     // cancels the job and waits for its completion
            Log.e("main: ", "main: Now I can quit.")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            var job = launch(Dispatchers.Default) {
                var startTime = System.currentTimeMillis()
                var i = 0
                while (isActive) {      // cancellable computation loop
                    // print a message twice a second
                    if (startTime < System.currentTimeMillis()) {
                        Log.e("job: ", "I'm sleeping ${i++} ...")
                        startTime += 500
                    }
                }
            }
            delay(1300)     // delay a bit
            Log.e("main: ", "I'm tired of waiting!")
            job.cancelAndJoin()     // cancels the job and waits for its completion
            Log.e("main: ", "Now I can quit.")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val job = launch {
                try {
                    repeat(1000) {
                        Log.e("job: ", "I'm sleeping $it ...")
                        delay(500)
                    }
                } finally {
                    Log.e("job: ", "I'm running finally")
                }
            }
            delay(1300)     // delay a bit
            Log.e("main: ", "I'm tired of waiting!")
            job.cancelAndJoin()     // cancels the job and waits for its completion
            Log.e("main: ", "Now I can quit.")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val job = launch {
                try {
                    repeat(1000) {
                        Log.e("job: ", "I'm sleeping $it ...")
                        delay(500)
                    }
                } finally {
                    withContext(NonCancellable) {
                        Log.e("job: ", "I'm running finally")
                        delay(1000)
                        Log.e("job: ", "job: And I've just delayed for 1 sec because I'm non-cancellable")
                    }
                }
            }
            delay(1300)     // delay a bit
            Log.e("main: ", "I'm tired of waiting!")
            job.cancelAndJoin()     // cancels the job and waits for its completion
            Log.e("main: ", "Now I can quit.")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            withTimeout(1300) {
                repeat(1000) {
                    Log.e("result : ", "I'm sleeping $it ...")
                    delay(500)
                }
            }
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val result = withTimeoutOrNull(1300) {
                repeat(1000) {
                    Log.e("result : ", "I'm sleeping $it ...")
                    delay(500)
                }
                "Done"  // will get cancelled before it produces this result
            }
            Log.e("result : ", "Result is $result")
        }

    }

}

MainActivity.kt

package com.jwsoft.kotlinproject

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        runBlocking {
            val result = withTimeoutOrNull(1300) {
                repeat(2) {
                    Log.e("result : ", "I'm sleeping $it ...")
                    delay(500)
                }
                "Done"  // will get cancelled before it produces this result
            }
            Log.e("result : ", "Result is $result")
        }

    }

}

참고

kotlinlang.org/docs/reference/coroutines/coroutines-guide.html

Coroutines Guide - Kotlin Programming Language

kotlinlang.org

저작자표시

'Android > Kotlin' 카테고리의 다른 글

[Kotlin] Synchronized (0)	2020.07.27
[Kotlin] Generics (0)	2020.07.27
[Kotlin] MVVM (0)	2020.07.21
[Kotlin] RecyclerView + ItemClickListener + ItemLongClickListener (0)	2020.07.21
[Kotlin] AlertDialog (0)	2020.07.21

공지사항

최근에 올라온 글

최근에 달린 댓글

Total

Today

Yesterday

링크

TAG more

« 2025/04 »
일	월	화	수	목	금	토
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30

글 보관함

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

혀가 길지 않은 개발자

티스토리 뷰

[Kotlin] Coroutine (1)

'Android > Kotlin' 카테고리의 다른 글

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역