"threading" --- スレッドベースの並列処理
****************************************

**ソースコード:** Lib/threading.py

======================================================================

このモジュールでは、高水準のスレッドインターフェースをより低水準 な
"_thread" モジュールの上に構築しています。

利用可能な環境: not WASI.

このモジュールは WebAssembly では動作しないか、利用不可です。詳しくは
、WebAssembly プラットフォーム を見てください。


はじめに
========

"threading" モジュールを使うと、1 つのプロセス内で複数の スレッド (プ
ロセスより小さな実行単位) を並行して実行できます。 スレッドの作成と管
理ができ、メモリ空間を共有しながらタスクを並列に実行できます。 スレッ
ドは、ファイル操作やネットワークリクエストなど、外部リソースを待つ時間
が大部分を占める I/O バウンドのタスクで特に役立ちます。

"threading" の典型的な用途には、複数のタスクを並行して処理するワーカー
スレッドのプールの管理があります。 以下は "Thread" を使ってスレッドを
作成し、開始する基本的な例です。

   import threading
   import time

   def crawl(link, delay=3):
       print(f"crawl started for {link}")
       time.sleep(delay)  # ブロックする I/O (ネットワークリクエストを模擬)
       print(f"crawl ended for {link}")

   links = [
       "https://python.org",
       "https://docs.python.org",
       "https://peps.python.org",
   ]

   # 各リンクのスレッドを開始する
   threads = []
   for link in links:
       # 位置引数は args、キーワード引数は kwargs で渡す
       t = threading.Thread(target=crawl, args=(link,), kwargs={"delay": 2})
       threads.append(t)

   # 各スレッドを開始する
   for t in threads:
       t.start()

   # すべてのスレッドの終了を待つ
   for t in threads:
       t.join()

バージョン 3.7 で変更: このモジュールは以前はオプションでしたが、常に
利用可能なモジュールとなりました。

参考:

  "concurrent.futures.ThreadPoolExecutor" は、呼び出し側のスレッドをブ
  ロックせずにバックグラウンドのスレッドへタスクを渡し、必要なときに結
  果を取得できる、より高水準のインターフェースを提供します。

  "queue" は、実行中のスレッド間でデータを交換するためのスレッドセーフ
  なインターフェースを提供します。

  "asyncio" は、オペレーティングシステムのスレッドを複数使わずに、タス
  クレベルの並行処理を実現する別の方法を提供します。

注釈:

  Python 2.x 系では、このモジュールの一部のメソッドや関数に
  "camelCase" 形式の名前がありました。 これらは Python 3.10 以降では非
  推奨ですが、Python 2.5 以前との互換性のため、引き続きサポートされて
  います。

CPython は *Global Interpreter Lock* のため、ある時点で Python コード
を実行できるスレッドは1つに限られます (ただし、いくつかのパフォーマン
スが強く求められるライブラリはこの制限を克服しています)。アプリケーシ
ョンにマルチコアマシンの計算能力をより良く利用させたい場合は、
"multiprocessing" モジュールや
"concurrent.futures.ProcessPoolExecutor" の利用をお勧めします。 ただし
、I/Oバウンドなタスクを並行して複数走らせたい場合においては、 マルチス
レッドは正しい選択肢です。


GIL とパフォーマンスに関する考慮事項
====================================

別々のプロセスを使って *グローバルインタープリタロック* (GIL) を回避す
る "multiprocessing" モジュールとは異なり、threading モジュールは 1 つ
のプロセス内で動作するため、すべてのスレッドが同じメモリ空間を共有しま
す。 ただし、一度に Python バイトコードを実行できるのは 1 つのスレッド
だけなので、CPU バウンドのタスクでは GIL によってスレッドによる性能向
上が制限されます。 それでも、多くの場面でスレッドは並行処理を実現する
有用な手段です。

Python 3.13 以降では、*フリースレッド* ビルドで GIL を無効にし、スレッ
ドを真に並列に実行できます。 ただし、この機能はデフォルトでは利用でき
ません (**PEP 703** を参照)。


リファレンス
============

このモジュールは以下の関数を定義しています:

threading.active_count()

   生存中の "Thread" オブジェクトの数を返します。この数は
   "enumerate()" の返すリストの長さと同じです。

   関数 "activeCount" はこの関数の非推奨エイリアスです。

threading.current_thread()

   呼び出し元の実行スレッドに対応する、現在の "Thread" オブジェクトを
   返します。 呼び出し元のスレッドが "threading" モジュールを使って作
   成されたものでなければ、機能が制限されたダミーのスレッドオブジェク
   トを返します。

   関数 "currentThread" はこの関数の非推奨エイリアスです。

threading.excepthook(args, /)

   "Thread.run()" で発生したキャッチされない例外を処理する。

   (実) 引数*args*は以下の属性をもちます:

   * *exc_type*: 例外の型

   * *exc_value*: 例外の値、"None" の可能性がある。

   * *exc_traceback*: 例外のトレースバック。 "None" の場合もあります。

   * *thread*: 例外を送出したスレッド。 "None" の場合もあります。

   *exc_type* が "SystemExit" の場合は、何も表示せずに例外を無視します
   。 それ以外の場合は、"sys.stderr" に例外を出力します。

   この関数が例外を送出した場合は、その例外を処理するために
   "sys.excepthook()" が呼び出されます。

   "threading.excepthook()" を置き換えることで、"Thread.run()" から送
   出されて捕捉されなかった例外の処理方法を制御できます。

   独自のフックで *exc_value* を保存すると、循環参照ができることがあり
   ます。 例外が不要になったときに明示的に消去して、循環参照を断ち切っ
   てください。

   独自のフックで *thread* を保存した際、その値がファイナライズ中のオ
   ブジェクトである場合は、そのオブジェクトを復活させる可能性がありま
   す。 オブジェクトの復活を避けるため、独自のフックの完了後まで
   *thread* を保存しないでください。

   参考: "sys.excepthook()" は捕捉されなかった例外を処理します。

   Added in version 3.8.

threading.__excepthook__

   "threading.excepthook()" の元の値を保持します。 壊れたオブジェクト
   や別のオブジェクトに置き換えられた場合に元の値を復元できるよう、保
   存されています。

   Added in version 3.10.

threading.get_ident()

   現在のスレッドの 'スレッドID' を返します。非ゼロの整数です。この値
   は直接の意味を持っていません; 例えばスレッド特有のデータの辞書に索
   引をつけるためのような、マジッククッキーとして意図されています。ス
   レッドが終了し、他のスレッドが作られたとき、スレッド ID は再利用さ
   れるかもしれません。

   Added in version 3.3.

threading.get_native_id()

   カーネルが割り当てた、現在のスレッドのネイティブなスレッド ID を返
   します。 これは非負の整数です。 この値で、システム全体においてこの
   スレッドを一意に識別できます (スレッドが終了するまでで、その後は OS
   が値を再利用することがあります)。

   利用可能な環境: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD,
   AIX, DragonFlyBSD, GNU/kFreeBSD, Solaris.

   Added in version 3.8.

   バージョン 3.13 で変更: GNU/kFreeBSD のサポートが追加されました。

   バージョン 3.15 で変更: Solaris のサポートが追加されました。

threading.enumerate()

   現在、アクティブな "Thread" オブジェクト全てのリストを返します。リ
   ストには、デーモンスレッド (daemonic thread)、 "current_thread()"
   の生成するダミースレッドオブジェクトが入ります。終了したスレッドと
   まだ開始していないスレッドは入りません。しかし、主スレッドは、たと
   え終了しても、常に結果に含まれます。

threading.main_thread()

   main "Thread" オブジェクトを返します。通常の条件では、メインスレッ
   ドはPythonインタプリタが起動したスレッドを指します。

   Added in version 3.4.

threading.settrace(func)

   "threading" モジュールから開始するすべてのスレッドにトレース関数を
   設定します。 各スレッドの "run()" メソッドが呼ばれる前に、*func* が
   "sys.settrace()" に渡されます。

threading.settrace_all_threads(func)

   "threading" モジュールから開始するすべてのスレッドと、現在実行中の
   すべての Python スレッドにトレース関数を設定します。

   The *func* will be passed to  "sys.settrace()" for each thread,
   before its "run()" method is called.

   Added in version 3.12.

threading.gettrace()

   "settrace()" 関数で設定したトレース関数を取得します。

   Added in version 3.10.

threading.setprofile(func)

   "threading" モジュールから開始するすべてのスレッドにプロファイル関
   数を設定します。 各スレッドの "run()" メソッドが呼ばれる前に、
   *func* が "sys.setprofile()" に渡されます。

threading.setprofile_all_threads(func)

   "threading" モジュールから開始するすべてのスレッドと、現在実行中の
   すべての Python スレッドにプロファイル関数を設定します。

   The *func* will be passed to  "sys.setprofile()" for each thread,
   before its "run()" method is called.

   Added in version 3.12.

threading.getprofile()

   "setprofile()" 関数で設定したプロファイラ関数を取得します。

   Added in version 3.10.

threading.stack_size([size])

   新しいスレッドを作るときのスレッドスタックサイズを返します。オプシ
   ョンの *size* 引数にはこれ以降に作成するスレッドのスタックサイズを
   指定し、0 (プラットフォームのデフォルト値または設定されたデフォルト
   値) か、 32,768 (32 KiB) 以上の正の整数でなければなりません。*size*
   が指定されない場合 0 が使われます。スレッドのスタックサイズの変更が
   サポートされていない場合、 "RuntimeError" を送出します。不正なスタ
   ックサイズが指定された場合、 "ValueError" を送出して、スタックサイ
   ズは変更されません。32 KiB は現在のインタープリタ自身のために十分で
   あると保証された最小のスタックサイズです。いくつかのプラットフォー
   ムではスタックサイズに対して制限があることに注意してください。例え
   ば最小のスタックサイズが 32 KiB より大きかったり、システムのメモリ
   ページサイズ の整数倍の必要があるなどです。この制限についてはプラッ
   トフォームのドキュメントを参照してください (一般的なページサイズは
   4 KiB なので、プラットフォームに関する情報がない場合は 4096 の整数
   倍のスタックサイズを選ぶといいかもしれません)。

   利用可能な環境: Windows, pthreads.

   POSIX スレッドをサポートする Unix プラットフォーム。

このモジュールでは以下の定数も定義しています:

threading.TIMEOUT_MAX

   ブロックする関数 ("Lock.acquire()"、"RLock.acquire()"、
   "Condition.wait()" など) の *timeout* 引数に指定できる最大値です。
   この値を超えるタイムアウトを指定すると "OverflowError" が送出されま
   す。

   Added in version 3.2.

このモジュールは多くのクラスを定義しています。それらは下記のセクション
で詳しく説明されます。

このモジュールのおおまかな設計は Java のスレッドモデルに基づいています
。とはいえ、 Java がロックと条件変数を全てのオブジェクトの基本的な挙動
にしているのに対し、 Python ではこれらを別個のオブジェクトに分けていま
す。 Python の "Thread" クラスがサポートしているのは Java の Thread ク
ラスの挙動のサブセットにすぎません; 現状では、優先度 (priority)やスレ
ッドグループがなく、スレッドの破壊 (destroy)、中断 (stop)、一時停止
(suspend)、復帰 (resume)、割り込み (interrupt) は行えません。 Java の
Thread クラスにおける静的メソッドに対応する機能が実装されている場合に
はモジュールレベルの関数になっています。

以下に説明するメソッドは全て原子的 (atomic) に実行されます。


スレッドローカルデータ
----------------------

スレッドローカルデータは、スレッドごとに固有の値を持つデータです。 ス
レッド内だけで使いたいデータがある場合は、"local" オブジェクトを作成し
、その属性を使ってください。

   >>> mydata = local()
   >>> mydata.number = 42
   >>> mydata.number
   42

"local" オブジェクトの辞書にもアクセスできます。

   >>> mydata.__dict__
   {'number': 42}
   >>> mydata.__dict__.setdefault('widgets', [])
   []
   >>> mydata.widgets
   []

別のスレッドからデータにアクセスすると、次のようになります。

   >>> log = []
   >>> def f():
   ...     items = sorted(mydata.__dict__.items())
   ...     log.append(items)
   ...     mydata.number = 11
   ...     log.append(mydata.number)

   >>> import threading
   >>> thread = threading.Thread(target=f)
   >>> thread.start()
   >>> thread.join()
   >>> log
   [[], 11]

異なるデータが得られます。 また、別のスレッドで変更しても、このスレッ
ドから見えるデータには影響しません。

   >>> mydata.number
   42

"__dict__" 属性を含め、"local" オブジェクトから取得した値は、その属性
を読み出したときのスレッドのものです。 値は取得元のスレッドだけに属す
るため、一般にはスレッドをまたいで保存しない方がよいでしょう。

"local" クラスを継承して、独自の "local" オブジェクトを作成できます。

   >>> class MyLocal(local):
   ...     number = 2
   ...     def __init__(self, /, **kw):
   ...         self.__dict__.update(kw)
   ...     def squared(self):
   ...         return self.number ** 2

これはデフォルト値、メソッド、初期化をサポートするのに便利です。
"__init__()" メソッドを定義すると、各スレッドで "local" オブジェクトを
初めて使うときに呼び出されることに注意してください。 各スレッドの辞書
を初期化するために必要な動作です。

この "local" オブジェクトを作成すると、次のようになります。

   >>> mydata = MyLocal(color='red')

"number" にはデフォルト値があります。

   >>> mydata.number
   2

"color" には初期値があります。

   >>> mydata.color
   'red'
   >>> del mydata.color

データを操作するメソッドもあります。

   >>> mydata.squared()
   4

先ほどと同じように、別のスレッドからデータにアクセスできます。

   >>> log = []
   >>> thread = threading.Thread(target=f)
   >>> thread.start()
   >>> thread.join()
   >>> log
   [[('color', 'red')], 11]

このスレッドのデータには影響しません。

   >>> mydata.number
   2
   >>> mydata.color
   Traceback (most recent call last):
   ...
   AttributeError: 'MyLocal' object has no attribute 'color'

サブクラスでは *__slots__* を定義できますが、スロットはスレッドローカ
ルではありません。 スレッド間で共有されます。

   >>> class MyLocal(local):
   ...     __slots__ = 'number'

   >>> mydata = MyLocal()
   >>> mydata.number = 42
   >>> mydata.color = 'red'

そのため、別のスレッドを実行すると、次のようになります。

   >>> thread = threading.Thread(target=f)
   >>> thread.start()
   >>> thread.join()

このスレッドから見える値にも影響します。

   >>> mydata.number
   11

class threading.local

   スレッドローカルデータを表現するクラス。


Thread オブジェクト
-------------------

"Thread" クラスは、別の実行スレッドで行う処理を表します。 処理を指定す
る方法は 2 つあります。 呼び出し可能オブジェクトをコンストラクタに渡す
か、サブクラスで "run()" メソッドをオーバーライドします。 サブクラスで
は、コンストラクタを除く他のメソッドをオーバーライドしてはいけません。
つまり、このクラスの "__init__()" と "run()" メソッド *だけ* をオーバ
ーライドしてください。

ひとたびスレッドオブジェクトを生成すると、スレッドの "start()" メソッ
ドを呼び出して活動を開始しなければなりません。 これにより、別のスレッ
ドでそのオブジェクトの "run()" メソッドが呼び出されます。

スレッドの活動が始まると、スレッドは '生存中 (alive)' とみなされます。
スレッドは、通常 "run()" メソッドが終了するまで、もしくは捕捉されない
例外が送出されるまで生存中となります。 "is_alive()" メソッドは、スレッ
ドが生存中であるかどうか調べます。

スレッドは他のスレッドの "join()" メソッドを呼び出すことができます。こ
のメソッドは、 "join()" メソッドを呼ばれたスレッドが終了するまでメソッ
ドの呼び出し元のスレッドをブロックします。

スレッドは名前を持っています。名前はコンストラクタに渡すことができ、
"name" 属性を通して読み出したり変更したりできます。

"run()" メソッドが例外を発生させた場合、"threading.excepthook()" が呼
び出され、例外を処理します。デフォルトでは、"threading.excepthook()"
は "SystemExit" を黙殺します。

スレッドには "デーモンスレッド (daemon thread)" であるというフラグを立
てられます。 このフラグには、残っているスレッドがデーモンスレッドだけ
になった時に Python プログラム全体を終了させるという意味があります。フ
ラグの初期値はスレッドを生成したスレッドから継承します。フラグの値は
"daemon" プロパティまたは *daemon* コンストラクタ引数を通して設定でき
ます。

注釈:

  デーモンスレッドは終了時にいきなり停止されます。デーモンスレッドで使
  われたリソース (開いているファイル、データベースのトランザクションな
  ど) は適切に解放されないかもしれません。きちんと (gracefully) スレッ
  ドを停止したい場合は、スレッドを非デーモンスレッドにして、"Event" の
  ような適切なシグナル送信機構を使用してください。

スレッドには "主スレッド (main thread)" オブジェクトがあります。主スレ
ッドは Python プログラムを最初に制御していたスレッドです。主スレッドは
デーモンスレッドではありません。

"ダミースレッドオブジェクト (dummy thread objects)" が作成される場合が
あります。ダミースレッドは、 "外来スレッド (alien thread)" に相当する
スレッドオブジェクトです。ダミースレッドは、C コードから直接生成された
スレッドのような、 "threading" モジュールの外で開始された処理スレッド
です。ダミースレッドオブジェクトには限られた機能しかなく、常に生存中、
かつデーモンスレッドであるとみなされ、 join できません。また、外来スレ
ッドの終了を検出するのは不可能なので、ダミースレッドは削除できません。

class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None, context=None)

   コンストラクタは常にキーワード引数を使って呼び出さなければなりませ
   ん。各引数は以下の通りです:

   *group* は "ThreadGroup" クラスが実装されたときの将来の拡張用に予約
   されているため、"None" でなければなりません。

   *target* は "run()" メソッドによって起動される呼び出し可能オブジェ
   クトです。デフォルトでは何も呼び出さないことを示す "None" になって
   います。

   *name*はスレッド名です。デフォルトでは、"Thread-*N*"(*N*は小さな10
   進数)、または*target*引数が指定された場合"Thread-*N*
   (target)"("target"は "target.__name__")という形式でユニークな名前が
   構成される。

   *args* は *target* を呼び出すときの引数のリストかタプルです。デフォ
   ルトは "()" です。

   *kwargs* は *target* を呼び出すときのキーワード引数の辞書です。デフ
   ォルトは "{}" です。

   "None" でない場合、*daemon* はスレッドがデーモンかどうかを明示的に
   設定します。"None" の場合 (デフォルト)、デーモン属性は現在のスレッ
   ドから継承されます。

   *context* はスレッドの開始時に使う "Context" の値です。 デフォルト
   値は "None" で、"sys.flags.thread_inherit_context" フラグが動作を制
   御します。 フラグが真の場合、スレッドは "start()" の呼び出し元のコ
   ンテキストのコピーで開始します。 偽の場合は空のコンテキストで開始し
   ます。 空のコンテキストで開始することを明示するには、新しい
   "Context()" インスタンスを渡してください。 現在のコンテキストのコピ
   ーで開始することを明示するには、"copy_context()" の戻り値を渡してく
   ださい。 このフラグのデフォルトは、フリースレッドビルドでは真、それ
   以外では偽です。

   サブクラスでコンストラクタをオーバーライドする場合は、そのスレッド
   オブジェクトに対して他の処理を行う前に、必ず基底クラスのコンストラ
   クタ ("Thread.__init__()") を呼び出してください。

   バージョン 3.3 で変更: *daemon* 引数が追加されました。

   バージョン 3.10 で変更: *name* 引数が省略された場合、*target* 名を
   使用します。

   バージョン 3.14 で変更: *context* パラメータを追加しました。

   start()

      スレッドの活動を開始します。

      このメソッドは、スレッドオブジェクトあたり一度しか呼び出してはな
      りません。 "start()" は、オブジェクトの "run()" メソッドが個別の
      処理スレッド中で呼び出されるように調整します。

      同じスレッドオブジェクトに対し、このメソッドを2回以上呼び出した
      場合、 "RuntimeError" を送出します。

      サポートされている場合、オペレーティングシステム上のスレッド名を
      "threading.Thread.name" に設定します。 名前は、オペレーティング
      システムのスレッド名の長さ制限に応じて切り詰められることがありま
      す。

      バージョン 3.14 で変更: オペレーティングシステム上のスレッド名を
      設定するようになりました。

   run()

      スレッドの活動をもたらすメソッドです。

      このメソッドはサブクラスでオーバライドできます。標準の "run()"
      メソッドでは、オブジェクトのコンストラクタの *target* 引数に呼び
      出し可能オブジェクトを指定した場合、 *args* および *kwargs* の位
      置引数およびキーワード引数とともに呼び出します。

      "Thread" に渡される *args* の引数にリストやタプルを使っても、同
      じ効果が得られます。

      以下はプログラム例です:

         >>> from threading import Thread
         >>> t = Thread(target=print, args=[1])
         >>> t.run()
         1
         >>> t = Thread(target=print, args=(1,))
         >>> t.run()
         1

   join(timeout=None)

      スレッドが終了するまで待機します。 このメソッドは、 "join()" を
      呼ばれたスレッドが正常終了あるいは処理されない例外によって終了す
      るか、オプションのタイムアウトが発生するまで、メソッドの呼び出し
      元のスレッドをブロックします。

      *timeout* 引数を指定し、その値が "None" でない場合は、操作のタイ
      ムアウトを秒単位で表す実数 (小数も可) にしてください。 "join()"
      は常に "None" を返すため、タイムアウトしたかどうかは "join()" の
      後に "is_alive()" を呼び出して判断する必要があります。 スレッド
      がまだ生存していれば、"join()" はタイムアウトしています。

      *timeout* が指定されないかまたは "None" であるときは、この操作は
      スレッドが終了するまでブロックします。

      1つのスレッドは何回も join されることができます。

      現在のスレッドに対して "join()" を呼び出そうとすると、デッドロッ
      クを引き起こすため "RuntimeError" が送出されます。 スレッドが開
      始される前に "join()" を呼び出すことも同様のエラーのため、同じ例
      外が送出されます。

      *Python のファイナライズ* の最終段階で、実行中のデーモンスレッド
      を join しようとすると、"join()" は "PythonFinalizationError" を
      送出します。

      バージョン 3.14 で変更: "PythonFinalizationError" を送出する場合
      があります。

      バージョン 3.15 で変更: *timeout* に、整数と浮動小数点数だけでな
      く任意の実数を受け付けるようになりました。

   name

      識別のためにのみ用いられる文字列です。名前には機能上の意味づけ
      (semantics) はありません。複数のスレッドに同じ名前をつけてもかま
      いません。名前の初期値はコンストラクタで設定されます。

      一部のプラットフォームでは、スレッドの開始時にオペレーティングシ
      ステム上のスレッド名も設定され、タスクマネージャに表示されます。
      この名前は、システム固有の制限 (例えば Linux では 15 バイト、
      macOS では 63 バイト) に収まるように切り詰められることがあります
      。

      *name* の変更が OS に反映されるのは、現在実行しているスレッド自
      身の名前を変更した場合だけです。 別のスレッドの *name* 属性を設
      定しても、Python の Thread オブジェクトだけが更新されます。

   getName()
   setName()

      "name" に対する非推奨 getter/setter API; 代わりにプロパティを直
      接使用してください。

      バージョン 3.10 で非推奨.

   ident

      'スレッド識別子' 、または、スレッドが開始されていなければ "None"
      です。非ゼロの整数です。 "get_ident()" 関数を参照下さい。スレッ
      ド識別子は、スレッドが終了した後、新たなスレッドが生成された場合
      、再利用され得ます。スレッド識別子は、スレッドが終了した後でも利
      用できます。

   native_id

      OS (カーネル) が割り当てた、このスレッドのスレッド ID ("TID") で
      す。 非負の整数で、スレッドがまだ開始されていない場合は "None"
      です。 "get_native_id()" を参照してください。 この値で、システム
      全体においてこのスレッドを一意に識別できます (スレッドが終了する
      までで、その後は OS が値を再利用することがあります)。

      注釈:

        プロセス ID と同様に、スレッド ID が有効である (システム全体で
        一意であると保証される) のは、スレッドが作成されてから終了する
        までの間だけです。

      利用可能な環境: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD,
      AIX, DragonFlyBSD.

      Added in version 3.8.

   is_alive()

      スレッドが生存中かどうかを返します。

      このメソッドは、 "run()" メソッドが起動する直前から "run()" メソ
      ッドが終了する直後までの間 "True" を返します。モジュール関数
      "enumerate()" は、全ての生存中のスレッドのリストを返します。

   daemon

      このスレッドがデーモンスレッドか ("True") か否か ("False") を示
      すブール値。この値は "start()" の呼び出し前に設定されなければな
      りません。さもなければ "RuntimeError" が送出されます。初期値は生
      成側のスレッドから継承されます; メインスレッドはデーモンスレッド
      ではないので、メインスレッドで作成されたすべてのスレッドは、デフ
      ォルトで "daemon" = "False" になります。

      デーモンでない生存中のスレッドが全てなくなると、 Python プログラ
      ム全体が終了します。

   isDaemon()
   setDaemon()

      "daemon" に対する非推奨 getter/setter API; 代わりにプロパティを
      直接使用してください。

      バージョン 3.10 で非推奨.


Lock オブジェクト
-----------------

プリミティブロックとは、ロックが生じた際に特定のスレッドによって所有さ
れない同期プリミティブです。 Python では現在のところ拡張モジュール
"_thread" で直接実装されている最も低水準の同期プリミティブを使えます。

プリミティブロックは2つの状態、 "ロック" または "アンロック" がありま
す。ロックはアンロック状態で作成されます。ロックには基本となる二つのメ
ソッド、 "acquire()" と "release()" があります。ロックの状態がアンロッ
クである場合、 "acquire()" は状態をロックに変更して即座に処理を戻しま
す。 状態がロックの場合、 "acquire()" は他のスレッドが "release()" を
呼び出してロックの状態をアンロックに変更するまでブロックします。その後
、 "acquire()" 呼び出しは状態を再度ロックに設定してから処理を戻します
。 "release()" メソッドを呼び出すのはロック状態のときでなければなりま
せん; このメソッドはロックの状態をアンロックに変更して、即座に処理を戻
します。 アンロックの状態のロックを解放しようとすると "RuntimeError"
が送出されます。

ロックは コンテキストマネージメントプロトコル もサポートします。

複数のスレッドにおいて "acquire()" がアンロック状態への遷移を待ってい
るためにブロックが起きている時に "release()" を呼び出してロックの状態
をアンロックにすると、一つのスレッドだけが処理を進行できます。 どのス
レッドが処理を進行できるのかは定義されておらず、実装によって異なるかも
しれません。

全てのメソッドはアトミックに実行されます。

class threading.Lock

   プリミティブロック (primitive lock) オブジェクトを実装しているクラ
   スです。スレッドが一度ロックを獲得すると、それ以後のロック獲得の試
   みはロックが解放されるまでブロックします。どのスレッドでもロックを
   解放できます。

   バージョン 3.13 で変更: "Lock" はクラスになりました。 以前の Python
   では、"Lock" は内部の非公開ロック型のインスタンスを返すファクトリ関
   数でした。

   acquire(blocking=True, timeout=-1)

      ブロックあり、またはブロックなしでロックを獲得します。

      引数 *blocking* を "True" (デフォルト) に設定して呼び出した場合
      、ロックがアンロック状態になるまでブロックします。そしてそれをロ
      ック状態にしてから "True" を返します。

      引数 *blocking* の値を "False" にして呼び出すとブロックしません
      。*blocking* を "True" にして呼び出した場合にブロックするような
      状況では、直ちに "False" を返します。それ以外の場合には、ロック
      をロック状態にして "True" を返します。

      *timeout* 引数に正の値を指定して呼び出すと、ロックを獲得できない
      間、最大で *timeout* 秒間ブロックします。 *timeout* に "-1" を指
      定すると、時間の制限なく待機します。 *blocking* が "False" の場
      合に *timeout* を指定することは禁止されています。

      ロックを獲得すると "True" を、ロックを獲得できなかったとき (例え
      ば *timeout* が過ぎた場合) には "False" を返します。

      バージョン 3.2 で変更: 新しい *timeout* 引数。

      バージョン 3.2 で変更: POSIX で、内部のスレッド実装がサポートし
      ていれば、ロックの獲得をシグナルで中断できるようになりました。

      バージョン 3.14 で変更: Windows でロックの獲得をシグナルで中断で
      きるようになりました。

      バージョン 3.15 で変更: *timeout* に、整数と浮動小数点数だけでな
      く任意の実数を受け付けるようになりました。

   release()

      ロックを解放します。これはロックを獲得したスレッドだけでなく、任
      意のスレッドから呼ぶことができます。

      ロックの状態がロックのとき、状態をアンロックにリセットして処理を
      戻します。他のスレッドがロックがアンロック状態になるのを待ってブ
      ロックしている場合、ただ一つのスレッドだけが処理を継続できるよう
      にします。

      アンロック状態のロックに対して呼び出された場合、"RuntimeError"
      が送出されます。

      戻り値はありません。

   locked()

      ロック状態のとき "True" を返します。


RLock オブジェクト
------------------

再入可能ロック (reentrant lock) とは、同じスレッドが複数回獲得できるよ
うな同期プリミティブです。再入可能ロックの内部では、プリミティブロック
の使うロック／アンロック状態に加え、 "所有スレッド (owning thread)" と
"再帰レベル (recursion level)" という概念を用いています。ロック状態で
は何らかのスレッドがロックを所有しており、アンロック状態ではいかなるス
レッドもロックを所有していません。

Threads call a lock's "acquire()" method to lock it, and its
"release()" method to unlock it.

注釈:

  再入可能ロックは コンテキスト管理プロトコル をサポートしています。
  そのため、コードブロックでのロックの獲得と解放には、"acquire()" と
  "release()" を手動で呼び出すよりも "with" を使うことを推奨します。

RLock's "acquire()"/"release()" call pairs may be nested, unlike
Lock's "acquire()"/"release()". Only the final "release()" (the
"release()" of the outermost pair) resets the lock to an unlocked
state and allows another thread blocked in "acquire()" to proceed.

"acquire()" と "release()" は対にして使わなければなりません。 ロックを
獲得するたびに、獲得したスレッドで解放する必要があります。 獲得した回
数と同じ回数だけ解放しないと、デッドロックにつながる可能性があります。

class threading.RLock

   このクラスは再入可能ロックオブジェクトを実装します。再入可能ロック
   はそれを獲得したスレッドによって解放されなければなりません。いった
   んスレッドが再入可能ロックを獲得すると、同じスレッドはブロックされ
   ずにもう一度それを獲得できます ; そのスレッドは獲得した回数だけ解放
   しなければいけません。

   "RLock" は実際にはファクトリ関数で、プラットフォームでサポートされ
   る最も効率的なバージョンの具体的な RLock クラスのインスタンスを返す
   ことに注意してください。

   acquire(blocking=True, timeout=-1)

      ブロックあり、またはブロックなしでロックを獲得します。

      参考:

        RLock をコンテキストマネージャとして使う
           実用上可能なら、"acquire()" と "release()" を手動で呼び出す
           よりも推奨されます。

      *blocking* 引数を "True" (デフォルト) にして呼び出した場合:

         * どのスレッドもロックを所有していなければ、ロックを獲得して
           直ちに戻ります。

         * 別のスレッドがロックを所有している場合は、ロックを獲得でき
           るようになるまでブロックします。 *timeout* に正の値が指定さ
           れていれば、その時間が経過した場合にも待機を終了します。

         * 同じスレッドがロックを所有している場合は、再びロックを獲得
           して直ちに戻ります。 この点が "Lock" と "RLock" の違いです
           。 "Lock" はこの場合も前項と同様に扱い、ロックを獲得できる
           までブロックします。

      *blocking* 引数を "False" にして呼び出した場合:

         * どのスレッドもロックを所有していなければ、ロックを獲得して
           直ちに戻ります。

         * 別のスレッドがロックを所有している場合は、直ちに戻ります。

         * 同じスレッドがロックを所有している場合は、再びロックを獲得
           して直ちに戻ります。

      いずれの場合も、スレッドがロックを獲得できれば "True" を返します
      。 獲得できなければ (ブロックしない場合やタイムアウトに達した場
      合など)、"False" を返します。

      複数回呼び出した場合、同じ回数だけ "release()" を呼び出さないと
      、デッドロックにつながる可能性があります。 acquire/release を直
      接呼び出す代わりに、"RLock" をコンテキストマネージャとして使うこ
      とを検討してください。

      バージョン 3.2 で変更: 新しい *timeout* 引数。

      バージョン 3.15 で変更: *timeout* に、整数と浮動小数点数だけでな
      く任意の実数を受け付けるようになりました。

   release()

      再帰レベルをデクリメントしてロックを解放します。デクリメント後に
      再帰レベルがゼロになった場合、ロックの状態をアンロック (いかなる
      スレッドにも所有されていない状態) にリセットし、ロックの状態がア
      ンロックになるのを待ってブロックしているスレッドがある場合にはそ
      の中のただ一つだけが処理を進行できるようにします。デクリメント後
      も再帰レベルがゼロでない場合、ロックの状態はロックのままで、呼び
      出し側のスレッドに所有されたままになります。

      このメソッドは、呼び出し元のスレッドがロックを所有している場合に
      だけ呼び出してください。 ロックを獲得していないときに呼び出すと
      、"RuntimeError" を送出します。

      戻り値はありません。

   locked()

      このオブジェクトが現在ロックされているかどうかを示すブール値を返
      します。

      Added in version 3.14.


Condition オブジェクト
----------------------

条件変数 (condition variable) は、常にある種のロックに関連付けられてい
ます; このロックは明示的に渡すことも、デフォルトで生成させることもでき
ます。複数の条件変数で同じロックを共有しなければならない場合には、引渡
しによる関連付けが便利です。ロックは条件オブジェクトの一部です: それを
別々に扱う必要はありません。

条件変数は コンテキスト管理プロトコル に従います: "with" 文を使って囲
まれたブロックの間だけ関連付けられたロックを獲得することができます。
"acquire()" メソッドと "release()" メソッドは、さらに関連付けられたロ
ックの対応するメソッドを呼び出します。

他のメソッドは、関連付けられたロックを保持した状態で呼び出さなければな
りません。 "wait()" メソッドはロックを解放します。そして別のスレッドが
"notify()" または "notify_all()" を呼ぶことによってスレッドを起こすま
でブロックします。一旦起こされたなら、 "wait()" は再びロックを得て戻り
ます。タイムアウトを指定することも可能です。

"notify()" メソッドは条件変数待ちのスレッドを1つ起こします。
"notify_all()" メソッドは条件変数待ちの全てのスレッドを起こします。

注意: "notify()" と "notify_all()" はロックを解放しません; 従って、ス
レッドが起こされたとき、 "wait()" の呼び出しは即座に処理を戻すわけでは
なく、 "notify()" または "notify_all()" を呼び出したスレッドが最終的に
ロックの所有権を放棄したときに初めて処理を返すのです。

条件変数を使う典型的なプログラミングスタイルでは、何らかの共有された状
態変数へのアクセスを同期させるためにロックを使います; 状態変数が特定の
状態に変化したことを知りたいスレッドは、自分の望む状態になるまで繰り返
し "wait()" を呼び出します。その一方で、状態変更を行うスレッドは、前者
のスレッドが待ち望んでいる状態であるかもしれないような状態へ変更を行っ
たときに "notify()" や "notify_all()" を呼び出します。例えば、以下のコ
ードは無制限のバッファ容量のときの一般的な生産者-消費者問題です:

   # 要素を 1 つ消費する
   with cv:
       while not an_item_is_available():
           cv.wait()
       get_an_available_item()

   # 要素を 1 つ生成する
   with cv:
       make_an_item_available()
       cv.notify()

アプリケーションの条件をチェックする "while" ループは必須です。なぜな
ら、 "wait()" が任意の長時間の後で返り、 "notify()" 呼び出しを促した条
件がもはや真でないことがありえるからです。これはマルチスレッドプログラ
ミングに固有です。条件チェックを自動化するために "wait_for()" メソッド
を使うことができ、それはタイムアウトの計算を簡略化します:

   # 要素を 1 つ消費する
   with cv:
       cv.wait_for(an_item_is_available)
       get_an_available_item()

"notify()" と "notify_all()" のどちらを使うかは、その状態の変化に興味
を持っている待ちスレッドが一つだけなのか、あるいは複数なのかで考えます
。例えば、典型的な生産者-消費者問題では、バッファに1つの要素を加えた場
合には消費者スレッドを 1 つしか起こさなくてかまいません。

class threading.Condition(lock=None)

   このクラスは条件変数 (condition variable) オブジェクトを実装します
   。条件変数を使うと、1つ以上のスレッドを別のスレッドの通知があるまで
   待機させておけます。

   *lock* に "None" でない値を指定した場合、その値は "Lock" または
   "RLock" オブジェクトでなければなりません。 この場合、 *lock* は根底
   にあるロックオブジェクトとして使われます。 それ以外の場合には、
   "RLock" オブジェクトを新しく作成して使います。

   バージョン 3.3 で変更: ファクトリ関数からクラスに変更されました。

   acquire(*args)

      根底にあるロックを獲得します。このメソッドは根底にあるロックの対
      応するメソッドを呼び出します。そのメソッドの戻り値を返します。

   release()

      根底にあるロックを解放します。このメソッドは根底にあるロックの対
      応するメソッドを呼び出します。戻り値はありません。

   locked()

      このオブジェクトが現在ロックされているかどうかを示すブール値を返
      します。

      Added in version 3.14.

   wait(timeout=None)

      通知 (notify) を受けるか、タイムアウトするまで待機します。呼び出
      し側のスレッドがロックを獲得していないときにこのメソッドを呼び出
      すと "RuntimeError" が送出されます。

      このメソッドは内部のロックを解放し、他のスレッドが同じ条件変数の
      "notify()" または "notify_all()" を呼び出して起こすか、指定され
      たタイムアウトが発生するまでブロックします。 起こされた場合もタ
      イムアウトした場合も、ロックを再び獲得してから戻ります。

      *timeout* 引数を指定し、その値が "None" でない場合は、操作のタイ
      ムアウトを秒単位で表す実数 (小数も可) にしてください。

      根底にあるロックが "RLock" である場合、 "release()" メソッドでは
      ロックは解放されません。というのも、ロックが再帰的に複数回獲得さ
      れている場合には、 "release()" によって実際にアンロックが行われ
      ないかもしれないからです。その代わり、ロックが再帰的に複数回獲得
      されていても確実にアンロックを行える "RLock" クラスの内部インタ
      ーフェースを使います。その後ロックを再獲得する時に、もう一つの内
      部インターフェースを使ってロックの再帰レベルを復帰します。

      与えられた *timeout* が過ぎていなければ返り値は "True" です。タ
      イムアウトした場合には "False" が返ります。

      バージョン 3.2 で変更: 以前は、このメソッドは常に "None" を返し
      ていました。

   wait_for(predicate, timeout=None)

      条件が真と判定されるまで待ちます。 *predicate* は呼び出し可能オ
      ブジェクトでなければならず、その結果はブール値として解釈されます
      。 最大の待ち時間を指定する *timeout* を与えることができます。

      このユーティリティメソッドは、述語が満たされるかタイムアウトが発
      生するまで "wait()" を繰り返し呼び出す場合があります。戻り値は述
      語の最後の戻り値で、もしメソッドがタイムアウトすれば、 "False"
      と評価されます。

      タイムアウト機能を無視すれば、このメソッドの呼び出しは以下のよう
      に書くのとほぼ等価です:

         while not predicate():
             cv.wait()

      したがって、 "wait()" と同じルールが適用されます: 呼び出された時
      にロックを保持していなければならず、戻るときにロックが再度獲得さ
      れます。述語はロックを保持した状態で評価されます。

      Added in version 3.2.

   notify(n=1)

      デフォルトで、この条件変数を待っている1つのスレッドを起こします
      。 呼び出し側のスレッドがロックを獲得していないときにこのメソッ
      ドを呼び出すと "RuntimeError" が送出されます。

      この条件変数を待っているスレッドを最大 *n* 個起こします。 待機中
      のスレッドがなければ何もしません。

      現在の実装では、少なくとも *n* スレッドが待機中であれば、ちょう
      ど *n* スレッドを起こします。 とはいえ、この挙動に依存するのは安
      全ではありません。 将来、実装の最適化によって、*n* 個を超えるス
      レッドを起こすことがあるかもしれないからです。

      注意: 起こされたスレッドは実際にロックを再獲得できるまで
      "wait()" 呼び出しから戻りません。 "notify()" はロックを解放しな
      いので、 "notify()" 呼び出し側は明示的にロックを解放しなければな
      りません。

   notify_all()

      この条件を待っているすべてのスレッドを起こします。このメソッドは
      "notify()" のように動作しますが、 1 つではなくすべての待ちスレッ
      ドを起こします。呼び出し側のスレッドがロックを獲得していない場合
      、 "RuntimeError" が送出されます。

      メソッド "notifyAll" は、このメソッドの非推奨エイリアスです。


Semaphore オブジェクト
----------------------

セマフォ (semaphore) は、計算機科学史上最も古い同期プリミティブの一つ
で、草創期のオランダ計算機科学者 Edsger W. Dijkstra によって発明されま
した (彼は "acquire()" と "release()" の代わりに "P()" と "V()" を使い
ました)。

セマフォは "acquire()" でデクリメントされ "release()" でインクリメント
されるような内部カウンタを管理します。 カウンタは決してゼロより小さく
はなりません; "acquire()" は、カウンタがゼロになっている場合、他のスレ
ッドが "release()" を呼び出すまでブロックします。

セマフォは コンテキストマネージメントプロトコル もサポートします。

class threading.Semaphore(value=1)

   このクラスはセマフォ (semaphore) オブジェクトを実装します。 セマフ
   ォは、"release()" を呼び出した回数から "acquire()" を呼び出した回数
   を引き、初期値を足した値を表すアトミックなカウンタを管理します。
   "acquire()" メソッドは、カウンタの値を負にせずに処理を戻せるまで、
   必要に応じてブロックします。 *value* を指定しない場合、デフォルトの
   値は 1 になります。

   オプションの引数には、内部カウンタの初期値を指定します。デフォルト
   は "1" です。与えられた *value* が 0 より小さい場合、 "ValueError"
   が送出されます。

   バージョン 3.3 で変更: ファクトリ関数からクラスに変更されました。

   acquire(blocking=True, timeout=None)

      セマフォを獲得します。

      引数なしで呼び出した場合:

      * 呼び出し時に内部カウンタが 0 より大きければ、1 減らして直ちに
        "True" を返します。

      * If the internal counter is zero on entry, block until awoken
        by a call to "release()".  Once awoken (and the counter is
        greater than 0), decrement the counter by 1 and return "True".
        Exactly one thread will be awoken by each call to "release()".
        The order in which threads are awoken should not be relied on.

      *blocking* を "False" にして呼び出すとブロックしません。引数なし
      で呼び出した場合にブロックするような状況であった場合には直ちに
      "False" を返します。それ以外の場合には、引数なしで呼び出したとき
      と同じ処理を行い "True" を返します。

      "None" 以外の *timeout* で起動された場合、最大で *timeout* 秒ブ
      ロックします。 acquire が その間隔の間で完了しなかった場合は
      "False" が返ります。そうでなければ "True" が返ります。

      バージョン 3.2 で変更: 新しい *timeout* 引数。

      バージョン 3.15 で変更: *timeout* に、整数と浮動小数点数だけでな
      く任意の実数を受け付けるようになりました。

   release(n=1)

      内部カウンタを *n* インクリメントして、セマフォを解放します。
      "release()" 処理に入ったときにカウンタがゼロであり、カウンタの値
      がゼロより大きくなるのを待っている別のスレッドがあった場合、それ
      らのスレッドから *n* 個を起こします。

      バージョン 3.9 で変更: 複数の待機中のスレッドを一度に解放する
      *n* パラメータを追加しました。

class threading.BoundedSemaphore(value=1)

   有限セマフォ (bounded semaphore) オブジェクトを実装しているクラスで
   す。 有限セマフォは、現在の値が初期値を超過しないようチェックを行い
   ます。 超過を起こした場合、 "ValueError" を送出します。 たいていの
   場合、セマフォは限られた容量のリソースを保護するために使われるもの
   です。 従って、セマフォを必要以上の回数解放することはバグが生じてい
   るしるしです。 *value* を指定しない場合、デフォルトの値は 1 になり
   ます。

   バージョン 3.3 で変更: ファクトリ関数からクラスに変更されました。


"Semaphore" の使用例
--------------------

セマフォはしばしば、容量に限りのある資源、例えばデータベースサーバなど
を保護するために使われます。リソースが固定の状況では、常に有限セマフォ
を使わなければなりません。主スレッドは、作業スレッドを立ち上げる前にセ
マフォを初期化します:

   maxconnections = 5
   # ...
   pool_sema = BoundedSemaphore(value=maxconnections)

作業スレッドは、ひとたび立ち上がると、サーバへ接続する必要が生じたとき
にセマフォの "acquire()" および "release()" メソッドを呼び出します:

   with pool_sema:
       conn = connectdb()
       try:
           # ... 接続を使う ...
       finally:
           conn.close()

有限セマフォを使うと、セマフォを獲得回数以上に解放してしまうというプロ
グラム上の間違いを見逃しにくくします。


Event オブジェクト
------------------

イベントは、あるスレッドがイベントを発信し、他のスレッドはそれを待つと
いう、スレッド間で通信を行うための最も単純なメカニズムの一つです。

イベントオブジェクトは内部フラグを管理します。このフラグは "set()" メ
ソッドで値を true に、 "clear()" メソッドで値を false にリセットします
。 "wait()" メソッドはフラグが true になるまでブロックします。

class threading.Event

   イベントオブジェクトを実装しているクラスです。 イベントは "set()"
   メソッドを使うと "True" に、 "clear()" メソッドを使うと "False" に
   セットされるようなフラグを管理します。 "wait()" メソッドは、そのフ
   ラグが true になるまでブロックするようになっています。 フラグの初期
   値は false です。

   バージョン 3.3 で変更: ファクトリ関数からクラスに変更されました。

   is_set()

      内部フラグが真のとき "True" を返します。

      メソッド "isSet" はこのメソッドの非推奨エイリアスです。

   set()

      内部フラグの値を true にセットします。フラグの値が true になるの
      を待っている全てのスレッドを起こします。一旦フラグが true になる
      と、スレッドが "wait()" を呼び出しても全くブロックしなくなります
      。

   clear()

      内部フラグの値を false にリセットします。以降は、 "set()" を呼び
      出して再び内部フラグの値を true にセットするまで、 "wait()" を呼
      び出したスレッドはブロックするようになります。

   wait(timeout=None)

      内部フラグが偽で、タイムアウトが指定されている場合はその時間が経
      過していない間、ブロックします。 戻り値は、このブロックするメソ
      ッドが処理を戻した理由を示します。 内部フラグが真になって戻った
      場合は "True"、タイムアウトが指定されており、その待ち時間内に内
      部フラグが真にならなかった場合は "False" です。

      "timeout" 引数を指定し、その値が "None" でない場合は、操作のタイ
      ムアウトを秒単位で表す実数 (小数も可) にしてください。

      バージョン 3.1 で変更: 以前は、このメソッドは常に "None" を返し
      ていました。


Timer オブジェクト
------------------

このクラスは、一定時間経過後に実行される活動、すなわちタイマ活動を表現
します。 "Timer" は "Thread" のサブクラスであり、自作のスレッドを構築
した一例でもあります。

タイマは、スレッドと同様に "Timer.start" メソッドを呼び出して開始しま
す。 "cancel()" メソッドを呼び出すと、処理を開始する前であればタイマを
停止できます。 処理の実行前にタイマが待つ時間は、指定された時間と厳密
には一致しない場合があります。

例えば:

   def hello():
       print("hello, world")

   t = Timer(30.0, hello)
   t.start()  # 30 秒後に "hello, world" が表示される

class threading.Timer(interval, function, args=None, kwargs=None)

   *interval* 秒後に引数 *args* キーワード引数 *kwargs* で *function*
   を実行するようなタイマを生成します。*args*が ``None`` (デフォルト)
   なら空のリストが使用されます。*kwargs* が "None" (デフォルト) なら
   空の辞書が使用されます。

   バージョン 3.3 で変更: ファクトリ関数からクラスに変更されました。

   cancel()

      タイマをストップして、その動作の実行をキャンセルします。このメソ
      ッドはタイマがまだ活動待ち状態にある場合にのみ動作します。


Barrier オブジェクト
--------------------

Added in version 3.2.

このクラスは、互いを待つ必要のある固定の数のスレッドで使用するための単
純な同期プリミティブを提供します。それぞれのスレッドは "wait()" メソッ
ドを呼ぶことによりバリアを通ろうとしてブロックします。すべてのスレッド
がそれぞれの "wait()" メソッドを呼び出した時点で、すべてのスレッドが同
時に解放されます。

バリアは同じ数のスレッドに対して何度でも再利用することができます。

例として、クライアントとサーバの間でスレッドを同期させる単純な方法を紹
介します:

   b = Barrier(2, timeout=5)

   def server():
       start_server()
       b.wait()
       while True:
           connection = accept_connection()
           process_server_connection(connection)

   def client():
       b.wait()
       while True:
           connection = make_connection()
           process_client_connection(connection)

class threading.Barrier(parties, action=None, timeout=None)

   *parties* 個のスレッドのためのバリアオブジェクトを作成します。
   *action* を指定する場合は、スレッドの解放時に、そのうちの 1 つから
   呼び出される呼び出し可能オブジェクトにしてください。 *timeout* は、
   "wait()" メソッドでタイムアウトを指定しなかった場合に使うデフォルト
   値です。

   wait(timeout=None)

      バリアを通ります。バリアに対するすべてのスレッドがこの関数を呼ん
      だ時に、それらは同時にすべて解放されます。*timeout* が提供される
      場合、それはクラスコンストラクタに渡された値に優先して使用されま
      す。

      返り値は 0 から *parties* -- 1 の範囲の整数で、それぞれのスレッ
      ドに対して異なります。これは、特別な後始末 (housekeeping) を行う
      スレッドを選択するために使用することができます。例えば:

         i = barrier.wait()
         if i == 0:
             # 1 つのスレッドだけが表示すればよい
             print("passed the barrier")

      *action* がコンストラクタに渡されていれば、スレッドのうちの1つが
      解放される前にそれを呼び出します。万一この呼び出しでエラーが発生
      した場合、バリアは broken な状態に陥ります。

      この呼び出しがタイムアウトする場合、バリアは broken な状態に陥り
      ます。

      スレッドが待っている間にバリアが broken になるかリセットされた場
      合、このメソッドは "BrokenBarrierError" 例外を送出するかもしれま
      せん。

   reset()

      バリアをデフォルトの空の状態に戻します。そのバリアの上で待ってい
      るすべてのスレッドは "BrokenBarrierError" 例外を受け取ります。

      状態が未知の他のスレッドがある場合、この関数を使用するのに何らか
      の外部同期を必要とするかもしれないことに注意してください。バリア
      が broken な場合、単にそれをそのままにして新しいものを作成する方
      がよいでしょう。

   abort()

      バリアを broken な状態にします。これによって、現在または将来の
      "wait()" 呼び出しが "BrokenBarrierError" とともに失敗するように
      なります。これを使うと、例えばスレッドが異常終了する必要がある場
      合にアプリケーションがデッドロックするのを避けることができます。

      スレッドのうちの1つが返ってこないことに対して自動的に保護するよ
      うに、単純に常識的な *timeout* 値でバリアを作成することは望まし
      いかもしれません。

   parties

      バリアを通るために要求されるスレッドの数。

   n_waiting

      現在バリアの中で待っているスレッドの数。

   broken

      バリアが broken な状態である場合に "True" となるブール値。

exception threading.BrokenBarrierError

   "Barrier" オブジェクトがリセットされるか broken な場合に、この例外
   ("RuntimeError" のサブクラス) が送出されます。


"with" 文でのロック・条件変数・セマフォの使い方
===============================================

このモジュールが提供するオブジェクトのうち、"acquire" メソッドと
"release" メソッドを持つものはすべて、"with" 文のコンテキストマネージ
ャとして使えます。 ブロックに入るときに "acquire"、ブロックを出るとき
に "release" が呼ばれます。 したがって、次のコードは

   with some_lock:
       # 何らかの処理を行う...

は、以下と同じです

   some_lock.acquire()
   try:
       # 何らかの処理を行う...
   finally:
       some_lock.release()

現在のところ、 "Lock" 、 "RLock" 、 "Condition" 、 "Semaphore" 、
"BoundedSemaphore" を "with" 文のコンテキストマネージャとして使うこと
ができます。


イテレータの同期
================

デフォルトでは、Python のイテレータは並行アクセスをサポートしません。
ほとんどのイテレータは、複数のスレッドから同時にアクセスされた場合の動
作を保証しません。 例えばジェネレータイテレータは、ジェネレータがすで
に実行中であるときにイテレータのメソッドが呼び出されると、"ValueError"
を送出します。 この節のツールを使うと、通常のイテレータやイテレータを
生成する呼び出し可能オブジェクトに、確実に動作する並行アクセスのサポー
トを追加できます。

"serialize_iterator" ラッパーを使うと、複数のスレッドが 1 つのイテレー
タを共有し、順番に値を取り出せます。 あるスレッドが "__next__()" を実
行している間、他のスレッドはイテレータが利用可能になるまでブロックしま
す。 元のイテレータが生成する各値は、ちょうど 1 つの呼び出し元に渡され
ます。

"concurrent_tee()" 関数を使うと、複数のスレッドがそれぞれ、1 つの元の
イテレータの値をすべて受け取れます。 同じ取得元から値を取り出す、独立
したイテレータを作成します。 値は、作成されたすべてのイテレータが消費
するまでバッファに保持されます。

class threading.serialize_iterator(iterable)

   "__next__()" への並行した呼び出しを、ロックを使って 1 つずつ実行す
   るイテレータラッパーを返します。

   ラップしたイテレータに "send()"、"throw()"、"close()" も定義されて
   いる場合は、それらの呼び出しも 1 つずつ実行します。

   これにより、ジェネレータイテレータを含め、1 つのイテレータを複数の
   スレッドで共有できます。 ロックによって、呼び出しは一度に 1 つずつ
   処理されます。 ラッパー自体が値を重複させたり飛ばしたりすることはあ
   りません。 元のイテレータの各要素は、ちょうど 1 つの呼び出し元に渡
   されます。

   このラッパーは値をコピーせず、バッファにも保持しません。 別のスレッ
   ドがイテレータを進めているときに "next()" を呼び出すスレッドは、実
   行中の呼び出しが完了するまでブロックします。

   例:

      import threading

      def squares(n):
          for x in range(n):
              yield x * x

      def consume(name, iterable):
          for item in iterable:
              print(name, item)

      source = threading.serialize_iterator(squares(5))

      t1 = threading.Thread(target=consume, args=("left", source))
      t2 = threading.Thread(target=consume, args=("right", source))
      t1.start()
      t2.start()
      t1.join()
      t2.join()

   この例では、各数値はちょうど一度ずつ表示されますが、処理は 2 つのス
   レッドに分担されます。

   Added in version 3.15.

threading.synchronized_iterator(func)

   イテレータを生成する呼び出し可能オブジェクトをラップし、それが返す
   各イテレータを自動的に "serialize_iterator" に渡すようにします。

   ジェネレータ関数の *デコレータ* として特に便利で、ジェネレータイテ
   レータの値を複数のスレッドから取り出せるようにします。

   例:

      import threading

      @threading.synchronized_iterator
      def squares(n):
          for x in range(n):
              yield x * x

      def consume(name, iterable):
          for item in iterable:
              print(name, item)

      source = squares(5)

      t1 = threading.Thread(target=consume, args=("left", source))
      t2 = threading.Thread(target=consume, args=("right", source))
      t1.start()
      t2.start()
      t1.join()
      t2.join()

   返されるラッパーは、名前やラップした関数への参照など、*func* のメタ
   データを保持します。

   Added in version 3.15.

threading.concurrent_tee(iterable, n=2)

   1 つの入力 *iterable* から *n* 個の独立したイテレータを返します。
   作成されたイテレータから並行して値を取り出す場合の動作が保証されま
   す。

   この関数は "itertools.tee()" に似ていますが、別々のスレッドで動作す
   る消費側に、元のイテレータから値を供給する場合を想定しています。 返
   される各イテレータは、元のイテラブルのすべての値を同じ順序で生成し
   ます。

   内部では、作成されたすべてのイテレータが各値を消費するまで、その値
   をバッファに保持します。

   返されるイテレータは、同じ同期用のロックを共有します。 作成された各
   イテレータは、一度に 1 つのスレッドから値を取り出すことを想定してい
   ます。 作成されたイテレータの 1 つを複数のスレッドで共有する必要が
   ある場合は、"serialize_iterator" でラップしてください。

   *n* が "0" の場合は空のタプルを返します。 *n* が負の場合は
   "ValueError" を送出します。

   例:

      import threading

      def squares(n):
          for x in range(n):
              yield x * x

      def consume(name, iterable):
          for item in iterable:
              print(name, item)

      source = squares(5)
      left, right = threading.concurrent_tee(source)

      t1 = threading.Thread(target=consume, args=("left", left))
      t2 = threading.Thread(target=consume, args=("right", right))
      t1.start()
      t2.start()
      t1.join()
      t2.join()

   In this example, both consumer threads see the full sequence of
   squares from a single generator expression.

   Added in version 3.15.
