std.concurrency

__gshared string received;
static void spawnedFunc(Tid ownerTid)
{
    import std.conv : text;
    // オーナー・スレッドからメッセージを受け取る。
    receive((int i){
        received = text("Received the number ", i);

        // オーナー・スレッドに成功を示すメッセージを
        // 送り返す。
        send(ownerTid, true);
    });
}

// 新しいスレッドでspawnedFuncを開始する。
auto childTid = spawn(&spawnedFunc, thisTid);

// この新しいスレッドに42番を送る。
send(childTid, 42);

// 結果コードを受け取る。
auto wasSuccessful = receiveOnly!(bool);
assert(wasSuccessful);
writeln(received); // "Received the number 42"("42番を受信")

class MessageMismatch: object.Exception;

の呼び出し時にスローされる。 receiveOnlyを呼び出したときにスローされる。 を呼び出すとスローされる。

pure nothrow @nogc @safe this(string msg = "Unexpected message type");

class OwnerTerminated: object.Exception;

への呼び出し時にスローされる。 receiveへの呼び出し時に投げられる。 への呼び出し時に投げられる。

pure nothrow @nogc @safe this(Tid t, string msg = "Owner terminated");

class LinkTerminated: object.Exception;

リンクされているスレッドが終了した場合にスローされる。

pure nothrow @nogc @safe this(Tid t, string msg = "Link terminated");

class PriorityMessageException: object.Exception;

を介してスレッドにメッセージが送られた場合にスローされる。 std.concurrency.prioritySendを介してスレッドに送られ、受信側がこのタイプのメッセージのハンドラ を持たない場合に投げられる。

this(Variant vals);

Variant message;

送信されたメッセージ。

class MailboxFull: object.Exception;

が設定されている場合、メールボックスの混雑時にスローされる。 OnCrowding.throwException.

pure nothrow @nogc @safe this(Tid t, string msg = "Mailbox full");

class TidMissingException: object.Exception;

Tid 。 ownerTid例えば オーナー・スレッドが見つからない場合などに投げられる。

struct Tid;

論理スレッドを表すために使用される不透明な型。

const void toString(W)(ref W w);

このTid を識別するための便利な文字列を生成する。 これは これは、現在実行されているTid'が同じか違うかを確認するのに便利である。 ロギングやデバッグのためなどである。 将来的に 将来実行されるTid が同じである可能性がある。 toString()出力 Tid を持つ可能性がある。

@property @safe Tid thisTid();

Returns:

呼び出し元のスレッドのTid 。

@property Tid ownerTid();

呼び出し元のスレッドを生成したスレッドのTid を返す。

Throws:

所有者スレッドがない場合は、TidMissingException 例外が発生する。 を返す。

Tid spawn(F, T...)(F fn, T args)
if (isSpawnable!(F, T));

新しい論理スレッドで開始する。 fn(args)を新しい論理スレッドで開始する。

で表される新しい論理スレッドで与えられた関数を実行する。 Tid. 呼び出し元のスレッドは新しいスレッドのオーナーとして指定される。 所有スレッドが終了すると、OwnerTerminated メッセージが新しいスレッドに送られる。 でOwnerTerminated 例外がスローされる。 receive() をスローする。

Parameters:

F fn	実行する関数。
T args	関数の引数。

Returns:

新しい論理スレッドを表すTid 。

注釈: argsは非共有エイリアシングであってはならない。 言い換えれば、すべての引数 への引数はすべて fnへの引数はすべて、shared またはimmutable であるか、あるいは でなければならない。 これはスレッド間の分離を強制するために必要である。 スレッド間の分離を強制するために必要である。

同様に fnがデリゲートである場合、共有されないエイリアスを持ってはならない。 fnはshared かimmutable のどちらかでなければならない。

Examples:

static void f(string msg)
{
    writeln(msg); // "Hello World"
}

auto tid = spawn(&f, "Hello World");

Examples:

失敗: char[] は変更可能なエイリアシングを持つ。

string msg = "Hello, World!";

static void f1(string msg) {}
static assert(!__traits(compiles, spawn(&f1, msg.dup)));
static assert( __traits(compiles, spawn(&f1, msg.idup)));

static void f2(char[] msg) {}
static assert(!__traits(compiles, spawn(&f2, msg.dup)));
static assert(!__traits(compiles, spawn(&f2, msg.idup)));

Examples:

匿名機能付き新スレッド

spawn({
    ownerTid.send("This is so great!");
});
writeln(receiveOnly!string); // "This is so great!"("これは素晴らしい!")

Tid spawnLinked(F, T...)(F fn, T args)
if (isSpawnable!(F, T));

始める fn(args)論理スレッドで開始しLinkTerminated 操作の終了時にメッセージを受け取る。

で表される新しい論理スレッドで指定された関数を実行する。 Tid. この新しいスレッドは呼び出しスレッドにリンクされている。 この新しいスレッドは呼び出しスレッドとリンクされており、スレッドまたは呼び出しスレッドのどちらかが終了すると、LinkTerminated メッセージがもう一方に送信される。 receive() にLinkTerminated 例外をスローさせる。 spawn() スレッド間のリンクが切断されると、所有者の終了が発生する。 スレッド間のリンクが切れても、所有者が終了すると、 で例外がスローされる。 OwnerTerminated 例外がreceive() 。

Parameters:

F fn	実行する関数。
T args	関数の引数。

Returns:

新しいスレッドを表すTid。

void send(T...)(Tid tid, T vals);

tidのメッセージキューの後ろにメッセージとして値を置く。

与えられた値をtidで表されるスレッドに送信する。 と同様に std.concurrency.spawnと同様、T は非共有エイリアシングであってはならない。

void prioritySend(T...)(Tid tid, T vals);

値をメッセージとしてtidのメッセージキューの先頭に置く。

にメッセージを送る。 tidにメッセージを送るが tidにメッセージを送るが キューにメッセージを送る。 この"関数"は通常、次のような場合に使われる。 この関数は通常、帯域外通信や例外的な状態を通知する場合などに使われる。

void receive(T...)(T ops);

他のスレッドからメッセージを受け取る。

他のスレッドからメッセージを受け取る。 指定された型のメッセージがない場合はブロックする。 この"関数"は、メッセージとデリゲートのセットをパターン・マッチさせることによって動作する。 この関数は、メッセージとデリゲートのセットをパターン・マッチさせ、最初にマッチしたものを実行する。

を受け付けるデリゲートが std.variant.Variantを受け付けるデリゲートが の最後の引数として receiveの最後の引数として にマッチする。 複数の引数が送られた場合 には、Variant 。 std.typecons.Tupleを含む。 が送られる。

Parameters:

T ops

関数ポインタとデリゲートの可変長引数リスト。エントリ のエントリは、後のエントリと重複してはならない。

Throws:

OwnerTerminated送信スレッドが終了したとき。

Examples:

import std.variant : Variant;

auto process = ()
{
    receive(
        (int i) { ownerTid.send(1); },
        (double f) { ownerTid.send(2); },
        (Variant v) { ownerTid.send(3); }
    );
};

{
    auto tid = spawn(process);
    send(tid, 42);
    writeln(receiveOnly!int); // 1
}

{
    auto tid = spawn(process);
    send(tid, 3.14);
    writeln(receiveOnly!int); // 2
}

{
    auto tid = spawn(process);
    send(tid, "something else");
    writeln(receiveOnly!int); // 3
}

receiveOnlyRet!T receiveOnly(T...)();

指定された型の引数を持つメッセージのみを受信する。

Parameters:

T	受信する型の可変長リスト。

Returns:

受信したメッセージ。 T に複数のエントリがある場合、 にまとめられる。 std.typecons.Tuple.

Throws:

MessageMismatch以外の型のメッセージを受信した場合、次のようになる。T を受信した、 OwnerTerminatedを受信した場合、送信スレッドは終了した。

Examples:

auto tid = spawn(
{
    assert(receiveOnly!int == 42);
});
send(tid, 42);

Examples:

auto tid = spawn(
{
    assert(receiveOnly!string == "text");
});
send(tid, "text");

Examples:

struct Record { string name; int age; }

auto tid = spawn(
{
    auto msg = receiveOnly!(double, Record);
    assert(msg[0] == 0.5);
    assert(msg[1].name == "Alice");
    assert(msg[1].age == 31);
});

send(tid, 0.5, Record("Alice", 31));

bool receiveTimeout(T...)(Duration duration, T ops);

他のスレッドからのメッセージを受信し、指定された時間内に一致するものがなければあきらめる。 はあきらめる。

他のスレッドからメッセージを受け取る。 durationを超えるまでブロックする、 を超えるまでブロックする。この関数は次のように動作する。 この関数は、メッセージとデリゲートのセットをパターン・マッチさせ、最初にマッチしたものを実行する。 を実行する。

もし std.variant.Variantを受け付けるデリゲートが を受け取るデリゲートが最後の引数として含まれる場合、そのデリゲート は、それ以前のデリゲートによってマッチしなかったすべてのメッセージに マッチする。 にマッチする。 複数の引数が送られた場合 Variant を含む。 std.typecons.Tupleを含む。 が送られる。

Parameters:

Duration duration	Duration(継続時間)。もし durationが負なら は全く待たない。
T ops	関数ポインタとデリゲートの可変長引数リスト。エントリ このリストのエントリは、後のエントリをオカしてはならない。

Returns:

true メッセージを受け取ったら、 。 である。 false

Throws:

OwnerTerminated送信スレッドが終了したときである。

enum OnCrowding: int;

これらの動作は、メールボックスが一杯になったときに指定することができる。

block

空きができるまで待つ。

throwException

例外をスローする。 MailboxFull例外を投げる。

ignore

送信を中止してリターンする。

pure @safe void setMaxMailboxSize(Tid tid, size_t messages, OnCrowding doThis);

メールボックスの最大サイズを設定する。

メールボックスで許可されるユーザ・メッセージの最大数の制限を設定する。 この制限に達した場合、新しいメッセージを追加しようとした呼び出し元は、doThis で指定された動作を実行する。 doThisで指定された動作を実行する。 messages がゼロの場合、メールボックス は制限されない。

Parameters:

Tid tid	この制限を設定するスレッドの Tid。
size_t messages	メッセージの最大数、または制限がない場合はゼロ。
OnCrowding doThis	メッセージが満杯の メールボックスがいっぱいになったときに実行される動作。

void setMaxMailboxSize(Tid tid, size_t messages, bool function(Tid) onCrowdingDoThis);

メールボックスの最大サイズを設定する。

メールボックスで許可されるユーザー・メッセージの最大数の制限を設定する。 この制限に達した場合、新しいメッセージを追加しようとする呼び出し元は onCrowdingDoThisを実行する。 messages がゼロの場合、メールボックスはアンバインドされる。

Parameters:

Tid tid	この制限を設定するスレッドのTid。
size_t messages	メッセージの最大数、または制限がない場合はゼロ。
bool function(Tid) onCrowdingDoThis	満杯の メールボックスに送られたときに呼び出されるルーチン。

bool register(string name, Tid tid);

name と tid を関連付ける。

名前と tid をプロセス・ローカル・マップに関連付ける。 スレッド tidで表されるスレッドが終了すると、それに関連付けられた名前はすべて は自動的に登録解除される。

Parameters:

string name	tidに関連付ける名前。
Tid tid	名前でtidを登録する。

Returns:

その名前が利用可能で、tidが消滅したスレッドを表すことがわかっていない場合は true を返す。 になる。

bool unregister(string name);

tidに関連付けられている登録名を削除する。

Parameters:

string name

登録解除する名前。

Returns:

名前が登録されていればtrue、登録されていなければfalseを返す。

Tid locate(string name);

name に関連付けられたTid を取得する。

Parameters:

string name

レジストリ内で探す名前。

Returns:

nameが登録されていない場合は、関連するTid 、またはTid.init 。

struct ThreadInfo;

スケジューリングに必要なすべての実装レベルデータをカプセル化する。

を定義するときは、この構造体のインスタンスを関連付けなければならない。 Schedulerを定義する場合、この構造体のインスタンスを各論理スレッドに関連付けなければならない。 この構造体のインスタンスは、各論理スレッドに関連付けられていなければならない。 この構造体には、内部APIが必要とする 内部APIが必要とするすべての実装レベル情報が含まれている。

static nothrow @property ref auto thisInfo();

ThreadInfo のスレッドローカルなインスタンスを取得する。

ThreadInfoのスレッドローカルインスタンスを取得する。 によって作成されていないスレッドに対して情報が要求された場合のデフォルト・インスタンスとして使用されるべきである。 Scheduler.

void cleanup();

この ThreadInfo をクリーンアップする。

これはスケジュールされたスレッドが終了するときに呼び出されなければならない。 これは スレッドのメッセージング・システムを破棄し、関係者にスレッドの終了を通知する。 スレッドの終了を関係者に通知する。

interface Scheduler;

A Schedulerは、spawnによるスレッド処理の実行方法を制御する。

を実装することで Schedulerを実装することで、この モジュールが使用する並行処理機構を、さまざまなニーズに応じてカスタマイズできるようになる。 デフォルトでは を呼び出すと新しいカーネル・スレッドが生成され、与えられたルーチンを実行し、終了すると終了する。 を実行し、終了すると終了する。 しかし Schedulerスレッドを作成することができる。 スレッドを再利用したり、1つのスレッドにFiber(コルーチン)を多重化したりすることもできる、 あるいは、他のアプローチも可能である。 スレッドを再利用する Schedulera ユーザーレベルのオプションを選択することで、std.concurrency 。 ユーザーレベルのオプションを選択することで、 は、この動作があらかじめ定義されている場合よりも、はるかに多くの種類のアプリケーションに使用することができる。

例:

import std.concurrency;
import std.stdio;

void main()
{
    scheduler = new FiberScheduler;
    scheduler.start(
    {
        writeln("the rest of main goes here");
    });
}

スケジューラーの中には、正しく動作させるために、ディスパッチ・ループを実行しなければならないものがある。 従って、スケジューラーを使うときは、一貫性を保つために、、start() をmain() 内で呼び出さなければならない。 これにより、生成されたスレッドが期待通りの方法で実行されるようになる。

abstract void start(void delegate() op);

提供されたopを起動し、Scheduler 。

これは、すべてのスケジューリングをアクティブな インスタンスに委ねるために、プログラムの開始時に呼び出されることを意図している。 スケジューリングをアクティブなScheduler インスタンスにゆだねる。 これは これは、単にオペレーティング・システムに依存するのではなく、明示的にスレッドをディスパッチするスケジューラに必要である。 これは、単にオペレーティング・システムに依存するのではなく、明示的にスレッドをディスパッチするスケジューラにとって必要なことである。 main() を常に呼び出すべきである。

Parameters:

void delegate() op

カスタム・スケジューラがない場合にメイン・スレッドが行うであろう処理のラッパーである。 のラッパーである。 これは、。 Scheduler によって自動的に実行される。

abstract void spawn(void delegate() op);

与えられたopを実行する論理スレッドを割り当てる。

このルーチンはspawnによって呼び出される。 このルーチンはspawnによって呼び出される。 論理スレッドをインスタンス化し、与えられた操作を実行する。 このスレッドは thisInfo.cleanup() を呼び出さなければならない。 すべてのカーネル・スレッドは、スレッドローカルのデストラクタによって自動的にそのThreadInfo すべてのカーネルスレッドは、スレッドローカルのデストラクタによって自動的にクリーンアップされる。

Parameters:

void delegate() op

実行する関数。 実行する関数。 であったり、ラッパー関数であったりする。

abstract nothrow void yield();

別の論理スレッドに実行を委ねる。

このルーチンは、並行処理対応APIの様々な場面で呼び出される。 このルーチンは、ある種の協調マルチスレッドモデルを使用しているときに、スケジューラに実行をゆだねる機会を提供するために、協調を意識したAPI内のさまざまなポイントで呼び出される。 このルーチンは、協調マルチスレッド・モデルを使用している場合に、スケジューラに実行を委ねる機会を提供するために、協調を意識したAPI内の様々な場所で呼ばれる。 これが適切でない場合、例えば 各論理スレッドが専用のカーネル・スレッドにバックアップされている場合などである、 このルーチンはノーオペになるかもしれない。

abstract nothrow @property ref ThreadInfo thisInfo();

適切なThreadInfo インスタンスを返す。

このルーチンを呼び出している論理スレッドに固有のThreadInfo のインスタンスを返す。 のインスタンスを返す。 によって作成されていない場合は、代わりに ThreadInfo.thisInfoを返す。

abstract nothrow Condition newCondition(Mutex m);

シグナリングのためのCondition 変数アナログを作成する。

スレッドのメッセージ・キューへのメッセージの追加をチェックし、シグナルを送るために使用される、新しいCondition 変数 analog を作成する。 をチェックし、スレッドのメッセージ・キューにメッセージが追加されたことを知らせるために使われる。 これは yieldのように、スケジューラによっては、カスタム動作を定義する必要があるかもしれない。 Condition.wait() 。 への呼び出しが、ブロッキングの代わりに別のスレッドに委譲されるように、カスタム動作を定義する必要があるかもしれない。

Parameters:

Mutex m

この条件に関連するMutex 。 この 条件に対する操作の前にロックされる。 場合によっては、Scheduler 、この参照を保持し、他の論理スレッドに実行を委ねる前にミューテックスのロックを解除する必要がある。 他の論理スレッドに実行を委ねる前に、この参照を保持し、ミューテックスのロックを解除する必要がある場合もある。

class ThreadScheduler: std.concurrency.Scheduler;

カーネル・スレッドを使用したScheduler 。

これはScheduler 、デフォルトのスケジューリング動作を反映している。 これは、spawnの呼び出しごとに1つのカーネル・スレッドを生成するという、デフォルトのスケジューリング動作を反映した例である。 これは完全に機能する。 インスタンス化して使用することもできるが、このモジュールのデフォルト機能には必要ない。 このモジュールのデフォルト機能には必要ない。

void start(void delegate() op);

このアプローチでは実際のスケジューリングは必要ないので、これは単にopを直接実行するだけである。 を直接実行するだけである。

void spawn(void delegate() op);

新しいカーネル・スレッドを作成し、与えられたopを実行するように割り当てる。

nothrow void yield();

このスケジューラは明示的な多重化を行わないので、これはno-opである。

nothrow @property ref ThreadInfo thisInfo();

を返す。 ThreadInfo.thisInfoのスレッドローカルインスタンスである。 ThreadInfo を返す。これがこのスケジューラの正しい動作である。

nothrow Condition newCondition(Mutex m);

新しいCondition 変数を作成する。 ここではカスタム動作は必要ない。

class FiberScheduler: std.concurrency.Scheduler;

Fiber sを使った例Scheduler 。

これは、spawnの呼び出しごとに新しいFiber 。 を呼び出すごとに新しい を作成し、メイン・スレッド内ですべてのファイバーの実行を多重化するスケジューラの例である。

void start(void delegate() op);

これは、与えられたopに対して新しいFiber を作成し、それから ディスパッチャーを起動する。

nothrow void spawn(void delegate() op);

これは、供給されたopに対して新しいFiber を作成し、それをディスパッチリストに追加する。 ディスパッチリストに追加する。

nothrow void yield();

呼び出し元がスケジュールされたFiber の場合、これは実行を別のスケジュールされた に譲る。 スケジュールされたFiber に実行をゆだねる。

nothrow @property ref ThreadInfo thisInfo();

適切なThreadInfo インスタンスを返す。

がこのディスパッチャによって作成された場合、呼び出されたFiber に固有のThreadInfo インスタンスを返す。 Fiber がこのディスパッチャによって作成された場合は、呼び出し元の に固有のインスタンスを返す。 ThreadInfo.thisInfo.

nothrow Condition newCondition(Mutex m);

waitまたはnotifyが呼び出されたときに返すCondition 。

バグ デフォルトの実装では、notifyAll はnotify のように振る舞う。

Parameters:

Mutex m

条件を待機させたり、複数のMutex から通知したりする必要がある場合、 をロックに使用する。 または複数のThreadから通知される必要がある場合に、ロックに使用する を指定する。 null の場合、Mutex は使用されず、 からのみ待機/通知されると仮定される。 Condition は1つのThread からのみ待機/通知されるものと仮定される。

protected nothrow void create(void delegate() op);

与えられたデリゲートを呼び出す新しいFiber を作成する。

Parameters:

void delegate() op

ファイバーが呼び出すべきデリゲートは

class InfoFiber: core.thread.fiber.Fiber;

Fiber を埋め込む。ThreadInfo

Scheduler scheduler;

プログラム内でScheduler の動作を設定する。

この変数は、このプログラム内でのScheduler の動作を設定する。 通常 を設定する場合、Scheduler 、 scheduler.start()はmain の中で呼び出されるべきである。 この ルーチンは、プログラムの実行が完了するまで戻らない。

nothrow void yield();

呼び出し元がFiber で、かつ Generatorでない場合、この関数を呼び出す。 scheduler.yield()または Fiber.yield()を呼び出す。

class Generator(T): Fiber, IsGenerator, InputRange!T;

ジェネレーターは、ファイバー を介して、T 型の値を定期的に返す。 yield これは、InputRangeとして表される。 これはInputRangeとして表される。

Examples:

auto tid = spawn({
    int i;
    while (i < 9)
        i = receiveOnly!int;

    ownerTid.send(i * 2);
});

auto r = new Generator!int({
    foreach (i; 1 .. 10)
        yield(i);
});

foreach (e; r)
    tid.send(e);

writeln(receiveOnly!int); // 18

this(void function() fn);

ジェネレーター・オブジェクトを初期化する。 D関数に関連付けられているジェネレーター・オブジェクトを初期化する。 この関数は1度だけ呼び出され、範囲を準備する。 を準備する。

Parameters:

void function() fn

ファイバー関数。

において fnはNULLであってはならない。

this(void function() fn, size_t sz);

ジェネレータ・オブジェクトを初期化する。 D関数に関連付けられているジェネレータ・オブジェクトを初期化する。 この関数は一度だけ呼び出され、範囲を準備する。 を準備するために一度だけ呼び出される。

Parameters:

void function() fn	ファイバー関数".
size_t sz	このファイバーのスタックサイズ。

において fnはNULLであってはならない。

this(void function() fn, size_t sz, size_t guardPageSize);

静的な D関数に関連付けられたジェネレータ・オブジェクトを初期化する。 この関数は一度だけ呼び出される。 を準備するために一度だけ呼び出される。

Parameters:

void function() fn	ファイバー関数".
size_t sz	このファイバーのスタックサイズ。
size_t guardPageSize	このファイバーのスタックサイズ。 オーバーフロー。を参照のこと。 core.thread.Fiber's のドキュメントを参照のこと。

また fnはNULLであってはならない。

this(void delegate() dg);

に関連付けられているジェネレータ・オブジェクトを初期化する。 D関数に関連付けられたジェネレータ・オブジェクトを初期化する。 この関数は1度だけ呼び出され、範囲を準備する。 を準備するために一度だけ呼び出される。

Parameters:

void delegate() dg

ファイバー関数。

において dgはNULLであってはならない。

this(void delegate() dg, size_t sz);

ジェネレータ・オブジェクトを初期化する。 D関数に関連付けられているジェネレータ・オブジェクトを初期化する。 この関数は一度だけ呼び出され、範囲を準備する。 を準備するために一度だけ呼び出される。

Parameters:

void delegate() dg	ファイバー関数".
size_t sz	このファイバーのスタックサイズ。

dgはNULLであってはならない。 dgはNULLであってはならない。

this(void delegate() dg, size_t sz, size_t guardPageSize);

ジェネレータ・オブジェクトを初期化する。 D関数に関連付けられたジェネレータ・オブジェクトを初期化する。 この関数は一度だけ呼び出され、範囲を準備する。 を準備するために一度だけ呼び出される。

Parameters:

void delegate() dg	ファイバー関数".
size_t sz	このファイバーのスタックサイズ。
size_t guardPageSize	このファイバーのスタックサイズ。 オーバーフロー。を参照のこと。 core.thread.Fiber's のドキュメントを参照のこと。

また dgはNULLであってはならない。

final @property bool empty();

ジェネレータが空の場合は真を返す。

final void popFront();

基礎となる関数から次の値を取得する。

final @property T front();

シャロー・コピーによって最近生成された値を返す。

final T moveFront();

コピー・コンストラクタを実行せずに、最近生成された値を返す。 コピー・コンストラクタを実行せずに直近に生成された値を返す。を定義する要素型ではコンパイルされない。 なぜなら、Generator は参照で返さないからである。

void yield(T)(ref T value);

void yield(T)(T value);

現在実行中のジェネレーターの呼び出し元にT型の値を返す。 ジェネレータの呼び出し元にT型の値を返す。

Parameters:

T value

降伏させる値。

Examples:

import std.range;

InputRange!int myIota = iota(10).inputRangeObject;

myIota.popFront();
myIota.popFront();
writeln(myIota.moveFront); // 2
writeln(myIota.front); // 2
myIota.popFront();
writeln(myIota.front); // 3

//直接std.range.interfaces.InputRangeに割り当てることができる
myIota = new Generator!int(
{
    foreach (i; 0 .. 10) yield(i);
});

myIota.popFront();
myIota.popFront();
writeln(myIota.moveFront); // 2
writeln(myIota.front); // 2
myIota.popFront();
writeln(myIota.front); // 3

size_t[2] counter = [0, 0];
foreach (i, unused; myIota) counter[] += [1, i];

assert(myIota.empty);
writeln(counter); // [7, 21]

ref auto initOnce(alias var)(lazy typeof(var) init);

スレッドセーフな方法でvarを遅延init値で初期化する。 で初期化する。

この実装は、すべてのスレッドが同時に を同時に呼び出したすべてのスレッドが、varが完全に初期化されるまでブロックすることを保証する。 が完全に初期化されるまでブロックされる。initのすべての副作用は、その後グローバルに可視化される。 の後に実行される。

Parameters:

var	初期化する変数
typeof(var) init	遅延初期化値

Returns:

初期化された変数への参照

Examples:

典型的な使用例は、スレッドセーフで遅延した初期化を行うことである。

static class MySingleton
{
    static MySingleton instance()
    {
        __gshared MySingleton inst;
        return initOnce!inst(new MySingleton);
    }
}

assert(MySingleton.instance !is null);

ref auto initOnce(alias var)(lazy typeof(var) init, shared Mutex mutex);

ref auto initOnce(alias var)(lazy typeof(var) init, Mutex mutex);

上記と同じだが、すべてのinit-Onceインスタンスでミューテックスを共有する代わりに、個別のミューテックスを取る。 を共有する代わりに、個別のミューテックスを取る。

これは、init 式が他のスレッドの結果を待つときのデッドロックを避けるために使用されるべきである。 を呼び出す可能性がある。注意して使用すること。

Parameters:

var	初期化する変数
typeof(var) init	遅延初期化値
Mutex mutex	競合状態を防ぐためのミューテックス

Returns:

初期化された変数への参照

Examples:

initOnceを呼び出す可能性のある別のスレッドでinitがブロックされる場合は、別のミューテックスを使用する。

import core.sync.mutex : Mutex;

static shared bool varA, varB;
static shared Mutex m;
m = new shared Mutex;

spawn({
    // デッドロックを避けるため、varBには別のミューテックスを使う
    initOnce!varB(true, m);
    ownerTid.send(true);
});
// initはスポーンされたスレッドの結果に依存する
initOnce!varA(receiveOnly!bool);
writeln(varA); // true
writeln(varB); // true