Asynchronous Programming

プログラムが外部とやり取りする必要がある場合、たとえばインターネット経由で別のマシンと通信する場合、プログラム内の処理は予測できない順序で実行されることがあります。ファイルをダウンロードする必要があるとしましょう。ダウンロード処理を開始し、完了を待つ間にほかの処理を行い、ファイルが利用可能になったら、そのファイルを必要とするコードの実行を再開したいものです。このような状況を扱うのが非同期プログラミングです。概念上、複数の処理が同時に進行することから、並行プログラミングと呼ばれることもあります。

Juliaでは、このような状況に対応するためにTask(対称コルーチン、軽量スレッド、協調的マルチタスク、ワンショット継続など、ほかにもいくつかの呼び名があります)が用意されています。ある計算処理(実際には、特定の関数の実行)をTaskとして指定すると、別のTaskに切り替えて、その処理を中断できます。元のTaskは後から再開でき、その時点で中断した箇所から実行を続けます。一見すると、これは関数呼び出しに似ているように思えるかもしれません。しかし、重要な違いが2つあります。まず、タスクの切り替えではスタック領域を消費しないため、呼び出しスタックを使い切ることなく、何度でもタスクを切り替えられます。次に、関数呼び出しでは呼び出された関数の実行が終わるまで呼び出し元に制御が戻りませんが、タスク間の切り替えは任意の順序で行えます。

Basic Task operations

Taskは、実行する計算処理の単位を表すハンドルと考えることができます。タスクには、作成、開始、実行、終了というライフサイクルがあります。タスクを作成するには、実行する引数なし関数をTaskコンストラクターに渡すか、@taskマクロを使います。

julia> t = @task begin; sleep(5); println("done"); end
Task (runnable) @0x00007f13a40c0eb0

@task xはTask(()->x)と同等です。

このタスクは5秒間待機してから、doneを出力します。ただし、まだ実行は開始されていません。準備ができたら、scheduleを呼び出して実行できます。

julia> schedule(t);

REPLで試すと、scheduleがすぐに戻ることがわかります。これは、実行待ちタスクの内部キューにtを追加するだけだからです。その後、REPLは次のプロンプトを表示し、入力を待ちます。キーボード入力を待つ間は、ほかのタスクを実行できます。そのため、この時点でtの実行が始まります。tはsleepを呼び出し、タイマーを設定して実行を停止します。その時点でほかのタスクがスケジュールされていれば、それらを実行できます。5秒後にタイマーが作動すると、tの実行が再開され、doneが出力されます。これでtは終了です。

wait関数は、別のタスクが終了するまで呼び出し元のタスクをブロックします。たとえば、次のように入力すると、

julia> schedule(t); wait(t)

scheduleを呼び出すだけの場合とは異なり、次の入力プロンプトが表示されるまで5秒間待つことになります。これは、REPLが処理を続ける前にtの終了を待つためです。

タスクを作成してすぐにスケジュールすることはよくあるため、そのためのマクロThreads.@spawnが用意されています。Threads.@spawn xはtask = @task x; task.sticky = false; schedule(task)と同等です。

Communicating with Channels

必要な処理同士が関数呼び出しで自然につながらず、実行すべき処理の間に明確な「呼び出し元」や「呼び出し先」が存在しない問題もあります。たとえば、生産者・消費者問題では、複雑な処理の一方が値を生成し、もう一方がそれを消費します。生産者にはまだ生成すべき値が残っていて、すぐには戻れない可能性があるため、消費者が生産者関数を単純に呼び出して値を取得することはできません。タスクを使えば、生産者と消費者は必要なだけそれぞれ実行し、必要に応じて値をやり取りできます。

Juliaには、この問題を解決するためのChannel機構があります。Channelは、複数のタスクが読み書きできる、待機可能な先入れ先出しキューです。

put!呼び出しで値を生成する生産者タスクを定義しましょう。値を消費するには、生産者を新しいタスクとしてスケジュールする必要があります。引数として1引数関数を受け取る特殊なChannelコンストラクターを使うと、チャネルにバインドされたタスクを実行できます。その後、チャネルオブジェクトから値を繰り返しtake!できます。

julia> function producer(c::Channel)
           put!(c, "start")
           for n=1:4
               put!(c, 2n)
           end
           put!(c, "stop")
       end;

julia> chnl = Channel(producer);

julia> take!(chnl)
"start"

julia> take!(chnl)
2

julia> take!(chnl)
4

julia> take!(chnl)
6

julia> take!(chnl)
8

julia> take!(chnl)
"stop"

この動作は、producerが複数回戻ることができた、と考えることもできます。put!の呼び出しの間、生産者の実行は中断され、消費者が制御を得ます。

返されたChannelは、forループで反復可能オブジェクトとして使えます。この場合、ループ変数には生成された値が順に代入されます。チャネルが閉じられると、ループは終了します。

julia> for x in Channel(producer)
           println(x)
       end
start
2
4
6
8
stop

生産者側でチャネルを明示的に閉じる必要がなかったことに注目してください。これは、ChannelをTaskにバインドすると、チャネルが開いている期間がバインド先のタスクの存続期間に結び付けられるためです。タスクが終了すると、チャネルオブジェクトは自動的に閉じられます。1つのタスクに複数のチャネルをバインドすることも、1つのチャネルを複数のタスクにバインドすることもできます。

Taskコンストラクターが引数なし関数を受け取るのに対し、タスクにバインドされたチャネルを作成するChannelメソッドは、Channel型の引数を1つ受け取る関数を必要とします。生産者をパラメーター化するのはよくあるパターンです。その場合、引数が0個または1個のanonymous functionを作成するために、部分関数適用が必要になります。

Taskオブジェクトでは、これを直接行うことも、便利なマクロを使うこともできます。

function mytask(myarg)
    ...
end

taskHdl = Task(() -> mytask(7))
# or, equivalently
taskHdl = @task mytask(7)

より高度な作業分配パターンを構成するには、bindとscheduleを、TaskおよびChannelコンストラクターと組み合わせて使うことで、チャネルの集合と生産者・消費者タスクの集合を明示的に関連付けられます。

More on Channels

チャネルはパイプとして捉えることができます。つまり、書き込み側と読み取り側があります。

  • 異なるタスクに属する複数の書き手が、put!呼び出しを通じて、同じチャネルに同時に書き込めます。

  • 異なるタスクに属する複数の読み手が、take!呼び出しを通じて、同時にデータを読み取れます。

  • 例を示します。

    # Given Channels c1 and c2,
    c1 = Channel(32)
    c2 = Channel(32)
    
    # and a function `foo` which reads items from c1, processes the item read
    # and writes a result to c2,
    function foo()
        while true
            data = take!(c1)
            [...]               # process data
            put!(c2, result)    # write out result
        end
    end
    
    # we can schedule `n` instances of `foo` to be active concurrently.
    for _ in 1:n
        errormonitor(Threads.@spawn foo())
    end
  • チャネルはChannel{T}(sz)コンストラクターで作成します。チャネルに格納できるのはT型のオブジェクトだけです。型を指定しない場合は、任意の型のオブジェクトを格納できます。szは、チャネルに同時に格納できる要素数の上限を表します。たとえば、Channel(32)は、任意の型のオブジェクトを最大32個格納できるチャネルを作成します。Channel{MyType}(64)は、MyType型のオブジェクトを最大64個格納できます。

  • Channelが空の場合、読み手はデータが利用可能になるまで(take!呼び出し時に)ブロックします(isemptyを参照)。

  • Channelが満杯の場合、書き手は空きができるまで(put!呼び出し時に)ブロックします(isfullを参照)。

  • isreadyはチャネル内にオブジェクトがあるかどうかを調べます。一方、waitはオブジェクトが利用可能になるまで待機します。

  • 別のタスクがオブジェクトをチャネルにput!しようと待機している場合、チャネル内の要素数が容量を超えることがあります。

  • Channelは、最初は開いた状態です。そのため、take!およびput!呼び出しを通じて、自由に読み書きできます。closeはChannelを閉じます。閉じたChannelに対しては、put!が失敗します。たとえば、次のとおりです。

    julia> c = Channel(2);
    
    julia> put!(c, 1) # `put!` on an open channel succeeds
    1
    
    julia> close(c);
    
    julia> put!(c, 2) # `put!` on a closed channel throws an exception.
    ERROR: InvalidStateException: Channel is closed.
    Stacktrace:
    [...]
  • チャネルを閉じた後でも、take!とfetch(値を取得しますが、削除はしません)は、チャネルが空になるまで既存の値を正常に返します。先ほどの例を続けると、次のようになります。

    julia> fetch(c) # Any number of `fetch` calls succeed.
    1
    
    julia> fetch(c)
    1
    
    julia> take!(c) # The first `take!` removes the value.
    1
    
    julia> take!(c) # No more data available on a closed channel.
    ERROR: InvalidStateException: Channel is closed.
    Stacktrace:
    [...]

タスク間通信にチャネルを使う簡単な例を見てみましょう。単一のjobsチャネルからデータを処理するタスクを4つ起動します。ジョブはID(job_id)で識別され、チャネルに書き込まれます。このシミュレーションでは、各タスクがjob_idを読み取り、ランダムな時間だけ待機した後、job_idとシミュレーション上の所要時間を組み合わせたタプルを結果チャネルに書き込みます。最後に、すべてのresultsを出力します。

julia> const jobs = Channel{Int}(32);

julia> const results = Channel{Tuple}(32);

julia> function do_work()
           for job_id in jobs
               exec_time = rand()
               sleep(exec_time)                # simulates elapsed time doing actual work
                                               # typically performed externally.
               put!(results, (job_id, exec_time))
           end
       end;

julia> function make_jobs(n)
           for i in 1:n
               put!(jobs, i)
           end
       end;

julia> n = 12;

julia> errormonitor(Threads.@spawn make_jobs(n)); # feed the jobs channel with "n" jobs

julia> for i in 1:4 # start 4 tasks to process requests in parallel
           errormonitor(Threads.@spawn do_work())
       end

julia> @elapsed while n > 0 # print out results
           job_id, exec_time = take!(results)
           println("$job_id finished in $(round(exec_time; digits=2)) seconds")
           global n = n - 1
       end
4 finished in 0.22 seconds
3 finished in 0.45 seconds
1 finished in 0.5 seconds
7 finished in 0.14 seconds
2 finished in 0.78 seconds
5 finished in 0.9 seconds
9 finished in 0.36 seconds
6 finished in 0.87 seconds
8 finished in 0.79 seconds
10 finished in 0.64 seconds
12 finished in 0.5 seconds
11 finished in 0.97 seconds
0.029772311

errormonitor(t)の代わりにbind(results, t)を使うと、より堅牢な解決策になる場合があります。予期しない失敗を記録するだけでなく、関連するリソースを確実に閉じ、例外をすべての箇所に伝播させるためです。

More task operations

タスク操作は、yieldtoという低レベルのプリミティブを基盤としています。yieldto(task, value)は現在のタスクを中断して、指定されたtaskに切り替え、そのタスクの直近のyieldto呼び出しが、指定されたvalueを返すようにします。タスク形式の制御フローに必要な操作はyieldtoだけです。呼び出しと復帰を行うのではなく、常に別のタスクへ切り替えます。この機能が「対称コルーチン」とも呼ばれるのはそのためです。どのタスクへの切り替えも、タスクからの切り替えも、同じ仕組みで行います。

yieldtoは強力ですが、タスクを使う場面のほとんどでは直接呼び出しません。その理由を考えてみましょう。現在のタスクから切り替えた後は、いずれそのタスクに戻りたいはずです。しかし、いつ戻るのか、どのタスクが戻す責任を負うのかを把握するには、かなりの調整が必要になることがあります。たとえば、put!とtake!はブロッキング操作です。チャネルと組み合わせて使うと、消費者がどのタスクなのかを記憶する状態を管理します。消費側のタスクを手動で追跡する必要がないため、低レベルのyieldtoよりもput!のほうが使いやすくなっています。

yieldtoに加えて、タスクを効果的に使うには、ほかにもいくつかの基本関数が必要です。

  • current_taskは、現在実行中のタスクへの参照を取得します。
  • istaskdoneは、タスクが終了したかどうかを調べます。
  • istaskstartedは、タスクがすでに実行されたかどうかを調べます。
  • task_local_storageは、現在のタスク固有のキーと値のストアを操作します。

Tasks and events

タスクの切り替えの多くは、I/O要求などのイベントを待つことで発生し、Julia Baseに含まれるスケジューラーによって実行されます。スケジューラーは実行可能なタスクのキューを管理し、メッセージの到着などの外部イベントに応じてタスクを再開するイベントループを実行します。

イベントを待つ基本関数はwaitです。複数のオブジェクトがwaitを実装しています。たとえば、Processオブジェクトに対してwaitを呼び出すと、そのオブジェクトが終了するまで待機します。waitは暗黙的に行われることもよくあります。たとえば、データが利用可能になるのを待つためにreadを呼び出すと、その内部でwaitが発生することがあります。

これらの場合、waitは最終的にConditionオブジェクトを操作します。このオブジェクトがタスクのキューイングと再開を担います。タスクがConditionに対してwaitを呼び出すと、そのタスクは実行不可としてマークされ、条件のキューに追加された後、スケジューラーに切り替わります。スケジューラーは別のタスクを実行するか、外部イベントを待ってブロックします。問題がなければ、最終的にイベントハンドラーが条件に対してnotifyを呼び出し、その条件を待っていたタスクが再び実行可能になります。

Taskを呼び出して明示的に作成したタスクは、最初はスケジューラーに認識されていません。そのため、必要であればyieldtoを使ってタスクを手動で管理できます。ただし、そのようなタスクがイベントを待つ場合、期待どおり、イベントが発生すると自動的に再開されます。