Tasks

Core.Task — Type
Task(func[, reserved_stack::Int])

指定された関数 func(引数なしで呼び出せる必要があります)を実行する Task(コルーチン)を作成します。この関数が戻ると、タスクは終了します。タスクは、scheduled の時点で親から引き継いだ「ワールドエイジ」で実行されます。

省略可能な引数 reserved_stack は、このタスクで使用できるスタックのサイズをバイト単位で指定します。デフォルトの 0 では、システム依存のデフォルトのスタックサイズが使用されます。

Warning

デフォルトでは、タスクの 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 です。

source
Base.@task — Macro
@task

式を実行せずにTaskでラップし、Taskを返します。これはタスクを作成するだけで、実行はしません。

Warning

デフォルトでは、タスクの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)
true
source
Base.@async — Macro
@async

式をTaskで囲み、ローカルマシンのスケジューラキューに追加します。

@asyncには、$を使って値を補間できます。これにより、値が構築される基底のクロージャに直接コピーされます。変数の「値」を挿入できるため、現在のタスクでその変数の値が変更されても、非同期コードには影響しません。

Warning

特に公開配布されるライブラリでは、並列処理が不要な場合であっても、常に@asyncよりThreads.@spawnを優先することを強く推奨します。これは、現行のJulia実装では、@asyncを使うと、親タスクがワーカースレッド間を移動できなくなるためです。そのため、ライブラリ関数内で何気なく@asyncを使うだけでも、ユーザーアプリケーションのまったく別の部分のパフォーマンスに大きな影響を及ぼす可能性があります。

Julia 1.4

$による値の補間は、Julia 1.4以降で利用できます。

source
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)))
5

ntasks=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)))
2

batch_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"
source
Base.asyncmap! — Function
asyncmap!(f, results, c...; ntasks=0, batch_size=nothing)

asyncmapと似ていますが、コレクションを返すのではなく、出力をresultsに格納します。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

source
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)
true
source
Base.istaskstarted — Function
istaskstarted(t::Task)::Bool

タスクの実行が開始されたかどうかを判定します。

Examples

julia> a3() = sum(i for i in 1:1000);

julia> b = Task(a3);

julia> istaskstarted(b)
false
source
Base.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)
true
Julia 1.3

この関数を使用するには、Julia 1.3 以降が必要です。

source
Base.task_local_storage — Method
task_local_storage(key)

現在のタスクのタスクローカルストレージで、キーの値を検索します。

source
Base.task_local_storage — Method
task_local_storage(key, value)

現在のタスクのタスクローカルストレージで、キーに値を割り当てます。

source
Base.task_local_storage — Method
task_local_storage(body, key, value)

body を、タスクローカルストレージを変更して呼び出します。この変更では、value に key を割り当てます。呼び出し後は、key の以前の値(値がなかった場合はその状態)に戻します。動的スコープをエミュレートするのに便利です。

source
Core.ConcurrencyViolationError — Type
ConcurrencyViolationError(msg) <: Exception

並行処理のセマンティクスに対する検出可能な違反が発生したときにスローされるエラーです。

このエラーが使われる例を、網羅的ではありませんが、以下に示します。

  • デッドロックが検出されたとき(例:wait(current_task()))
  • 安全でないことが既知の動作を試みたとき(例:yield(current_task))
  • スレッドセーフでないことが既知のデータ構造を、複数の並行タスクから変更しようとしたとき
  • このタスクがロックしていないロックを解除しようとしたとき
source

Scheduling

Base.yield — Function
yield(t::Task, arg = nothing)

スケジューラを呼び出す前に、ただちにtへ譲る、schedule(t, arg); yield()の高速な不公平スケジューリング版です。

tが現在実行中のタスクである場合、ConcurrencyViolationErrorをスローします。

source
yield()

スケジューラに切り替えて、別のスケジュール済みタスクを実行できるようにします。この関数を呼び出したタスクは引き続き実行可能な状態にあり、ほかに実行可能なタスクがなければ直ちに再開されます。

source
Base.yieldto — Function
yieldto(t::Task, arg = nothing)

指定したタスクに切り替えます。タスクに初めて切り替えるときは、そのタスクの関数が引数なしで呼び出されます。2回目以降の切り替えでは、そのタスクが前回 yieldto を呼び出したときの戻り値が arg から返されます。これはタスクの切り替えだけを行う低レベルの呼び出しであり、状態やスケジューリングは一切考慮しません。使用は推奨されません。

source
Base.sleep — Function
sleep(seconds)

現在のタスクを、指定した秒数だけブロックします。最小スリープ時間は1ミリ秒、または0.001の入力です。

source
Base.schedule — Function
schedule(t::Task, [val]; error=false)

スケジューラのキューにTaskを追加します。これにより、システムがほかの処理をしていない間、タスクは常に実行されます。ただし、タスクがwaitのようなブロッキング操作を行う場合は除きます。

2つ目の引数としてvalを指定すると、タスクが再び実行される際に、その値がyieldtoの戻り値を介してタスクに渡されます。errorがtrueの場合、その値は起床したタスク内で例外として送出されます。

Warning

すでに開始されている任意のTaskに対してscheduleを使用するのは誤りです。詳しくはthe API referenceを参照してください。

Warning

デフォルトでは、タスクの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)
true
source

Synchronization

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:
[...]
source
Base.@sync — Macro
@sync

Distributed.@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 2
source
Base.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 ループ内で呼び出されます。

source
Base.waitany — Function
waitany(tasks; throw=true) -> (done_tasks, remaining_tasks)

指定されたタスクのうち、少なくとも1つが完了するまで待機します。

throw が true の場合、完了したタスクのいずれかが例外を発生させて終了すると、CompositeException をスローします。

戻り値は2つのタスクベクトルで構成されます。1つ目は完了したタスク、もう1つは未完了のタスクです。

Warning

呼び出すたびに tasks のリストを走査し、各タスクと同期する必要があるため、タスクごとに個別のタスクを作成して直列に実行するコードを書く場合と比べて、効率が悪くなる可能性があります。または、代わりに waitall(tasks; failfast=true) を使うことも検討してください。

Julia 1.12

この関数を使用するには、Julia 1.12 以降が必要です。

source
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つには未完了のタスクが格納されます。

Julia 1.12

この関数を使用するには、Julia 1.12 以降が必要です。

source
Base.fetch — Method
fetch(t::Task)

Task の完了を待ってから、その結果の値を返します。タスクが例外で失敗した場合は、失敗したタスクをラップする TaskFailedException がスローされます。

source
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)
:ok
source
Base.Condition — Type
Condition()

タスクが待機できる、エッジトリガー型のイベントソースを作成します。Condition に対して wait を呼び出したタスクは、一時停止され、キューに追加されます。その後、Condition に対して notify を呼び出すと、タスクが起こされます。notify のオプション引数を指定すると、条件の待機から値が返されたり、エラーが発生したりすることがあります。エッジトリガーでは、notify の呼び出し時点で待機中のタスクだけが起こされます。レベルトリガー型の通知を実現するには、通知が発生したかどうかを追跡するための状態を別途保持する必要があります。Channel 型と Threads.Event 型はこの処理を行うため、レベルトリガー型のイベントに使用できます。

このオブジェクトはスレッドセーフではありません。スレッドセーフなバージョンについては、Threads.Condition を参照してください。

source
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)
end
Julia 1.2

この機能を使用するには、Julia 1.2以降が必要です。

source
Base.Event — Type
Event([autoreset=false])

レベルトリガー型のイベントソースを作成します。Eventに対してwaitを呼び出したタスクは、Eventに対してnotifyが呼び出されるまで、一時停止してキューに入れられます。notifyが呼び出されると、Eventはシグナル状態を維持し、resetが呼び出されるまで、待機中のタスクがブロックされなくなります。

autoresetがtrueの場合、notifyを呼び出すたびに、waitから解放されるタスクは最大1つです。

これにより、notify/waitに対してacquire/releaseメモリ順序が保証されます。

Julia 1.1

この機能を使用するには、Julia 1.1以降が必要です。

Julia 1.8

autoresetの機能とメモリ順序の保証を利用するには、Julia 1.8以降が必要です。

source
Base.notify — Function
notify(condition, val=nothing; all=true, error=false)

条件を待機しているタスクを起こし、valを渡します。allがtrue(デフォルト)の場合は待機中のすべてのタスクを起こし、それ以外の場合は1つだけを起こします。errorがtrueの場合、渡された値は起こされたタスク内で例外として送出されます。

起こしたタスクの数を返します。conditionを待機しているタスクがない場合は0を返します。

source
Base.reset — Method
reset(::Event)

Eventを未設定の状態に戻します。その後は、notifyが再度呼び出されるまで、waitの呼び出しはブロックされます。

source
Base.Semaphore — Type
Semaphore(sem_size)

同時に使用できる acquire の数が最大 sem_size となるカウントセマフォを作成します。各 acquire には、対応する release が必要です。

acquire/release の呼び出しでは、acquire & release のメモリ順序が保証されます。

source
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
end
Julia 1.8

このメソッドを使用するには、Julia 1.8以降が必要です。

source
acquire(s::Semaphore)

sem_size の許可証が利用可能になるまで待機します。取得できるまでブロックします。

source
Base.@acquire — Macro
Base.@acquire s::Semaphore expr

f 関数の代わりに expr を使う、Base.acquire(f, s::Semaphore) のマクロ版です。次のように展開されます。

Base.acquire(s)
try
    expr
finally
    Base.release(s)
end

これは、acquire と do ブロックを使う方法に似ていますが、クロージャの作成を避けられます。

Julia 1.13

Base.@acquire は Julia 1.13 で追加されました

source
Base.release — Function
release(s::Semaphore)

許可証を1つプールに返却します。これにより、別のタスクがその許可証を取得して実行を再開できる場合があります。

source
Base.lock — Function
lock(f::Function, l::Lockable)

lに関連付けられたロックを取得し、ロックを保持した状態でfを実行します。fが戻ったら、ロックを解放します。fには、lでラップされた値が位置引数として1つ渡されます。ロックが別のタスクまたはスレッドによってすでに取得されている場合は、ロックが利用可能になるまで待機します。この関数が戻る時点で、lockは解放済みです。そのため、呼び出し元はunlockしないでください。

Julia 1.11

Julia 1.11以降が必要です。

source
lock(f::Function, lock)

lockを取得し、lockを保持した状態でfを実行します。fが返ったら、lockを解放します。ロックがすでに別のタスクまたはスレッドによって取得されている場合は、使用可能になるまで待機します。

この関数が返ると、lockは解放されています。そのため、呼び出し側でunlockしないでください。

関連項目: @lock。

Julia 1.7

2番目の引数としてChannelを使用するには、Julia 1.7以降が必要です。

source
lock(lock)

利用可能になったら、lockを取得します。ロックがすでに別のタスク/スレッドによって取得されている場合は、利用可能になるまで待ちます。

各lockには、unlockを対応させる必要があります。

source
Base.unlock — Function
unlock(lock)

lock の所有権を解放します。

以前に取得した再帰ロックの場合は、内部カウンターをデクリメントして直ちに戻ります。

source
Base.trylock — Function
trylock(lock) -> Success (Boolean)

ロックが利用可能であれば取得し、成功した場合は true を返します。別のタスク/スレッドがすでにロックを取得している場合は、false を返します。

成功した trylock には、それぞれ unlock を対応させる必要があります。

trylock と islocked を組み合わせると、typeof(lock) でサポートされている場合に限り、test-and-test-and-set アルゴリズムや指数バックオフアルゴリズムを実装できます(ドキュメントを参照してください)。

source
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()
end

Implementation

ロックの実装では、以下の特性を持つislockedを定義し、その旨をdocstringに記載することを推奨します。

  • islocked(lock)はデータ競合が発生しない。
  • islocked(lock)がfalseを返した場合、他のタスクによる干渉がなければ、直後にtrylock(lock)を呼び出すと成功し(trueを返し)なければならない。
source
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)は成功します。

source
Base.@lock — Macro
@lock l expr

f 関数の代わりに expr を使う、lock(f, l::AbstractLock) のマクロ版です。次のように展開されます。

lock(l)
try
    expr
finally
    unlock(l)
end

これは、do ブロックを使って lock を使う方法に似ていますが、クロージャの作成を避けられるため、パフォーマンスが向上する場合があります。

Compat

@lock は Julia 1.3 で追加され、Julia 1.7 でエクスポートされました。

source
Base.Lockable — Type
Lockable(value, lock = ReentrantLock())

Lockable オブジェクトを作成します。このオブジェクトは value をラップし、指定された lock に関連付けます。@lock、lock、trylock、unlock をサポートします。値にアクセスするには、ロックを保持した状態でロック可能オブジェクトをインデックス指定します。

Julia 1.11

Julia 1.11 以降が必要です。

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}"
source

Channels

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)と同等です。
Julia 1.3

デフォルトのコンストラクターChannel()と、デフォルトのsize=0は、Julia 1.3で追加されました。

source
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[])
true
Julia 1.3

spawn=パラメーターはJulia 1.3で追加されました。このコンストラクターもJulia 1.3で追加されました。それ以前のJuliaでは、Channelはキーワード引数でsizeとTを設定していましたが、これらのコンストラクターは非推奨です。

Julia 1.9

threadpool=引数はJulia 1.9で追加されました。

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"
source
Base.put! — Method
put!(c::Channel, v)

チャネル c に項目 v を追加します。チャネルが満杯の場合はブロックします。

バッファなしチャネルでは、別のタスクによって take! が実行されるまでブロックします。

Julia 1.1

v は、convert を使ってチャネルの型に変換されるようになりました。これは put! が呼び出される際に行われます。

source
Base.take! — Method
take!(c::Channel)

Channelから順番に値を取り出して返します。データが利用可能になるまでブロックします。バッファなしチャネルの場合は、別のタスクによってput!が実行されるまでブロックします。

Examples

Buffered channel

julia> c = Channel(1);

julia> put!(c, 1);

julia> take!(c)
1

Unbuffered channel

julia> c = Channel(0);

julia> task = Task(() -> put!(c, 1));

julia> schedule(task);

julia> take!(c)
1
source
Base.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)
true

Unbuffered channel

julia> c = Channel(); # capacity = 0

julia> isfull(c) # unbuffered channel is always full
true
source
Base.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)
true

Unbuffered 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)
true
source
Base.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)
false

Unbuffered channel

julia> c = Channel{Int}();

julia> isopen(c)
true

julia> close(c)

julia> isopen(c)
false
source
Base.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
 3
source
Base.close — Method
close(c::Channel[, excp::Exception])

チャネルを閉じます。次の場合、(省略可能な excp を指定して)例外がスローされます。

  • 閉じたチャネルに対する put!。
  • 空で閉じたチャネルに対する take! および fetch。
source
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)
false
julia> 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
[...]
source

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...
done

OneWayEventを使うと、あるタスクが別のタスクの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)は失敗するため、そのようなタスクは存在し得ません。