名前¶

threads::shared - スレッド間でデータ構造を共有するためのPerl拡張

概要¶

  use threads;
  use threads::shared;

  my $var : shared;

  my($scalar, @array, %hash);
  share($scalar);
  share(@array);
  share(%hash);
  my $bar = &share([]);
  $hash{bar} = &share({});

  { lock(%hash); ...  }

  cond_wait($scalar);
  cond_timedwait($scalar, time() + 30);
  cond_broadcast(@array);
  cond_signal(%hash);

  my $lockvar : shared;
  # condition var != lock var
  cond_wait($var, $lockvar);
  cond_timedwait($var, time()+30, $lockvar);

説明¶

By default, variables are private to each thread, and each newly created thread gets a private copy of each existing variable. This module allows you to share variables across different threads (and pseudoforks on Win32). It is used together with the threads module.

デフォルトにおいて、変数は各スレッドに対しプライベートである。新たに生成された スレッドは、存在している各変数のプライベートなコピーを得る。このモジュールは 異なるスレッド（とWin32上の擬似fork）間で変数を共有することを可能にする。 threadsモジュールと一緒に使う。

エクスポート¶

share, cond_wait, cond_timedwait, cond_signal, cond_broadcast

Note that if this module is imported when threads has not yet been loaded, then these functions all become no-ops. This makes it possible to write modules that will work in both threaded and non-threaded environments.

まだthreadsがロードされていない段階でこのモジュールをインポートすると、 その機能は全て無効になることに注意。これによりスレッド・非スレッド環境の 両方で動作するモジュールを書くことができる。

関数¶

share VARIABLE

share takes a value and marks it as shared. You can share a scalar, array, hash, scalar ref, array ref or hash ref. share will return the shared rvalue but always as a reference.

shareは値を引数に取り、それを共有化されたものとしてマークする。 スカラー、配列、ハッシュ、スカラーリファレンス、配列リファレンス、あるいは ハッシュリファレンスを共有化することができる。shareは共有化された 右辺値(rvalue)を返すが、それは常にリファレンスとして返される。

share will traverse up references exactly one level. share(\$a) is equivalent to share($a), while share(\\$a) is not.

shareは正確に1レベルリファレンスを辿る。share(\$a)は share($a)と等価だ。しかしshare(\\$a)はそうではない。

A variable can also be marked as shared at compile time by using the shared attribute: my $var : shared.

shared属性（ my $var : shared ）を使うことで、ある変数を コンパイル時に共有化されたものとしてマークすることもできる。

If you want to share a newly created reference unfortunately you need to use &share([]) and &share({}) syntax due to problems with Perl's prototyping.

もし新たに生成したリファレンスを共有したい場合、残念ながら、 Perlのプロトタイプ宣言に伴う問題で、&share([])と&share({}) という構文を使う必要がある。

lock VARIABLE

lock places a lock on a variable until the lock goes out of scope. If the variable is locked by another thread, the lock call will block until it's available. lock is recursive, so multiple calls to lock are safe -- the variable will remain locked until the outermost lock on the variable goes out of scope.

lockはスコープから外れるまで変数をロックする。もし他のスレッドによって その変数がロックされているなら、ロックが可能になるまでlockの呼び出しは ブロックされる。lockは再帰的なので複数回コールしても安全である。-- 最も 外側のロックがスコープから抜けるまでその変数はロックされ続ける。

If a container object, such as a hash or array, is locked, all the elements of that container are not locked. For example, if a thread does a lock @a, any other thread doing a lock($a[12]) won't block.

ハッシュや配列といったコンテナオブジェクトがロックされるからといって、 そこに含まれる全ての要素がロックされるわけではない。例えば、あるスレッドが lock @aするとしても、他のスレッドの行うlock($a[12])はブロックされない。

lock will traverse up references exactly one level. lock(\$a) is equivalent to lock($a), while lock(\\$a) is not.

lockは正確に1レベルリファレンスを辿る。 lock(\$a)はlock($a)と等価だ。しかしlock(\\$a)はそうではない。

Note that you cannot explicitly unlock a variable; you can only wait for the lock to go out of scope. If you need more fine-grained control, see Thread::Semaphore.

明示的に変数をunlockすることはできないことに注意；ロックがスコープを 抜けるのを待つしかない。もしも、よりうまい制御を望むなら Thread::Semaphoreを見ること。

cond_wait VARIABLE

cond_wait CONDVAR, LOCKVAR

The cond_wait function takes a locked variable as a parameter, unlocks the variable, and blocks until another thread does a cond_signal or cond_broadcast for that same locked variable. The variable that cond_wait blocked on is relocked after the cond_wait is satisfied. If there are multiple threads cond_waiting on the same variable, all but one will reblock waiting to reacquire the lock on the variable. (So if you're only using cond_wait for synchronisation, give up the lock as soon as possible). The two actions of unlocking the variable and entering the blocked wait state are atomic, the two actions of exiting from the blocked wait state and relocking the variable are not.

cond_wait関数はロックされた変数を引数に取り、その変数のロックを 解除する。そして他のスレッドがその同じロックされていた変数に向けて cond_signalかcond_broadcastするまで、ブロック（待機）する。 cond_waitがブロックする変数は、cond_waitが完了した後、再度ロック される。もし複数のスレッドが同じ変数に対してcond_waitしているなら、 一つを除いて全てのスレッドがロックを獲得するまで待機するために再度 ブロックする（よって同期のためにcond_waitを使うだけなら、可能な限り 早くロックを解除すること）。変数のロック解除と、ブロックされて待ち状態に 入るという二つの動作はアトミックである。待ち状態から抜けることと、 変数の再ロックという二つの動作は、アトミックではない。

In its second form, cond_wait takes a shared, unlocked variable followed by a shared, locked variable. The second variable is unlocked and thread execution suspended until another thread signals the first variable.

第二の書式では、cond_waitはロックされていない共有変数をとり、 その後ろにロックされた共有変数がくる。この二番目の変数はロックが 解除され、そして他のスレッドが一番目の変数にシグナルを送るまで、 そのスレッドの実行は停止する。

It is important to note that the variable can be notified even if no thread cond_signal or cond_broadcast on the variable. It is therefore important to check the value of the variable and go back to waiting if the requirement is not fulfilled. For example, to pause until a shared counter drops to zero:

どのスレッドも、変数に対しcond_signalやcond_broadcastをしなくても、 その変数はnotifyされうるということに注意することが大切だ。 それゆえ、変数の値のチェック及び、要求が満たされない場合に待ち状態へ戻る ことが重要である。例えば、共有カウンタが0になるまで停止する：

    { lock($counter); cond_wait($count) until $counter == 0; }

cond_timedwait VARIABLE, ABS_TIMEOUT

cond_timedwait CONDVAR, ABS_TIMEOUT, LOCKVAR

In its two-argument form, cond_timedwait takes a locked variable and an absolute timeout as parameters, unlocks the variable, and blocks until the timeout is reached or another thread signals the variable. A false value is returned if the timeout is reached, and a true value otherwise. In either case, the variable is re-locked upon return.

二つの引数をとる形式では、cond_timedwaitはロックされた変数と タイムアウトの絶対時間を引数にとる。変数はロック解除され、タイムアウト 時間に達するか、他のスレッドが変数にシグナルを送るかするまでブロック される。タイムアウトになると偽の値が返される。そうでなければ真の値が 返される。どちらの場合でも戻りの際に変数は再ロックされる。

Like cond_wait, this function may take a shared, locked variable as an additional parameter; in this case the first parameter is an unlocked condition variable protected by a distinct lock variable.

cond_wait同様、この関数はロックされた共有変数を追加のパラメータ としてとれる；この場合、最初のパラメータはロックされていない条件変数 であり、これと区別されるロック変数によって守られる。

Again like cond_wait, waking up and reacquiring the lock are not atomic, and you should always check your desired condition after this function returns. Since the timeout is an absolute value, however, it does not have to be recalculated with each pass:

さらにcond_wait同様、覚醒とロックの再獲得はアトミックでない。 この関数が戻った後、あなたが望んだ状態になっているかどうか常にチェック するべきだろう。しかし、タイムアウトは絶対的な値なので、パスごとに再計算 させるべきではない：

    lock($var);
    my $abs = time() + 15;
    until ($ok = desired_condition($var)) {
      last if !cond_timedwait($var, $abs);
    }
    # $okならそれを得る。そうでなければタイムアウト！

cond_signal VARIABLE

The cond_signal function takes a locked variable as a parameter and unblocks one thread that's cond_waiting on that variable. If more than one thread is blocked in a cond_wait on that variable, only one (and which one is indeterminate) will be unblocked.

cond_signal関数はロックされた変数を引数にとり、その変数に対して cond_waitしている一つのスレッドのブロックを解除する。もし一つ以上の スレッドがcond_waitしてブロックされているなら、ただ一つのスレッド だけがブロックを解除される（どれがなるかは不確定）。

If there are no threads blocked in a cond_wait on the variable, the signal is discarded. By always locking before signaling, you can (with care), avoid signaling before another thread has entered cond_wait().

もしどのスレッドもその変数をcond_waitしていない場合、シグナルは破棄 される。常にシグナルの前にロックされるので、他のスレッドがcond_wait()に 入る前にシグナルを発するのを回避することが（注意深くやれば）出来る。

cond_signal will normally generate a warning if you attempt to use it on an unlocked variable. On the rare occasions where doing this may be sensible, you can skip the warning with

ロックされていない変数に対しcond_signalを試みると、通常は警告を発する。 稀に起こるこの警告がうるさい場合、次の方法で警告をスキップすることができる。

    { no warnings 'threads'; cond_signal($foo) }

cond_broadcast VARIABLE

The cond_broadcast function works similarly to cond_signal. cond_broadcast, though, will unblock all the threads that are blocked in a cond_wait on the locked variable, rather than only one.

cond_broadcast関数はcond_signalとよく似た働きをする。しかし cond_broadcastはスレッド一つだけではなく、ロックされた変数に対して cond_waitして待機中の全スレッドをブロック解除する。

注意¶

threads::shared is designed to disable itself silently if threads are not available. If you want access to threads, you must use threads before you use threads::shared. threads will emit a warning if you use it after threads::shared.

threadsが利用できない場合、threads::sharedは黙って利用不可になるよう 設計されている。threadsにアクセスしようとするなら、use threads::shared する前にuse threadsしなければならない。threads::sharedの後にthreadsを useしようとすれば、警告が発せられる。

バグ¶

bless is not supported on shared references. In the current version, bless will only bless the thread local reference and the blessing will not propagate to the other threads. This is expected to be implemented in a future version of Perl.

blessは共有リファレンスに対してはサポートしていない。現行のバージョンでは、 blessはスレッドローカルなリファレンスをblessするだけである。blessは 他のスレッドにまで伝搬しない。将来のPerlのバージョンでは実装されることが 期待されている。

Does not support splice on arrays!

配列に対するspliceはサポートしていない！

Taking references to the elements of shared arrays and hashes does not autovivify the elements, and neither does slicing a shared array/hash over non-existent indices/keys autovivify the elements.

共有化された配列とハッシュの要素へのリファレンスをとっても 自動活性化しない。また、共有配列／ハッシュで存在しないインデックスや キーにスライスしても、その要素は自動活性化しない。

share() allows you to share $hashref->{key} without giving any error message. But the $hashref->{key} is not shared, causing the error "locking can only be used on shared values" to occur when you attempt to lock $hasref->{key}.

share $hashref->{key}しても、share()はエラーメッセージを出さない。 しかし、$hashref->{key}は共有されない。lock $hasref->{key} しようとすれば"locking can only be used on shared values" （ロックは共有変数に対してのみ使用できる）というエラーが発生する。

作者¶

Arthur Bergman <arthur at contiller.se>

threads::shared is released under the same license as Perl

Documentation borrowed from the old Thread.pm

参考¶

threads, perlthrtut, http://www.perl.com/pub/a/2002/06/11/threads.html