ౙٳΈલʹ
,PUMJOͷ$PSPVUJOFTΛ
ٵҾ͍ͨ͠ਓ͕ू͏ձ !V[[V 

झࢫ w೥຤,PUMJOͰ੒Ռग़ͧ͢
w·ͩ$PSPVUJOFTΑ͘෼͔ͬͯͳ͍ͧ
w$PSPVUJOFTରԠਓࡐʹͳΔͧ 

ຊ୊ w ,PUMJOϕʔεͰ࿩͠·͢
w$PSPVUJOFTͱ͸
wଞݴޠʹ͓͚ΔBTZODBXBJUͱͷҧ͍
w࢖͍ํͬ͘͟Γ
wͱΓ͜ΕϦϯΫू 

$PSPVUJOFT w,PUMJO͔Βਖ਼ࣜϦϦʔε͞Εͨඇಉظϓϩάϥ ϛϯάͷҝͷػೳ ΋ͪΖΜNVMUJQMBUGPSNରԠ
wଞݴޠͰ͍͏ॴͷBTZODBXBJU౳ؚ͕·Ε͍ͯΔ
wଞݴޠͰ͍͏ॴͷDPSPVUJOF HFOFSBUPS ͸
 ,PUMJOͰ͸4FRVFODF5 

BTZODBXBJU
$ class Program { static async ValueTask DoSomething(int value) { await Task.Delay(1000); return value * value; } static async Task MainAsync(string[] args) { Console.WriteLine("Start task"); var result = await DoSomething(100); Console.WriteLine($"Result: {result}"); } static void Main(string[] args) => MainAsync(args).Wait(); } 

BTZODBXBJU
$ class Program { static async ValueTask DoSomething(int value) { await Task.Delay(1000); return value * value; } static async Task MainAsync(string[] args) { Console.WriteLine("Start task"); var result = await DoSomething(100); Console.WriteLine($"Result: {result}"); } static void Main(string[] args) => MainAsync(args).Wait(); } 

BTZODBXBJU
$ class Program { static async ValueTask DoSomething(int value) { await Task.Delay(1000); return value * value; } static async Task MainAsync(string[] args) { Console.WriteLine("Start task"); var result = await DoSomething(100); Console.WriteLine($"Result: {result}"); } static void Main(string[] args) => MainAsync(args).Wait(); } 

BTZODBXBJU
&4 function sleep(milliSeconds) { return new Promise(resolve => setTimeout(resolve, milliSeconds)); } async function doSomething(value) { await sleep(1000); return value * value; } (async() => { console.log("Start task."); const result = await doSomething(100); console.log(`Result: ${result}`) })(); 

BTZODBXBJU
&4 function sleep(milliSeconds) { return new Promise(resolve => setTimeout(resolve, milliSeconds)); } async function doSomething(value) { await sleep(1000); return value * value; } (async() => { console.log("Start task."); const result = await doSomething(100); console.log(`Result: ${result}`) })(); 

BTZODBXBJU
&4 function sleep(milliSeconds) { return new Promise(resolve => setTimeout(resolve, milliSeconds)); } async function doSomething(value) { await sleep(1000); return value * value; } (async() => { console.log("Start task."); const result = await doSomething(100); console.log(`Result: ${result}`) })(); 

BTZODBXBJU wBTZOD
GVODUJPOΛ࣮૷ͯ͠
 ݺͼग़͠ଆͰBXBJU͢Δ 

$PSPVUJOFT suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } 

$PSPVUJOFT suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } 

$PSPVUJOFT suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } 

$PSPVUJOFT wTVTQFOE
GVODUJPOΛ࣮૷ͯ͠
 ݺͼग़͠ଆ͸ͨͩݺͿ BXBJU
LFZXPSEͳ͠ 
 
BTZODBXBJUͳݴޠͰ͸ඇಉظͰ͋Δࣄ͕લఏ
 
,PUMJOͰ͸ඇಉظؔ਺Ͱ͸ͳ͘தஅؔ਺ͳͷͰ
 ɹ
ಉظzతzʹهड़Ͱ͖ΔΑ͏ʹͳ͍ͬͯΔ
 ɹ
ଞݴޠͷΑ͏ʹಉظඇಉظΛҙࣝ͢Δඞཁ͕ͳ͍ 

࢖͍ํ w%FQFOEFODJFTͷ௥Ճ
w$PSPVUJOF4DPQFΛ࣮૷͢Δ
w$PSPVUJOF4DPQFMBVODIͯ͠
 Α͠ͳʹTVTQFOE
GVODUJPOΛݺͼग़͢ 

%FQFOEFODJFTͷ௥Ճ w,PUMJOdΛೖΕΔ͚ͩͰ͸࣮࣭࢖͑ͳ͍
 ݴޠͱͯ͠͸௿ϨΠϠʔͳ࢓༷ͷΈಉ͍ࠝͯ͠Δҝ 
 wՃ͑ͯɺ1MBUGPSNʹ߹ΘͤͯϥΠϒϥϦΛ௥Ճ
 implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.0.1" implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1" 

$PSPVUJOF4DPQFΛ࣮૷͢Δ wTVTQFOE
GVODUJPO͸$PSPVUJOFͷத͋Δ͍͸ TVTQFOE
GVODUJPO͔ΒͷΈར༻Ͱ͖Δ
w$PSPVUJOF͸$PSPVUJOF4DPQFͷதͰͷΈ
 ىಈͰ͖Δ
w$PSPVUJOF4DPQFͷ࣮૷͕ඞཁ 

$PSPVUJOF4DPQFΛ࣮૷͢Δ suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } ݱࡏͷ࣮ߦεϨουΛݩʹ CoroutineScopeΛ࡞ͬͯ ࣮ߦ׬ྃ·Ͱ଴ͬͯΔ 

$PSPVUJOF4DPQFΛ࣮૷͢Δ w࣮૷ͷલʹগ͚ͩ͠ొ৔ਓ෺ͷ੔ཧ
 ਂೖΓ͢ΔͱऴΘΒͳ͍ͷͰগ͚ͩ͠ 

࣮૷͢Δ্Ͱ࠷௿ݶͷొ৔ਓ෺ w$PSPVUJOF$POUFYU

ϓϩύςΟͱͯ࣋ͭ͠ඞཁ͕͋Δ
w+PC

MBVODI͢Δ$PSPVUJOFͷϥΠϑαΠΫϧΛ؅ཧ
w$PSPVUJOF%JTQBUDIFS

࣮ߦίϯςΩετ 5ISFBE
FUD
wଞɺ$PSPVUJOF&YDFQUJPO)BOEMFS౳͍Δ
 ͕Ұ୴์ஔ 

$PSPVUJOF4DPQFΛ࣮૷͢Δ class SimpleCoroutineScope(ui: CoroutineDispatcher) : CoroutineScope { // ਌JobΛ࡞Δ(࡞Ε) private val job: Job = Job() // σϑΥϧτͷڍಈͱͯ͠
 // ਌Job͸jobϓϩύςΟͷ΍ͭ
 // ࣮ߦίϯςΩετ͸ίϯετϥΫλҾ਺uiΛ༻͍Δ override val coroutineContext: CoroutineContext = job + ui } 

$PSPVUJOF4DPQFΛ࣮૷͢Δ class SimpleCoroutineScope : CoroutineScope { // ਌JobΛ࡞Δ(࡞Ε) private val job: Job = Job() // σϑΥϧτͷڍಈͱͯ͠
 // ਌Job͸jobϓϩύςΟͷ΍ͭ
 // ࣮ߦίϯςΩετ͸mainϧʔϓΛ༻͍Δ override val coroutineContext: CoroutineContext = job + Dispatchers.Main } 

$PSPVUJOF4DPQFΛ࣮૷͢Δ class SimpleCoroutineScope : CoroutineScope { // ਌JobΛ࡞Δ(࡞Ε) private val job: Job = Job() // σϑΥϧτͷڍಈͱͯ͠
 // ਌Job͸jobϓϩύςΟͷ΍ͭ
 // ࣮ߦίϯςΩετ͸IO Pool(※Threadͱ͸ݶΒͳ͍)Λ༻͍Δ override val coroutineContext: CoroutineContext = job + Dispatchers.IO } 

$PSPVUJOF4DPQFMBVODI͢Δ w جຊతͳॴͱͯ͠ MBVODI͢Δͱ$PSPVUJOF͕ى ಈ͢Δ
 $PSPVUJOF͸࣮ࡍ͍ΖΜͳॴͰىಈ͍ͯ͠Δ͚Ͳলུ
wMBVODIͷલʹొ৔ਓ෺Λʜ 

ొ৔ਓ෺ w$PSPVUJOF4DPQF

͖ͬ͞࡞ͬͨ΍ͭ

w$PSPVUJOF$POUFYU

͖ͬ͞ϓϩύςΟʹ࣋ͨͤͨ΍ͭ
w$PSPVUJOF

MBVODI౳ʹΑͬͯ࡞ΒΕΔ࣮ࡍʹಈ͍ͯΔ΍ͭ

w+PC
ུ %JTQBUDIFS
FUDʜ

͖ͬ͞આ໌ͨ͠΍ͭ
wଞɺ$PSPVUJOF4UBSU౳͋Δ͕Ұ୴লུ 

$PSPVUJOF4DPQFMBVODI͢Δ class SimpleCoroutineScope : CoroutineScope { // ਌JobΛ࡞Δ(࡞Ε) private val job: Job = Job() // σϑΥϧτͷڍಈͱͯ͠
 // ਌Job͸jobϓϩύςΟͷ΍ͭ
 // ࣮ߦίϯςΩετ͸mainϧʔϓΛ༻͍Δ override val coroutineContext: CoroutineContext = job + Dispatchers.Main } 

$PSPVUJOF4DPQFMBVODI͢Δ class SimpleCoroutineScope : CoroutineScope { private val job: Job = Job() override val coroutineContext: CoroutineContext = job + Dispatchers.Main fun foo() { launch { // ਌Λjob // ࣮ߦίϯςΩετΛmainϧʔϓͱͯ͠ // CoroutineΛىಈ͠ॲཧΛ࣮ߦ͢Δ val result = doSomething() } } } 

$PSPVUJOF4DPQFMBVODI͢Δ class SimpleCoroutineScope : CoroutineScope { // ਌JobΛ࡞Δ(࡞Ε) private val job: Job = Job() // σϑΥϧτͷڍಈͱͯ͠
 // ਌Job͸jobϓϩύςΟͷ΍ͭ
 // ࣮ߦίϯςΩετ͸IO Pool(※Threadͱ͸ݶΒͳ͍)Λ༻͍Δ override val coroutineContext: CoroutineContext = job + Dispatchers.IO } 

$PSPVUJOF4DPQFMBVODI͢Δ class SimpleCoroutineScope : CoroutineScope { private val job: Job = Job() override val coroutineContext: CoroutineContext = job + Dispatchers.IO fun foo() { launch { // ਌Λjob // ࣮ߦίϯςΩετΛIO Poolͱͯ͠ // CoroutineΛىಈ͠ॲཧΛ࣮ߦ͢Δ val result = doSomething() } } } 

$PSPVUJOF4DPQFMBVODI͢Δ wิ଍ɿ͜Ε͸DPNQJMF
FSSPS
SFUVSOͰ͖ͳ͍ fun execute(): Int { launch { return doSomething() } } 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ suspend fun doSomething(value: Int): Int { delay(1000) return value * value } fun main() = runBlocking { println("Start task") val result = doSomething(100) println("Result: $result") } ͜Εsuspend function 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ function sleep(milliSeconds) { return new Promise(resolve => setTimeout(resolve, milliSeconds)); } async function doSomething(value) { await sleep(1000); return value * value; } (async() => { console.log("Start task."); const result = await doSomething(100); console.log(`Result: ${result}`) })(); 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ function sleep(milliSeconds) { return new Promise(resolve => setTimeout(resolve, milliSeconds)); } async function doSomething(value) { await sleep(1000); return value * value; } (async() => { console.log("Start task."); const result = await doSomething(100); console.log(`Result: ${result}`) })(); Ԟ஍Ͱ͜Ε૬౰ͷͳʹ͔Λ
 ࣮૷͢Δඞཁ͕͋Δ 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ w࣮૷ͷલʹొ৔ਓ෺Λʜ 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ wTVTQFOE$PSPVUJOF

TVTQFOE
GVODUJPOΛ࣮૷͢Δҝͷ




ɹɹɹɹɹɹɹɹɹɹɹɹɹɹɹɹɹ#VJMEFS
GVODUJPO
w$POUJOVBUJPO

TVTQFOE
GVODUJPOΛ࠶։͢Δҝͷ&NJUUFSɹ
wଞɺTVTQFOE$PSPVUJOFɺ$POUJOVBUJPO
 γϦʔζ͕͍͔ͭ͋͘Δ͚ͲҰ୴লུ 

TVTQFOE
GVODUJPOΛ࣮૷͢Δ suspend fun doSomething(value: Int): Int = suspendCoroutine { continuation -> continuation.resume(value * value) } suspend fun doSomething(value: Int): Int = suspendCoroutine { continuation -> continuation.resumeWithException(Throwable()) } 

طଘίʔυΛTVTQFOE
GVO w$14 ͍ΘΏΔDBMMCBDLܗࣜ ͔ΒҠߦ͍ͨ͠৔߹ fun doSomethingAsync(value: Int, listener: Listener) { if (value <= 0) { listener.onError(Throwable()) } else { listener.onSuccess(value) } } suspend fun doSomething(value: Int): Int = suspendCoroutine { doSomethingAsync(value, object : Listener { override fun onSuccess(value: Int) { it.resume(value) } override fun onError(e: Throwable) { it.resumeWithException(e) } }) } 

طଘίʔυΛTVTQFOE
GVO w3FBDUJWFd͔ΒҠߦ͍ͨ͠৔߹͸ม׵༻ϥΠϒϥϦΛ࢖͏
 ҎԼ͸3Y+BWBͷྫ 
 fun doSomethingSingle(value: Int): Single = Single.just(value * value) suspend fun doSomething(value: Int): Int = doSomethingSingle(value).await() implementation "org.jetbrains.kotlinx:kotlinx-coroutines-rx2:1.0.1" 

ྫ֎र͍͍ͨ launch { try { val result = doSomething() } catch (e: Throwable) { // } } launch { runCatching { doSomething() } // Result͕ฦ٫͞ΕΔ .onSuccess { value -> } .onFailure { throwable -> } } ,PUMJO͔Β௥ՃͷSVO$BUDIJOHਪ঑ 

࣮ߦίϯςΩετม͍͑ͨ class SimpleCoroutineScope : CoroutineScope { private val job: Job = Job() override val coroutineContext: CoroutineContext = job + Dispatchers.Main fun execute() { launch { // Main runCatching { // Main withContext(Dispatchers.IO) { // IO doSomething() } } .onSuccess { value -> // Main } .onFailure { throwable -> // Main } } } } 

Ωϟϯηϧ͍ͨ͠ $ static async ValueTask DoSomething(int value, CancellationToken token) { await Task.Delay(1000); token.ThrowIfCancellationRequested(); return value * value; } static async Task MainAsync(string[] args) { Console.WriteLine("Start task"); var cancellable = new CancellationTokenSource(); var task = DoSomething(100, cancellable.Token); cancellable.Cancel(); var result = await task; Console.WriteLine($"result: {result}"); } 

Ωϟϯηϧ͍ͨ͠ &4 async function doSomething(value, token) { await sleep(1000); await token.rejectIfCancelled(); return value * value; } (async() => { const cancellable = new Cancellable(); const finalize = () => cancellable.cancel(); process.on('exit', finalize); console.log("Start task."); doSomething(100, cancellable.token); console.log(`Result: ${result}`); process.removeListener('exit', finalize); })(); Cancellable.js https://gist.github.com/uzzu/7d6e89fafc4bcde1c6f6d82a3d164409 ˢ͸ྫ͕ѱ͍͕OPEFͰϓϩηεؒ௨৴ͭͭ͠௕ظλεΫ࣮ߦͯͯ͠ʜͳ࣌ͱ͔ 

Ωϟϯηϧ͍ͨ͠ class SimpleCoroutineScope : CoroutineScope { private val job: Job = Job() override val coroutineContext: CoroutineContext = job + Dispatchers.Main fun onDestroy() { job.cancel() } } 

Ωϟϯηϧ͍ͨ͠ class SimpleCoroutineScope : CoroutineScope { private val job: Job = Job() override val coroutineContext: CoroutineContext = job + Dispatchers.Main fun onDestroy() { job.cancel() } } ࢠͷJob(Coroutine)͕શ෦cancel͞ΕΔ ݸผʹcancel͍ͨ͠έʔεʹ͍ͭͯ͸লུ 

ͱΓ͜ΕϦϯΫू w$PSPVUJOF
(VJEF
 IUUQTHJUIVCDPN,PUMJOLPUMJOYDPSPVUJOFTCMPC NBTUFSDPSPVUJOFTHVJEFNE
 ೔ຊޠ༁
IUUQTHJUIVCDPNQMKQLPUMJOYDPSPVUJOFTCMPC KBQBOFTF@USBOTMBUJPODPSPVUJOFTHVJEFNE
w,PUMJO$POGͰࢀՃͨ͠XPSLTIPQ
 IUUQTHJUIVCDPNFMJ[BSPW$PSPVUJOFT8PSLTIPQ
 ຊ౰ʹॳาతͳॴ͔Β"DUPS
1SPEVDFS·Ͱ෼͔Δ 

Ұ୴͜͜·Ͱ 

ଞτϐοΫฉ͖͍ͨࣄ͋Ε͹ޙ΄ͲͲ͏ͧ w "EWBODFE
 3Y+BWBΛར༻࣮ͨ͠૷ͱͷൺֱΛͯ͠ΈΑ͏
 TVTQFOE
GVODUJPOΛෳ਺૸Β͍ͤͨ

BTZODͷར༻ํ๏ͱ஫ҙ఺
 +BWBίʔυͱͷ૬ޓӡ༻
 .VUFY
 ଟॏݺͼग़͠๷ࢭ

IPU
MBVODI
IPU
TVTQFOE
GVODUJPO ໋໊͸ద౰ 
 6OJU
5FTUͷॻ͖ํ
 $PSPVUJOF4UBSU
$PSPVUJOF&YDFQUJPO)BOEMFS
TVTQFOE$PSPVUJOF$POUJOVBUJPO
γϦʔζ 
 ଞඈ͹ౕͨ͠
 $IBOOFM
"DUPS
1SPEVDFS
w %FFQ
%JWJOH
 KPC

EJTQBUDIFS


ʜ
ͬͯԿ
 ͲΜͳίʔυʹͳΔͷ

όΠτίʔυݟͳ͕Β
 $PSPVUJOFͷத਎Ͳ͏ͳͬͯΜͷ

ιʔείʔυಡΈͳ͕Β
 NVMUJQMBUGPSNؔ࿈