名前¶

threads::shared - Perl extension for sharing data structures between threads

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_broadcast(@array);
  cond_signal(%hash);

説明¶

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モジュールと一緒に使う。

EXPORT¶

share, lock, cond_wait, 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.

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

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を使うだけなら、可能な限り早くロックを解除すること）。 変数のロック解除と、ブロックされて待ち状態に入るという二つの動作は、アトミックである。待ち状態から抜けることと、変数への再ロックという二つの動作は、アトミックではない。

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.

どのスレッドも変数に対しcond_signalやcond_broadcastをしなくても、その変数はnotifyされうるということに注意することが大切だ。 それゆえ、変数の値のチェックと、要求が満たされない場合に待ち状態に戻ることが重要である。

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

SEE ALSO¶

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