# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-04-05 14:30+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/asyncio-sync.rst:7
msgid "Synchronization Primitives"
msgstr "同期プリミティブ"

#: ../../library/asyncio-sync.rst:9
msgid "**Source code:** :source:`Lib/asyncio/locks.py`"
msgstr "**ソースコード:** :source:`Lib/asyncio/locks.py`"

#: ../../library/asyncio-sync.rst:13
msgid ""
"asyncio synchronization primitives are designed to be similar to those of "
"the :mod:`threading` module with two important caveats:"
msgstr ""
"asyncio の同期プリミティブは :mod:`threading` モジュールのそれと類似するよう"
"にデザインされていますが、2つの重要な注意事項があります:"

#: ../../library/asyncio-sync.rst:16
msgid ""
"asyncio primitives are not thread-safe, therefore they should not be used "
"for OS thread synchronization (use :mod:`threading` for that);"
msgstr ""
"asyncio の同期プリミティブはスレッドセーフではありません。従って OS スレッド"
"の同期に使うべきではありません (代わりに :mod:`threading` を使ってください);"

#: ../../library/asyncio-sync.rst:20
msgid ""
"methods of these synchronization primitives do not accept the *timeout* "
"argument; use the :func:`asyncio.wait_for` function to perform operations "
"with timeouts."
msgstr ""
"同期プリミティブのメソッドは *timeout* 引数を受け付けません; タイムアウトを伴"
"う操作を実行するには :func:`asyncio.wait_for` 関数を使ってください。"

#: ../../library/asyncio-sync.rst:24
msgid "asyncio has the following basic synchronization primitives:"
msgstr "asyncio モジュールは以下の基本的な同期プリミティブを持っています:"

#: ../../library/asyncio-sync.rst:26
msgid ":class:`Lock`"
msgstr ":class:`Lock`"

#: ../../library/asyncio-sync.rst:27
msgid ":class:`Event`"
msgstr ":class:`Event`"

#: ../../library/asyncio-sync.rst:28
msgid ":class:`Condition`"
msgstr ":class:`Condition`"

#: ../../library/asyncio-sync.rst:29
msgid ":class:`Semaphore`"
msgstr ":class:`Semaphore`"

#: ../../library/asyncio-sync.rst:30
msgid ":class:`BoundedSemaphore`"
msgstr ":class:`BoundedSemaphore`"

#: ../../library/asyncio-sync.rst:31
msgid ":class:`Barrier`"
msgstr ":class:`Barrier`"

#: ../../library/asyncio-sync.rst:38
msgid "Lock"
msgstr "Lock"

#: ../../library/asyncio-sync.rst:42
msgid "Implements a mutex lock for asyncio tasks.  Not thread-safe."
msgstr ""
"asyncio タスクのためのミューテックスロックを実装しています。スレッドセーフで"
"はありません。"

#: ../../library/asyncio-sync.rst:44
msgid ""
"An asyncio lock can be used to guarantee exclusive access to a shared "
"resource."
msgstr ""
"asyncio ロックは、共有リソースに対する排他的なアクセスを保証するために使うこ"
"とができます。"

#: ../../library/asyncio-sync.rst:47
msgid "The preferred way to use a Lock is an :keyword:`async with` statement::"
msgstr ""
"Lock の望ましい使用方法は、 :keyword:`async with` 文と組み合わせて使うことで"
"す::"

#: ../../library/asyncio-sync.rst:50
msgid ""
"lock = asyncio.Lock()\n"
"\n"
"# ... later\n"
"async with lock:\n"
"    # access shared state"
msgstr ""

#: ../../library/asyncio-sync.rst:56 ../../library/asyncio-sync.rst:201
#: ../../library/asyncio-sync.rst:309
msgid "which is equivalent to::"
msgstr "これは以下のコードと等価です::"

#: ../../library/asyncio-sync.rst:58
msgid ""
"lock = asyncio.Lock()\n"
"\n"
"# ... later\n"
"await lock.acquire()\n"
"try:\n"
"    # access shared state\n"
"finally:\n"
"    lock.release()"
msgstr ""

#: ../../library/asyncio-sync.rst:67 ../../library/asyncio-sync.rst:113
#: ../../library/asyncio-sync.rst:189 ../../library/asyncio-sync.rst:297
#: ../../library/asyncio-sync.rst:353
msgid "Removed the *loop* parameter."
msgstr "*loop* パラメータが削除されました。"

#: ../../library/asyncio-sync.rst:73
msgid "Acquire the lock."
msgstr "ロックを獲得します。"

#: ../../library/asyncio-sync.rst:75
msgid ""
"This method waits until the lock is *unlocked*, sets it to *locked* and "
"returns ``True``."
msgstr ""
"このメソッドはロックが *解除される* まで待機し、ロックを *ロック状態* に変更"
"して ``True`` を返します。"

#: ../../library/asyncio-sync.rst:78
msgid ""
"When more than one coroutine is blocked in :meth:`acquire` waiting for the "
"lock to be unlocked, only one coroutine eventually proceeds."
msgstr ""
"複数のコルーチンが :meth:`acquire` メソッドによりロックの解除を待ち受けている"
"場合、最終的にただひとつのコルーチンが実行されます。"

#: ../../library/asyncio-sync.rst:82
msgid ""
"Acquiring a lock is *fair*: the coroutine that proceeds will be the first "
"coroutine that started waiting on the lock."
msgstr ""
"ロックの獲得は *公平* です: すなわちロックを獲得して実行されるコルーチンは、"
"最初にロックの待ち受けを開始したコルーチンです。"

#: ../../library/asyncio-sync.rst:87
msgid "Release the lock."
msgstr "ロックを解放します。"

#: ../../library/asyncio-sync.rst:89
msgid "When the lock is *locked*, reset it to *unlocked* and return."
msgstr ""
"ロックが *ロック状態* の場合、 ロックを *解除状態* にしてリターンします。"

#: ../../library/asyncio-sync.rst:91
msgid "If the lock is *unlocked*, a :exc:`RuntimeError` is raised."
msgstr "ロックが *解除状態* の場合、 :exc:`RuntimeError` 例外が送出されます。"

#: ../../library/asyncio-sync.rst:95
msgid "Return ``True`` if the lock is *locked*."
msgstr "*ロック状態* の場合に ``True`` を返します。"

#: ../../library/asyncio-sync.rst:99
msgid "Event"
msgstr "Event"

#: ../../library/asyncio-sync.rst:103
msgid "An event object.  Not thread-safe."
msgstr "イベントオブジェクトです。スレッドセーフではありません。"

#: ../../library/asyncio-sync.rst:105
msgid ""
"An asyncio event can be used to notify multiple asyncio tasks that some "
"event has happened."
msgstr ""
"asyncio イベントは、複数の asyncio タスクに対して何らかのイベントが発生したこ"
"とを通知するために使うことができます。"

#: ../../library/asyncio-sync.rst:108
msgid ""
"An Event object manages an internal flag that can be set to *true* with the :"
"meth:`~Event.set` method and reset to *false* with the :meth:`clear` "
"method.  The :meth:`~Event.wait` method blocks until the flag is set to "
"*true*.  The flag is set to *false* initially."
msgstr ""
"Event オブジェクトは内部フラグを管理します。フラグの値は :meth:`~Event.set` "
"メソッドにより *true* に、また :meth:`clear` メソッドにより *false* に設定す"
"ることができます。 :meth:`~Event.wait` メソッドはフラグが *true* になるまで処"
"理をブロックします。フラグの初期値は *false* です。"

#: ../../library/asyncio-sync.rst:118 ../../library/asyncio-sync.rst:377
msgid "Example::"
msgstr "以下はプログラム例です::"

#: ../../library/asyncio-sync.rst:120
msgid ""
"async def waiter(event):\n"
"    print('waiting for it ...')\n"
"    await event.wait()\n"
"    print('... got it!')\n"
"\n"
"async def main():\n"
"    # Create an Event object.\n"
"    event = asyncio.Event()\n"
"\n"
"    # Spawn a Task to wait until 'event' is set.\n"
"    waiter_task = asyncio.create_task(waiter(event))\n"
"\n"
"    # Sleep for 1 second and set the event.\n"
"    await asyncio.sleep(1)\n"
"    event.set()\n"
"\n"
"    # Wait until the waiter task is finished.\n"
"    await waiter_task\n"
"\n"
"asyncio.run(main())"
msgstr ""

#: ../../library/asyncio-sync.rst:144
msgid "Wait until the event is set."
msgstr "イベントがセットされるまで待機します。"

#: ../../library/asyncio-sync.rst:146
msgid ""
"If the event is set, return ``True`` immediately. Otherwise block until "
"another task calls :meth:`~Event.set`."
msgstr ""
"イベントがセットされると、即座に ``True`` を返します。 そうでなければ、他のタ"
"スクが :meth:`~Event.set` メソッドを呼び出すまで処理をブロックします。"

#: ../../library/asyncio-sync.rst:151
msgid "Set the event."
msgstr "イベントをセットします。"

#: ../../library/asyncio-sync.rst:153
msgid "All tasks waiting for event to be set will be immediately awakened."
msgstr ""
"イベントがセットされるまで待機している全てのタスクは、即座に通知を受けて実行"
"を再開します。"

#: ../../library/asyncio-sync.rst:158
msgid "Clear (unset) the event."
msgstr "イベントをクリア (アンセット) します"

#: ../../library/asyncio-sync.rst:160
msgid ""
"Subsequent tasks awaiting on :meth:`~Event.wait` will now block until the :"
"meth:`~Event.set` method is called again."
msgstr ""

#: ../../library/asyncio-sync.rst:165
msgid "Return ``True`` if the event is set."
msgstr "イベントがセットされている場合 ``True`` を返します。"

#: ../../library/asyncio-sync.rst:169
msgid "Condition"
msgstr "Condition"

#: ../../library/asyncio-sync.rst:173
msgid "A Condition object.  Not thread-safe."
msgstr "条件変数オブジェクトです。スレッドセーフではありません。"

#: ../../library/asyncio-sync.rst:175
msgid ""
"An asyncio condition primitive can be used by a task to wait for some event "
"to happen and then get exclusive access to a shared resource."
msgstr ""
"asyncio 条件プリミティブは何らかのイベントが発生するのを待ち受け、そのイベン"
"トを契機として共有リソースへの排他的なアクセスを得るために利用することができ"
"ます。"

#: ../../library/asyncio-sync.rst:179
msgid ""
"In essence, a Condition object combines the functionality of an :class:"
"`Event` and a :class:`Lock`.  It is possible to have multiple Condition "
"objects share one Lock, which allows coordinating exclusive access to a "
"shared resource between different tasks interested in particular states of "
"that shared resource."
msgstr ""
"本質的に、 Condition オブジェクトは :class:`Event` と a :class:`Lock` の2つの"
"クラスの機能を組み合わせたものです。複数の Condition オブジェクトが単一の "
"Lock を共有することでができます。これにより、共有リソースのそれぞれの状態に関"
"連する異なるタスクの間で、そのリソースへの排他的アクセスを調整することが可能"
"になります。"

#: ../../library/asyncio-sync.rst:185
msgid ""
"The optional *lock* argument must be a :class:`Lock` object or ``None``.  In "
"the latter case a new Lock object is created automatically."
msgstr ""
"オプション引数 *lock* は :class:`Lock` または ``None`` でなければなりません。"
"後者の場合自動的に新しい Lock オブジェクトが生成されます。"

#: ../../library/asyncio-sync.rst:192
msgid ""
"The preferred way to use a Condition is an :keyword:`async with` statement::"
msgstr ""
"Condition の望ましい使用方法は :keyword:`async with` 文と組み合わせて使うこと"
"です::"

#: ../../library/asyncio-sync.rst:195
msgid ""
"cond = asyncio.Condition()\n"
"\n"
"# ... later\n"
"async with cond:\n"
"    await cond.wait()"
msgstr ""

#: ../../library/asyncio-sync.rst:203
msgid ""
"cond = asyncio.Condition()\n"
"\n"
"# ... later\n"
"await cond.acquire()\n"
"try:\n"
"    await cond.wait()\n"
"finally:\n"
"    cond.release()"
msgstr ""

#: ../../library/asyncio-sync.rst:215
msgid "Acquire the underlying lock."
msgstr "下層でのロックを獲得します。"

#: ../../library/asyncio-sync.rst:217
msgid ""
"This method waits until the underlying lock is *unlocked*, sets it to "
"*locked* and returns ``True``."
msgstr ""
"このメソッドは下層のロックが  *解除される* まで待機し、ロックを *ロック状態* "
"に変更して ``True`` を返します。"

#: ../../library/asyncio-sync.rst:222
msgid ""
"Wake up *n* tasks (1 by default) waiting on this condition.  If fewer than "
"*n* tasks are waiting they are all awakened."
msgstr ""

#: ../../library/asyncio-sync.rst:225 ../../library/asyncio-sync.rst:240
msgid ""
"The lock must be acquired before this method is called and released shortly "
"after.  If called with an *unlocked* lock a :exc:`RuntimeError` error is "
"raised."
msgstr ""
"このメソッドが呼び出される前にロックを獲得しておかなければなりません。また、"
"メソッド呼び出し後速やかにロックを解除しなければなりません。 *解除された* "
"ロックとと共に呼び出された場合、 :exc:`RuntimeError` 例外が送出されます。"

#: ../../library/asyncio-sync.rst:231
msgid "Return ``True`` if the underlying lock is acquired."
msgstr "下層のロックを獲得していれば ``True`` を返します。"

#: ../../library/asyncio-sync.rst:235
msgid "Wake up all tasks waiting on this condition."
msgstr "この条件を待ち受けている全てのタスクを起動します。"

#: ../../library/asyncio-sync.rst:237
msgid "This method acts like :meth:`notify`, but wakes up all waiting tasks."
msgstr ""
"このメソッドは :meth:`notify` と同じように振る舞いますが、待ち受けている全て"
"のタスクを起動します。"

#: ../../library/asyncio-sync.rst:246
msgid "Release the underlying lock."
msgstr "下層のロックを解除します。"

#: ../../library/asyncio-sync.rst:248
msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."
msgstr ""
"アンロック状態のロックに対して呼び出された場合、:exc:`RuntimeError` が送出さ"
"れます。"

#: ../../library/asyncio-sync.rst:254
msgid "Wait until notified."
msgstr "通知を受けるまで待機します。"

#: ../../library/asyncio-sync.rst:256
msgid ""
"If the calling task has not acquired the lock when this method is called, a :"
"exc:`RuntimeError` is raised."
msgstr ""
"このメソッドが呼び出された時点で呼び出し元のタスクがロックを獲得していない場"
"合、 :exc:`RuntimeError` 例外が送出されます。"

#: ../../library/asyncio-sync.rst:259
msgid ""
"This method releases the underlying lock, and then blocks until it is "
"awakened by a :meth:`notify` or :meth:`notify_all` call. Once awakened, the "
"Condition re-acquires its lock and this method returns ``True``."
msgstr ""
"このメソッドは下層のロックを解除し、その後 :meth:`notify` または :meth:"
"`notify_all` の呼び出しによって起動されるまで処理をブロックします。いったん起"
"動されると、  Condition は再びロックを獲得し、メソッドは ``True`` を返しま"
"す。"

#: ../../library/asyncio-sync.rst:264
msgid ""
"Note that a task *may* return from this call spuriously, which is why the "
"caller should always re-check the state and be prepared to :meth:`~Condition."
"wait` again. For this reason, you may prefer to use :meth:`~Condition."
"wait_for` instead."
msgstr ""

#: ../../library/asyncio-sync.rst:272
msgid "Wait until a predicate becomes *true*."
msgstr "引数 predicate の条件が *真* になるまで待機します。"

#: ../../library/asyncio-sync.rst:274
msgid ""
"The predicate must be a callable which result will be interpreted as a "
"boolean value.  The method will repeatedly :meth:`~Condition.wait` until the "
"predicate evaluates to *true*. The final value is the return value."
msgstr ""

#: ../../library/asyncio-sync.rst:281
msgid "Semaphore"
msgstr "Semaphore"

#: ../../library/asyncio-sync.rst:285
msgid "A Semaphore object.  Not thread-safe."
msgstr "セマフォオブジェクトです。スレッドセーフではありません。"

#: ../../library/asyncio-sync.rst:287
msgid ""
"A semaphore manages an internal counter which is decremented by each :meth:"
"`acquire` call and incremented by each :meth:`release` call. The counter can "
"never go below zero; when :meth:`acquire` finds that it is zero, it blocks, "
"waiting until some task calls :meth:`release`."
msgstr ""
"セマフォは内部のカウンターを管理しています。カウンターは :meth:`acquire` メ"
"ソッドの呼び出しによって減算され、 :meth:`release` メソッドの呼び出しによって"
"加算されます。カウンターがゼロを下回ることはありません。 :meth:`acquire` メ"
"ソッドが呼び出された時にカウンターがゼロになっていると、セマフォは処理をブ"
"ロックし、他のタスクが :meth:`release` メソッドを呼び出すまで待機します。"

#: ../../library/asyncio-sync.rst:293
msgid ""
"The optional *value* argument gives the initial value for the internal "
"counter (``1`` by default). If the given value is less than ``0`` a :exc:"
"`ValueError` is raised."
msgstr ""
"オプション引数 *value* は内部カウンターの初期値を与えます (デフォルトは "
"``1`` です)。 指定された値が ``0`` より小さい場合、 :exc:`ValueError` 例外が"
"送出されます。"

#: ../../library/asyncio-sync.rst:300
msgid ""
"The preferred way to use a Semaphore is an :keyword:`async with` statement::"
msgstr ""
"セマフォの望ましい使用方法は、 :keyword:`async with` 文と組み合わせて使うこと"
"です::"

#: ../../library/asyncio-sync.rst:303
msgid ""
"sem = asyncio.Semaphore(10)\n"
"\n"
"# ... later\n"
"async with sem:\n"
"    # work with shared resource"
msgstr ""

#: ../../library/asyncio-sync.rst:311
msgid ""
"sem = asyncio.Semaphore(10)\n"
"\n"
"# ... later\n"
"await sem.acquire()\n"
"try:\n"
"    # work with shared resource\n"
"finally:\n"
"    sem.release()"
msgstr ""

#: ../../library/asyncio-sync.rst:323
msgid "Acquire a semaphore."
msgstr "セマフォを獲得します。"

#: ../../library/asyncio-sync.rst:325
msgid ""
"If the internal counter is greater than zero, decrement it by one and return "
"``True`` immediately.  If it is zero, wait until a :meth:`release` is called "
"and return ``True``."
msgstr ""
"内部カウンターがゼロより大きい場合、カウンターを1つ減算して即座に ``True`` を"
"返します。内部カウンターがゼロの場合、 :meth:`release` が呼び出されるまで待機"
"してから ``True`` を返します。"

#: ../../library/asyncio-sync.rst:331
msgid "Returns ``True`` if semaphore can not be acquired immediately."
msgstr "セマフォを直ちに獲得できない場合 ``True`` を返します。"

#: ../../library/asyncio-sync.rst:335
msgid ""
"Release a semaphore, incrementing the internal counter by one. Can wake up a "
"task waiting to acquire the semaphore."
msgstr ""
"セマフォを解放し、内部カウンターを1つ加算します。セマフォ待ちをしているタスク"
"を起動する可能性があります。"

#: ../../library/asyncio-sync.rst:338
msgid ""
"Unlike :class:`BoundedSemaphore`, :class:`Semaphore` allows making more "
"``release()`` calls than ``acquire()`` calls."
msgstr ""
":class:`BoundedSemaphore` と異なり、 :class:`Semaphore` は ``release()`` を "
"``acquire()`` よりも多く呼び出すことを許容します。"

#: ../../library/asyncio-sync.rst:343
msgid "BoundedSemaphore"
msgstr "BoundedSemaphore"

#: ../../library/asyncio-sync.rst:347
msgid "A bounded semaphore object.  Not thread-safe."
msgstr "有限セマフォオブジェクトです。スレッドセーフではありません。"

#: ../../library/asyncio-sync.rst:349
msgid ""
"Bounded Semaphore is a version of :class:`Semaphore` that raises a :exc:"
"`ValueError` in :meth:`~Semaphore.release` if it increases the internal "
"counter above the initial *value*."
msgstr ""
"有限セマフォは :class:`Semaphore` の一種で、 :meth:`~Semaphore.release` メ"
"ソッドの呼び出しにより内部カウンターが *初期値* よりも増加してしまう場合は :"
"exc:`ValueError` 例外を送出します。"

#: ../../library/asyncio-sync.rst:358
msgid "Barrier"
msgstr ""

#: ../../library/asyncio-sync.rst:362
msgid "A barrier object.  Not thread-safe."
msgstr ""

#: ../../library/asyncio-sync.rst:364
msgid ""
"A barrier is a simple synchronization primitive that allows to block until "
"*parties* number of tasks are waiting on it. Tasks can wait on the :meth:"
"`~Barrier.wait` method and would be blocked until the specified number of "
"tasks end up waiting on :meth:`~Barrier.wait`. At that point all of the "
"waiting tasks would unblock simultaneously."
msgstr ""

#: ../../library/asyncio-sync.rst:370
msgid ""
":keyword:`async with` can be used as an alternative to awaiting on :meth:"
"`~Barrier.wait`."
msgstr ""

#: ../../library/asyncio-sync.rst:373
msgid "The barrier can be reused any number of times."
msgstr ""

#: ../../library/asyncio-sync.rst:379
msgid ""
"async def example_barrier():\n"
"   # barrier with 3 parties\n"
"   b = asyncio.Barrier(3)\n"
"\n"
"   # create 2 new waiting tasks\n"
"   asyncio.create_task(b.wait())\n"
"   asyncio.create_task(b.wait())\n"
"\n"
"   await asyncio.sleep(0)\n"
"   print(b)\n"
"\n"
"   # The third .wait() call passes the barrier\n"
"   await b.wait()\n"
"   print(b)\n"
"   print(\"barrier passed\")\n"
"\n"
"   await asyncio.sleep(0)\n"
"   print(b)\n"
"\n"
"asyncio.run(example_barrier())"
msgstr ""

#: ../../library/asyncio-sync.rst:400
msgid "Result of this example is::"
msgstr ""

#: ../../library/asyncio-sync.rst:402
msgid ""
"<asyncio.locks.Barrier object at 0x... [filling, waiters:2/3]>\n"
"<asyncio.locks.Barrier object at 0x... [draining, waiters:0/3]>\n"
"barrier passed\n"
"<asyncio.locks.Barrier object at 0x... [filling, waiters:0/3]>"
msgstr ""

#: ../../library/asyncio-sync.rst:412
msgid ""
"Pass the barrier. When all the tasks party to the barrier have called this "
"function, they are all unblocked simultaneously."
msgstr ""

#: ../../library/asyncio-sync.rst:415
msgid ""
"When a waiting or blocked task in the barrier is cancelled, this task exits "
"the barrier which stays in the same state. If the state of the barrier is "
"\"filling\", the number of waiting task decreases by 1."
msgstr ""

#: ../../library/asyncio-sync.rst:420
msgid ""
"The return value is an integer in the range of 0 to ``parties-1``, different "
"for each task. This can be used to select a task to do some special "
"housekeeping, e.g.::"
msgstr ""

#: ../../library/asyncio-sync.rst:424
msgid ""
"...\n"
"async with barrier as position:\n"
"   if position == 0:\n"
"      # Only one task prints this\n"
"      print('End of *draining phase*')"
msgstr ""

#: ../../library/asyncio-sync.rst:430
msgid ""
"This method may raise a :class:`BrokenBarrierError` exception if the barrier "
"is broken or reset while a task is waiting. It could raise a :exc:"
"`CancelledError` if a task is cancelled."
msgstr ""

#: ../../library/asyncio-sync.rst:437
msgid ""
"Return the barrier to the default, empty state.  Any tasks waiting on it "
"will receive the :class:`BrokenBarrierError` exception."
msgstr ""

#: ../../library/asyncio-sync.rst:440
msgid ""
"If a barrier is broken it may be better to just leave it and create a new "
"one."
msgstr ""

#: ../../library/asyncio-sync.rst:445
msgid ""
"Put the barrier into a broken state.  This causes any active or future calls "
"to :meth:`~Barrier.wait` to fail with the :class:`BrokenBarrierError`. Use "
"this for example if one of the tasks needs to abort, to avoid infinite "
"waiting tasks."
msgstr ""

#: ../../library/asyncio-sync.rst:452
msgid "The number of tasks required to pass the barrier."
msgstr ""

#: ../../library/asyncio-sync.rst:456
msgid "The number of tasks currently waiting in the barrier while filling."
msgstr ""

#: ../../library/asyncio-sync.rst:460
msgid "A boolean that is ``True`` if the barrier is in the broken state."
msgstr "バリアが broken な状態である場合に ``True`` となるブール値。"

#: ../../library/asyncio-sync.rst:465
msgid ""
"This exception, a subclass of :exc:`RuntimeError`, is raised when the :class:"
"`Barrier` object is reset or broken."
msgstr ""
":class:`Barrier` オブジェクトがリセットされるか broken な場合に、この例外 (:"
"exc:`RuntimeError` のサブクラス) が送出されます。"

#: ../../library/asyncio-sync.rst:473
msgid ""
"Acquiring a lock using ``await lock`` or ``yield from lock`` and/or :keyword:"
"`with` statement (``with await lock``, ``with (yield from lock)``) was "
"removed.  Use ``async with lock`` instead."
msgstr ""
"``await lock`` や ``yield from lock`` およびそれらと :keyword:`with` 文との組"
"み合わせ (すなわち ``with await lock`` や ``with (yield from lock)``) による"
"ロックの獲得は削除されました。代わりに ``async with lock`` を使ってください。"