Tasks
Core.Task — Type
Task(func[, reserved_stack::Int])指定された関数 func(引数なしで呼び出せる必要があります)を実行する Task(コルーチン)を作成します。この関数が戻ると、タスクは終了します。タスクは、scheduled の時点で親から引き継いだ「ワールドエイジ」で実行されます。
省略可能な引数 reserved_stack は、このタスクで使用できるスタックのサイズをバイト単位で指定します。デフォルトの 0 では、システム依存のデフォルトのスタックサイズが使用されます。
デフォルトでは、タスクの sticky ビットは true に設定されます t.sticky。これは、@async の従来のデフォルト動作を再現するものです。sticky タスクは、最初にスケジュールされたワーカースレッドでしか実行できません。また、スケジュールされると、そのタスクをスケジュールしたタスクも sticky になります。Threads.@spawn の動作にするには、sticky ビットを手動で false に設定します。
Examples
julia> a() = sum(i for i in 1:1000);
julia> b = Task(a);この例では、b は、まだ開始されていない実行可能な Task です。
Base.@task — Macro
@task式を実行せずにTaskでラップし、Taskを返します。これはタスクを作成するだけで、実行はしません。
デフォルトでは、タスクのstickyビットはtrue t.stickyに設定されます。これは、@asyncにおける従来のデフォルト動作を再現したものです。stickyタスクは、最初にスケジュールされたワーカースレッドでのみ実行できます。また、スケジュールされると、そのタスクをスケジュールしたタスクもstickyになります。Threads.@spawnの動作にするには、stickyビットを手動でfalseに設定してください。
Examples
julia> a1() = sum(i for i in 1:1000);
julia> b = @task a1();
julia> istaskstarted(b)
false
julia> schedule(b);
julia> yield();
julia> istaskdone(b)
trueBase.@async — Macro
@async式をTaskで囲み、ローカルマシンのスケジューラキューに追加します。
@asyncには、$を使って値を補間できます。これにより、値が構築される基底のクロージャに直接コピーされます。変数の「値」を挿入できるため、現在のタスクでその変数の値が変更されても、非同期コードには影響しません。
Base.asyncmap — Function
asyncmap(f, c...; ntasks=0, batch_size=nothing)コレクション(または複数の同じ長さのコレクション)に対して、複数の並行タスクを使って f を適用します。複数のコレクションを引数に指定した場合、f は要素ごとに適用されます。
出力の順序は、コレクションの要素の順序 c と同じになることが保証されています。
ntasks は、同時に実行するタスク数を指定します。コレクションの長さに応じて、ntasks が指定されていない場合、並行マッピングには最大100個のタスクが使用されます。
ntasks には、引数を取らない関数を指定することもできます。この場合、各要素の処理前に並列実行するタスク数が確認され、ntasks_func の値が現在のタスク数を上回ると、新しいタスクが開始されます。
batch_size を指定すると、コレクションはバッチモードで処理されます。この場合、f は、引数タプルの Vector を受け取り、結果のベクトルを返す関数でなければなりません。入力ベクトルの長さは batch_size 以下です。
以下の例では、マッピング関数が実行されたタスクの objectid を返すことで、異なるタスクでの実行を示します。
まず、ntasks が未定義の場合、各要素はそれぞれ異なるタスクで処理されます。
julia> tskoid() = objectid(current_task());
julia> asyncmap(x->tskoid(), 1:5)
5-element Vector{UInt64}:
0x6e15e66c75c75853
0x440f8819a1baa682
0x9fb3eeadd0c83985
0xebd3e35fe90d4050
0x29efc93edce2b961
julia> length(unique(asyncmap(x->tskoid(), 1:5)))
5ntasks=2 を指定すると、すべての要素が2つのタスクで処理されます。
julia> asyncmap(x->tskoid(), 1:5; ntasks=2)
5-element Vector{UInt64}:
0x027ab1680df7ae94
0xa23d2f80cd7cf157
0x027ab1680df7ae94
0xa23d2f80cd7cf157
0x027ab1680df7ae94
julia> length(unique(asyncmap(x->tskoid(), 1:5; ntasks=2)))
2batch_size を定義した場合、マッピング関数は引数タプルの配列を受け取り、結果の配列を返すように変更する必要があります。変更後のマッピング関数では、これを実現するために map を使用します。
julia> batch_func(input) = map(x->string("args_tuple: ", x, ", element_val: ", x[1], ", task: ", tskoid()), input)
batch_func (generic function with 1 method)
julia> asyncmap(batch_func, 1:5; ntasks=2, batch_size=2)
5-element Vector{String}:
"args_tuple: (1,), element_val: 1, task: 9118321258196414413"
"args_tuple: (2,), element_val: 2, task: 4904288162898683522"
"args_tuple: (3,), element_val: 3, task: 9118321258196414413"
"args_tuple: (4,), element_val: 4, task: 4904288162898683522"
"args_tuple: (5,), element_val: 5, task: 9118321258196414413"Base.asyncmap! — Function
asyncmap!(f, results, c...; ntasks=0, batch_size=nothing)asyncmapと似ていますが、コレクションを返すのではなく、出力をresultsに格納します。
Base.current_task — Function
current_task()現在実行中のTaskを取得します。
Base.istaskdone — Function
istaskdone(t::Task)::Boolタスクが終了したかどうかを判定します。
Examples
julia> a2() = sum(i for i in 1:1000);
julia> b = Task(a2);
julia> istaskdone(b)
false
julia> schedule(b);
julia> yield();
julia> istaskdone(b)
trueBase.istaskstarted — Function
istaskstarted(t::Task)::Boolタスクの実行が開始されたかどうかを判定します。
Examples
julia> a3() = sum(i for i in 1:1000);
julia> b = Task(a3);
julia> istaskstarted(b)
falseBase.istaskfailed — Function
istaskfailed(t::Task)::Boolタスクが例外のスローによって終了したかどうかを判定します。
Examples
julia> a4() = error("task failed");
julia> b = Task(a4);
julia> istaskfailed(b)
false
julia> schedule(b);
julia> yield();
julia> istaskfailed(b)
trueBase.task_local_storage — Method
task_local_storage(key)現在のタスクのタスクローカルストレージで、キーの値を検索します。
Base.task_local_storage — Method
task_local_storage(key, value)現在のタスクのタスクローカルストレージで、キーに値を割り当てます。
Base.task_local_storage — Method
task_local_storage(body, key, value)body を、タスクローカルストレージを変更して呼び出します。この変更では、value に key を割り当てます。呼び出し後は、key の以前の値(値がなかった場合はその状態)に戻します。動的スコープをエミュレートするのに便利です。
Core.ConcurrencyViolationError — Type
ConcurrencyViolationError(msg) <: Exception並行処理のセマンティクスに対する検出可能な違反が発生したときにスローされるエラーです。
このエラーが使われる例を、網羅的ではありませんが、以下に示します。
- デッドロックが検出されたとき(例:
wait(current_task())) - 安全でないことが既知の動作を試みたとき(例:
yield(current_task)) - スレッドセーフでないことが既知のデータ構造を、複数の並行タスクから変更しようとしたとき
- このタスクがロックしていないロックを解除しようとしたとき
Scheduling
Base.yield — Function
yield(t::Task, arg = nothing)スケジューラを呼び出す前に、ただちにtへ譲る、schedule(t, arg); yield()の高速な不公平スケジューリング版です。
tが現在実行中のタスクである場合、ConcurrencyViolationErrorをスローします。
yield()スケジューラに切り替えて、別のスケジュール済みタスクを実行できるようにします。この関数を呼び出したタスクは引き続き実行可能な状態にあり、ほかに実行可能なタスクがなければ直ちに再開されます。
Base.yieldto — Function
yieldto(t::Task, arg = nothing)指定したタスクに切り替えます。タスクに初めて切り替えるときは、そのタスクの関数が引数なしで呼び出されます。2回目以降の切り替えでは、そのタスクが前回 yieldto を呼び出したときの戻り値が arg から返されます。これはタスクの切り替えだけを行う低レベルの呼び出しであり、状態やスケジューリングは一切考慮しません。使用は推奨されません。
Base.sleep — Function
sleep(seconds)現在のタスクを、指定した秒数だけブロックします。最小スリープ時間は1ミリ秒、または0.001の入力です。
Base.schedule — Function
schedule(t::Task, [val]; error=false)スケジューラのキューにTaskを追加します。これにより、システムがほかの処理をしていない間、タスクは常に実行されます。ただし、タスクがwaitのようなブロッキング操作を行う場合は除きます。
2つ目の引数としてvalを指定すると、タスクが再び実行される際に、その値がyieldtoの戻り値を介してタスクに渡されます。errorがtrueの場合、その値は起床したタスク内で例外として送出されます。
すでに開始されている任意のTaskに対してscheduleを使用するのは誤りです。詳しくはthe API referenceを参照してください。
デフォルトでは、タスクのstickyビットはtrue t.stickyに設定されます。これは、@asyncにおける従来のデフォルト動作を再現するものです。stickyタスクは、最初にスケジュールされたワーカースレッドでのみ実行できます。また、スケジュールされると、そのタスクをスケジュールした側のタスクもstickyになります。Threads.@spawnの動作にするには、stickyビットを手動でfalseに設定してください。
Examples
julia> a5() = sum(i for i in 1:1000);
julia> b = Task(a5);
julia> istaskstarted(b)
false
julia> schedule(b);
julia> yield();
julia> istaskstarted(b)
true
julia> istaskdone(b)
trueSynchronization
Base.errormonitor — Function
errormonitor(t::Task)タスク t が失敗した場合は、stderr にエラーログを出力します。
Examples
julia> wait(errormonitor(Threads.@spawn error("task failed")); throw = false)
Unhandled Task ERROR: task failed
Stacktrace:
[...]Base.@sync — Macro
@syncDistributed.@spawnat、Distributed.@distributed、@async、@spawnで字句的に囲まれたすべての処理が完了するまで待機します。囲まれた非同期処理でスローされた例外はすべて収集され、CompositeExceptionとしてスローされます。
Examples
julia> Threads.nthreads()
4
julia> @sync begin
Threads.@spawn println("Thread-id $(Threads.threadid()), task 1")
Threads.@spawn println("Thread-id $(Threads.threadid()), task 2")
end;
Thread-id 3, task 1
Thread-id 1, task 2Base.wait — Function
wait([x])イベントが発生するまで、現在のタスクをブロックします。
Channel: チャネルに値が追加されるまで待機します。Condition: 条件が満たされるまでnotifyを待機し、notifyに渡されたvalパラメーターを返します。正確な動作については、waitのCondition固有の docstring を参照してください。Process: プロセスまたはプロセスチェーンが終了するまで待機します。成功したか失敗したかは、プロセスのexitcodeフィールドで確認できます。Task:Taskが終了するまで待機します。正確な動作については、waitのTask固有の docstring を参照してください。RawFD: ファイル記述子の変更を待機します(FileWatchingパッケージを参照)。
引数を渡さない場合、タスクは期間が定まらないままブロックされます。タスクを再開できるのは、schedule または yieldto を明示的に呼び出した場合のみです。
多くの場合、待機対象の条件が満たされてから処理を続行できるよう、wait は while ループ内で呼び出されます。
Base.waitany — Function
waitany(tasks; throw=true) -> (done_tasks, remaining_tasks)指定されたタスクのうち、少なくとも1つが完了するまで待機します。
throw が true の場合、完了したタスクのいずれかが例外を発生させて終了すると、CompositeException をスローします。
戻り値は2つのタスクベクトルで構成されます。1つ目は完了したタスク、もう1つは未完了のタスクです。
呼び出すたびに tasks のリストを走査し、各タスクと同期する必要があるため、タスクごとに個別のタスクを作成して直列に実行するコードを書く場合と比べて、効率が悪くなる可能性があります。または、代わりに waitall(tasks; failfast=true) を使うことも検討してください。
Base.waitall — Function
waitall(tasks; failfast=true, throw=true) -> (done_tasks, remaining_tasks)指定されたすべてのタスクが完了するまで待機します。
failfast が true の場合、指定されたタスクのうち少なくとも1つが例外によって終了すると、この関数は戻ります。完了したタスクのいずれかが失敗している場合、CompositeException をスローするには、throw を true に設定します。
キーワード引数 failfast と throw は独立して機能します。throw=true のみを指定した場合、この関数はすべてのタスクが完了するまで待機します。
戻り値は2つのタスクベクトルからなります。1つ目には完了したタスクが、もう1つには未完了のタスクが格納されます。
Base.fetch — Method
fetch(t::Task)Task の完了を待ってから、その結果の値を返します。タスクが例外で失敗した場合は、失敗したタスクをラップする TaskFailedException がスローされます。
Base.fetch — Method
fetch(x::Any)x
Base.timedwait — Function
timedwait(testcb, timeout::Real; pollint::Real=0.1)testcb() が true または timeout 秒経過するまで待ちます。いずれか早い方が適用されます。テスト関数は pollint 秒ごとにポーリングされます。pollint の最小値は 0.001 秒、つまり 1 ミリ秒です。
:ok または :timed_out を返します。
Examples
julia> cb() = (sleep(5); return);
julia> t = @async cb();
julia> timedwait(()->istaskdone(t), 1)
:timed_out
julia> timedwait(()->istaskdone(t), 6.5)
:okBase.Condition — Type
Condition()タスクが待機できる、エッジトリガー型のイベントソースを作成します。Condition に対して wait を呼び出したタスクは、一時停止され、キューに追加されます。その後、Condition に対して notify を呼び出すと、タスクが起こされます。notify のオプション引数を指定すると、条件の待機から値が返されたり、エラーが発生したりすることがあります。エッジトリガーでは、notify の呼び出し時点で待機中のタスクだけが起こされます。レベルトリガー型の通知を実現するには、通知が発生したかどうかを追跡するための状態を別途保持する必要があります。Channel 型と Threads.Event 型はこの処理を行うため、レベルトリガー型のイベントに使用できます。
このオブジェクトはスレッドセーフではありません。スレッドセーフなバージョンについては、Threads.Condition を参照してください。
Base.Threads.Condition — Type
Threads.Condition([lock])Base.Conditionのスレッドセーフなバージョンです。
Threads.Conditionに対してwaitまたはnotifyを呼び出すには、まずlockを呼び出す必要があります。waitを呼び出すと、ブロック中はロックがアトミックに解放され、waitが戻る前に再取得されます。そのため、Threads.Condition cの慣用的な使い方は次のようになります。
lock(c)
try
while !thing_we_are_waiting_for
wait(c)
end
finally
unlock(c)
endBase.Event — Type
Event([autoreset=false])レベルトリガー型のイベントソースを作成します。Eventに対してwaitを呼び出したタスクは、Eventに対してnotifyが呼び出されるまで、一時停止してキューに入れられます。notifyが呼び出されると、Eventはシグナル状態を維持し、resetが呼び出されるまで、待機中のタスクがブロックされなくなります。
autoresetがtrueの場合、notifyを呼び出すたびに、waitから解放されるタスクは最大1つです。
これにより、notify/waitに対してacquire/releaseメモリ順序が保証されます。
Base.notify — Function
notify(condition, val=nothing; all=true, error=false)条件を待機しているタスクを起こし、valを渡します。allがtrue(デフォルト)の場合は待機中のすべてのタスクを起こし、それ以外の場合は1つだけを起こします。errorがtrueの場合、渡された値は起こされたタスク内で例外として送出されます。
起こしたタスクの数を返します。conditionを待機しているタスクがない場合は0を返します。
Base.reset — Method
Base.Semaphore — Type
Semaphore(sem_size)同時に使用できる acquire の数が最大 sem_size となるカウントセマフォを作成します。各 acquire には、対応する release が必要です。
acquire/release の呼び出しでは、acquire & release のメモリ順序が保証されます。
Base.acquire — Function
acquire(f, s::Semaphore)Semaphore sから取得した後にfを実行し、完了時またはエラー発生時にreleaseを実行します。
たとえば、次のdoブロック形式では、fooの呼び出しが同時にアクティブになるのは2つまでです。
s = Base.Semaphore(2)
@sync for _ in 1:100
Threads.@spawn begin
Base.acquire(s) do
foo()
end
end
endacquire(s::Semaphore)sem_size の許可証が利用可能になるまで待機します。取得できるまでブロックします。
Base.@acquire — Macro
Base.@acquire s::Semaphore exprf 関数の代わりに expr を使う、Base.acquire(f, s::Semaphore) のマクロ版です。次のように展開されます。
Base.acquire(s)
try
expr
finally
Base.release(s)
endこれは、acquire と do ブロックを使う方法に似ていますが、クロージャの作成を避けられます。
Base.release — Function
release(s::Semaphore)許可証を1つプールに返却します。これにより、別のタスクがその許可証を取得して実行を再開できる場合があります。
Base.lock — Function
lock(f::Function, l::Lockable)lに関連付けられたロックを取得し、ロックを保持した状態でfを実行します。fが戻ったら、ロックを解放します。fには、lでラップされた値が位置引数として1つ渡されます。ロックが別のタスクまたはスレッドによってすでに取得されている場合は、ロックが利用可能になるまで待機します。この関数が戻る時点で、lockは解放済みです。そのため、呼び出し元はunlockしないでください。
lock(f::Function, lock)lockを取得し、lockを保持した状態でfを実行します。fが返ったら、lockを解放します。ロックがすでに別のタスクまたはスレッドによって取得されている場合は、使用可能になるまで待機します。
この関数が返ると、lockは解放されています。そのため、呼び出し側でunlockしないでください。
関連項目: @lock。
2番目の引数としてChannelを使用するには、Julia 1.7以降が必要です。
lock(lock)利用可能になったら、lockを取得します。ロックがすでに別のタスク/スレッドによって取得されている場合は、利用可能になるまで待ちます。
各lockには、unlockを対応させる必要があります。
Base.unlock — Function
unlock(lock)lock の所有権を解放します。
以前に取得した再帰ロックの場合は、内部カウンターをデクリメントして直ちに戻ります。
Base.trylock — Function
trylock(lock) -> Success (Boolean)ロックが利用可能であれば取得し、成功した場合は true を返します。別のタスク/スレッドがすでにロックを取得している場合は、false を返します。
成功した trylock には、それぞれ unlock を対応させる必要があります。
trylock と islocked を組み合わせると、typeof(lock) でサポートされている場合に限り、test-and-test-and-set アルゴリズムや指数バックオフアルゴリズムを実装できます(ドキュメントを参照してください)。
Base.islocked — Function
islocked(lock) -> Status (Boolean)lockが、いずれかのタスクまたはスレッドによって保持されているかどうかを確認します。この関数だけを同期に使用してはいけません。ただし、islockedとtrylockを組み合わせれば、typeof(lock)がサポートしている場合に限り(ドキュメントを参照)、test-and-test-and-setアルゴリズムや指数バックオフアルゴリズムを実装できます。
Extended help
たとえば、lockの実装が以下に記載する特性を満たしていれば、次のように指数バックオフを実装できます。
nspins = 0
while true
while islocked(lock)
GC.safepoint()
nspins += 1
nspins > LIMIT && error("timeout")
end
trylock(lock) && break
backoff()
endImplementation
ロックの実装では、以下の特性を持つislockedを定義し、その旨をdocstringに記載することを推奨します。
islocked(lock)はデータ競合が発生しない。islocked(lock)がfalseを返した場合、他のタスクによる干渉がなければ、直後にtrylock(lock)を呼び出すと成功し(trueを返し)なければならない。
Base.ReentrantLock — Type
ReentrantLock()Taskを同期するための再入可能ロックを作成します。同じタスクは必要な回数だけロックを取得できます(名前に「再入可能」とあるのはこのためです)。各lockには、対応するunlockが必要です。
lockを呼び出すと、対応するunlockが呼び出されるまで、そのスレッドでファイナライザーが実行されなくなります。以下に示す標準的なロックパターンは通常どおり使用できますが、tryとlockの順序を逆にしたり、tryブロックを省略したりしないよう注意してください(たとえば、ロックを保持したままreturnしようとする場合など)。
これにより、ロックとアンロックの呼び出しに対して、acquire/releaseのメモリ順序が保証されます。
lock(l)
try
<atomic work>
finally
unlock(l)
end!islocked(lck::ReentrantLock)が成立する場合、ほかのタスクが「同時に」ロックを保持しようとしていなければ、trylock(lck)は成功します。
Base.@lock — Macro
@lock l exprf 関数の代わりに expr を使う、lock(f, l::AbstractLock) のマクロ版です。次のように展開されます。
lock(l)
try
expr
finally
unlock(l)
endこれは、do ブロックを使って lock を使う方法に似ていますが、クロージャの作成を避けられるため、パフォーマンスが向上する場合があります。
Base.Lockable — Type
Lockable(value, lock = ReentrantLock())Lockable オブジェクトを作成します。このオブジェクトは value をラップし、指定された lock に関連付けます。@lock、lock、trylock、unlock をサポートします。値にアクセスするには、ロックを保持した状態でロック可能オブジェクトをインデックス指定します。
Example
julia> locked_list = Base.Lockable(Int[]);
julia> @lock(locked_list, push!(locked_list[], 1)) # must hold the lock to access the value
1-element Vector{Int64}:
1
julia> lock(summary, locked_list)
"1-element Vector{Int64}"Channels
Base.AbstractChannel — Type
AbstractChannel{T}T型のオブジェクトを渡すチャネルの表現。
Base.Channel — Type
Channel{T=Any}(size::Int=0)内部バッファに、型Tのオブジェクトを最大size個まで保持できるChannelを構築します。チャネルが満杯のときにput!を呼び出すと、take!によってオブジェクトが取り出されるまでブロックされます。
Channel(0)は、バッファなしのチャネルを構築します。対応するtake!が呼び出されるまで、put!はブロックされます。逆の場合も同様です。
その他のコンストラクター:
Channel(): デフォルトのコンストラクター。Channel{Any}(0)と同等です。Channel(Inf):Channel{Any}(typemax(Int))と同等です。Channel(sz):Channel{Any}(sz)と同等です。
Base.Channel — Method
Channel{T=Any}(func::Function, size=0; taskref=nothing, spawn=false, threadpool=nothing)funcから新しいタスクを作成し、bindで型がT、サイズがsizeの新しいチャネルに接続して、タスクをスケジュールします。これらすべてを1回の呼び出しで行います。タスクが終了すると、チャネルは自動的に閉じられます。
funcは、バインドされたチャネルだけを引数として受け取る必要があります。
作成したタスクへの参照が必要な場合は、キーワード引数taskrefにRef{Task}オブジェクトを渡します。
spawn=trueの場合、func用に作成されたTaskは、別のスレッドで並行してスケジュールされることがあります。これは、Threads.@spawnを使ってタスクを作成するのと同等です。
spawn=trueの場合、threadpool引数が設定されていなければ、デフォルトで:defaultになります。
threadpool引数が設定されている場合(:defaultまたは:interactive)、これはspawn=trueを意味し、新しいタスクは指定されたスレッドプールで起動されます。
Channelを返します。
Examples
julia> chnl = Channel() do ch
foreach(i -> put!(ch, i), 1:4)
end;
julia> typeof(chnl)
Channel{Any}
julia> for i in chnl
@show i
end;
i = 1
i = 2
i = 3
i = 4作成したタスクへの参照:
julia> taskref = Ref{Task}();
julia> chnl = Channel(taskref=taskref) do ch
println(take!(ch))
end;
julia> istaskdone(taskref[])
false
julia> put!(chnl, "Hello");
Hello
julia> istaskdone(taskref[])
truespawn=パラメーターはJulia 1.3で追加されました。このコンストラクターもJulia 1.3で追加されました。それ以前のJuliaでは、Channelはキーワード引数でsizeとTを設定していましたが、これらのコンストラクターは非推奨です。
julia> chnl = Channel{Char}(1, spawn=true) do ch
for c in "hello world"
put!(ch, c)
end
end;
julia> String(collect(chnl))
"hello world"Base.take! — Method
take!(c::Channel)Channelから順番に値を取り出して返します。データが利用可能になるまでブロックします。バッファなしチャネルの場合は、別のタスクによってput!が実行されるまでブロックします。
Examples
Buffered channel
julia> c = Channel(1);
julia> put!(c, 1);
julia> take!(c)
1Unbuffered channel
julia> c = Channel(0);
julia> task = Task(() -> put!(c, 1));
julia> schedule(task);
julia> take!(c)
1Base.isfull — Method
isfull(c::Channel)Channel が満杯かどうかを判定します。つまり、put!(c, some_value) を呼び出すとブロックされる状態かどうかを調べます。すぐに戻り、ブロックしません。
この呼び出しが true を返した後でも、put! がブロックしないことはよくあります。このメソッドを呼び出すことで、コードにライブロックが誤って発生しないよう、ユーザーは注意する必要があります。ライブロックは一般にデッドロックよりもデバッグが困難です。また、複数のプロデューサータスクが並行して put! を呼び出している場合、この呼び出しが false を返した後でも、put! がブロックする可能性があります。
Examples
Buffered channel
julia> c = Channel(1); # capacity = 1
julia> isfull(c)
false
julia> put!(c, 1);
julia> isfull(c)
trueUnbuffered channel
julia> c = Channel(); # capacity = 0
julia> isfull(c) # unbuffered channel is always full
trueBase.isready — Method
isready(c::Channel)Channelに値が格納されているかどうかを判定します。ブロックせず、すぐに戻ります。
バッファなしチャネルの場合、put!で待機中のタスクがあれば、trueを返します。
Examples
Buffered channel
julia> c = Channel(1);
julia> isready(c)
false
julia> put!(c, 1);
julia> isready(c)
trueUnbuffered channel
julia> c = Channel();
julia> isready(c) # no tasks waiting to put!
false
julia> task = Task(() -> put!(c, 1));
julia> schedule(task); # schedule a put! task
julia> isready(c)
trueBase.isopen — Method
isopen(c::Channel)Channelが新しいput!操作を受け付ける状態かどうかを判定します。Channelは閉じていても、バッファに要素が残っており、take!で取り出せる場合があります。
Examples
Buffered channel with task
julia> c = Channel(ch -> put!(ch, 1), 1);
julia> isopen(c) # The channel is closed to new `put!`s
false
julia> isready(c) # The channel is closed but still contains elements
true
julia> take!(c)
1
julia> isready(c)
falseUnbuffered channel
julia> c = Channel{Int}();
julia> isopen(c)
true
julia> close(c)
julia> isopen(c)
falseBase.fetch — Method
fetch(c::Channel)Channel から最初に利用可能な項目を待ち受け、削除せずに返します。注: バッファーなし(サイズ 0)の Channel では、fetch はサポートされません。
Examples
Buffered channel
julia> c = Channel(3) do ch
foreach(i -> put!(ch, i), 1:3)
end;
julia> fetch(c)
1
julia> collect(c) # item is not removed
3-element Vector{Any}:
1
2
3Base.close — Method
close(c::Channel[, excp::Exception])チャネルを閉じます。次の場合、(省略可能な excp を指定して)例外がスローされます。
Base.bind — Method
bind(chnl::Channel, task::Task)chnlのライフタイムをタスクに関連付けます。タスクが終了すると、Channel chnlは自動的に閉じられます。タスク内で捕捉されなかった例外は、chnlで待機しているすべてのタスクに伝播します。
chnlオブジェクトは、タスクの終了とは無関係に明示的に閉じることができます。タスクが終了しても、すでに閉じられているChannelオブジェクトには影響しません。
チャネルが複数のタスクに関連付けられている場合、最初に終了したタスクがチャネルを閉じます。複数のチャネルが同じタスクに関連付けられている場合、そのタスクが終了すると、関連付けられているすべてのチャネルが閉じられます。
Examples
julia> c = Channel(0);
julia> task = @async foreach(i->put!(c, i), 1:4);
julia> bind(c,task);
julia> for i in c
@show i
end;
i = 1
i = 2
i = 3
i = 4
julia> isopen(c)
falsejulia> c = Channel(0);
julia> task = @async (put!(c, 1); error("foo"));
julia> bind(c, task);
julia> take!(c)
1
julia> put!(c, 1);
ERROR: TaskFailedException
Stacktrace:
[...]
nested task error: foo
[...]Low-level synchronization using schedule and wait
scheduleを正しく使う最も簡単な方法は、まだ開始(スケジュール)されていないTaskに対して使うことです。ただし、scheduleとwaitを、同期インターフェースを構築するための非常に低レベルな構成要素として使うこともできます。schedule(task)を呼び出す際の重要な前提条件は、呼び出し元がtaskを「所有」していることです。つまり、指定されたtask内でwaitが呼び出される位置を、schedule(task)を呼び出すコードが把握していなければなりません。この前提条件を満たす方法の一つは、次の例のようにアトミック操作を使うことです。
@enum OWEState begin
OWE_EMPTY
OWE_WAITING
OWE_NOTIFYING
end
mutable struct OneWayEvent
@atomic state::OWEState
task::Task
OneWayEvent() = new(OWE_EMPTY)
end
function Base.notify(ev::OneWayEvent)
state = @atomic ev.state
while state !== OWE_NOTIFYING
# Spin until we successfully update the state to OWE_NOTIFYING:
state, ok = @atomicreplace(ev.state, state => OWE_NOTIFYING)
if ok
if state == OWE_WAITING
# OWE_WAITING -> OWE_NOTIFYING transition means that the waiter task is
# already waiting or about to call `wait`. The notifier task must wake up
# the waiter task.
schedule(ev.task)
else
@assert state == OWE_EMPTY
# Since we are assuming that there is only one notifier task (for
# simplicity), we know that the other possible case here is OWE_EMPTY.
# We do not need to do anything because we know that the waiter task has
# not called `wait(ev::OneWayEvent)` yet.
end
break
end
end
return
end
function Base.wait(ev::OneWayEvent)
ev.task = current_task()
state, ok = @atomicreplace(ev.state, OWE_EMPTY => OWE_WAITING)
if ok
# OWE_EMPTY -> OWE_WAITING transition means that the notifier task is guaranteed to
# invoke OWE_WAITING -> OWE_NOTIFYING transition. The waiter task must call
# `wait()` immediately. In particular, it MUST NOT invoke any function that may
# yield to the scheduler at this point in code.
wait()
else
@assert state == OWE_NOTIFYING
# Otherwise, the `state` must have already been moved to OWE_NOTIFYING by the
# notifier task.
end
return
end
ev = OneWayEvent()
@sync begin
Threads.@spawn begin
wait(ev)
println("done")
end
println("notifying...")
notify(ev)
end
# output
notifying...
doneOneWayEventを使うと、あるタスクが別のタスクのnotifyに対してwaitできます。waitは単一のタスクから一度しか使えないため、これは制限のある通信インターフェースです(ev.taskへの代入がアトミックではない点に注意してください)。
この例では、notify(ev::OneWayEvent)がschedule(ev.task)を呼び出せるのは、そのタスク自身が状態をOWE_WAITINGからOWE_NOTIFYINGに変更した場合に限られます。これにより、wait(ev::OneWayEvent)を実行しているタスクが現在ok分岐にいることが分かります。また、ほかのタスクがschedule(ev.task)を試みても、それらの@atomicreplace(ev.state, state => OWE_NOTIFYING)は失敗するため、そのようなタスクは存在し得ません。