GeezerVisonThe World Wide Web, restored to 800 pixels of glory. |
| Home|About|Gaming cabinet|Archives|How it works|Starter sites |
GeezerVison is showing github.com — python-docs-ja/library/concurrent.futures.po at 3.14 · python/python-docs-ja Expand file tree/ Copy pathconcurrent.futures.poMore file actions 1327 lines (1206 loc) · 63.4 KB / Copy pathconcurrent.futures.poFile metadata and controls1327 lines (1206 loc) · 63.4 KB 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 # 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 # Takanori Suzuki <[email protected]>, 2026 # #, fuzzy msgid "" msgstr "" "Project-Id-Version: Python 3.15\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2026-10-13 19:59+0000\n" "PO-Revision-Date: 2025-09-16 00:01+0000\n" "Last-Translator: Takanori Suzuki <[email protected]>, 2026\n" "Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/" "ja/)\n" "Language: ja\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=1; plural=0;\n" #: ../../library/concurrent.futures.rst:2 msgid ":mod:`!concurrent.futures` --- Launching parallel tasks" msgstr ":mod:`!concurrent.futures` --- 並列タスク実行" #: ../../library/concurrent.futures.rst:9 msgid "" "**Source code:** :source:`Lib/concurrent/futures/thread.py`, :source:`Lib/" "concurrent/futures/process.py`, and :source:`Lib/concurrent/futures/" "interpreter.py`" msgstr "" "**ソースコード:** :source:`Lib/concurrent/futures/thread.py`、:source:`Lib/" "concurrent/futures/process.py` および :source:`Lib/concurrent/futures/" "interpreter.py`" msgid "" "The :mod:`!concurrent.futures` module provides a high-level interface for " "asynchronously executing callables." msgstr "" ":mod:`!concurrent.futures` モジュールは、呼び出し可能オブジェクトを非同期に実" "行するための高水準インターフェースを提供します。" msgid "" "The asynchronous execution can be performed with threads, " "using :class:`ThreadPoolExecutor` or :class:`InterpreterPoolExecutor`, or " "separate processes, using :class:`ProcessPoolExecutor`. Each implements the " "same interface, which is defined by the abstract :class:`Executor` class." msgstr "" "非同期実行には、:class:`ThreadPoolExecutor` また" "は :class:`InterpreterPoolExecutor` によるスレッド、あるい" "は :class:`ProcessPoolExecutor` による別プロセスを使えます。\n" "いずれも、抽象クラス :class:`Executor` で定義された同じインターフェースを実装" "しています。" msgid "" ":class:`concurrent.futures.Future` must not be confused " "with :class:`asyncio.Future`, which is designed for use with :mod:`asyncio` " "tasks and coroutines. See the :doc:`asyncio's Future <asyncio-future>` " "documentation for a detailed comparison of the two." msgstr "" ":class:`concurrent.futures.Future` と :class:`asyncio.Future` を混同しないで" "ください。\n" "後者は :mod:`asyncio` のタスクやコルーチンとともに使うよう設計されていま" "す。\n" "両者の詳しい比較は、:doc:`asyncio の Future <asyncio-future>` のドキュメント" "を参照してください。" msgid "Availability" msgstr "利用可能な環境" #: ../../includes/wasm-notavail.rst:5 msgid "" "This module does not work or is not available on WebAssembly. See :ref:`wasm-" "availability` for more information." msgstr "" "このモジュールは WebAssembly では動作しないか、利用不可です。詳しく" "は、:ref:`wasm-availability` を見てください。" #: ../../library/concurrent.futures.rst:32 msgid "Executor Objects" msgstr "Executor オブジェクト" #: ../../library/concurrent.futures.rst:36 msgid "" "An abstract class that provides methods to execute calls asynchronously. It " "should not be used directly, but through its concrete subclasses." msgstr "" "非同期呼び出しを実行するためのメソッドを提供する抽象クラスです。このクラスを" "直接使ってはならず、具象サブクラスを介して使います。" #: ../../library/concurrent.futures.rst:41 msgid "" "Schedules the callable, *fn*, to be executed as ``fn(*args, **kwargs)`` and " "returns a :class:`Future` object representing the execution of the " "callable. ::" msgstr "" "呼び出し可能オブジェクト *fn* を、 ``fn(*args, **kwargs)`` として実行するよう" "にスケジュールし、呼び出し可能オブジェクトの実行を表現する :class:`Future` オ" "ブジェクトを返します。 ::" msgid "" "with ThreadPoolExecutor(max_workers=1) as executor:\n" " future = executor.submit(pow, 323, 1235)\n" " print(future.result())" msgstr "" "with ThreadPoolExecutor(max_workers=1) as executor:\n" " future = executor.submit(pow, 323, 1235)\n" " print(future.result())" msgid "Similar to :func:`map(fn, *iterables) <map>` except:" msgstr ":func:`map(fn, *iterables) <map>` と似ていますが、次の違いがあります:" msgid "" "The *iterables* are collected immediately rather than lazily, unless a " "*buffersize* is specified to limit the number of submitted tasks whose " "results have not yet been yielded. If the buffer is full, iteration over the " "*iterables* pauses until a result is yielded from the buffer." msgstr "" "結果をまだ yield していない投入済みタスクの数を制限する *buffersize* が指定さ" "れていない限り、*iterables* の要素は遅延せず、直ちに収集されます。\n" "バッファがいっぱいになると、バッファから結果が yield されるまで *iterables* " "の反復処理は一時停止します。" msgid "" "*fn* is executed asynchronously and several calls to *fn* may be made " "concurrently." msgstr "" "*fn* は非同期に実行され、複数の *fn* の呼び出しが並行して行われる場合がありま" "す。" msgid "" "The returned iterator raises a :exc:`TimeoutError` " "if :meth:`~iterator.__next__` is called and the result isn't available after " "*timeout* seconds from the original call to :meth:`Executor.map`. *timeout* " "can be an int or a float. If *timeout* is not specified or ``None``, there " "is no limit to the wait time." msgstr "" "もし :meth:`~iterator.__next__` が呼ばれその結果が元々" "の :meth:`Executor.map` の呼び出しから *timeout* 秒経った後も利用できない場" "合、返されるイテレータは :exc:`TimeoutError` を送出します。\n" "*timeout* は整数または浮動小数点数です。\n" "*timeout* を省略するか ``None`` を指定した場合、待ち時間に制限はありません。" #: ../../library/concurrent.futures.rst:67 msgid "" "If a *fn* call raises an exception, then that exception will be raised when " "its value is retrieved from the iterator." msgstr "" "もし *fn* の呼び出しが例外を送出した場合、その例外はイテレータから値を受け取" "る時に送出されます。" msgid "" "When using :class:`ProcessPoolExecutor`, this method chops *iterables* into " "a number of chunks which it submits to the pool as separate tasks. The " "(approximate) size of these chunks can be specified by setting *chunksize* " "to a positive integer. For very long iterables, using a large value for " "*chunksize* can significantly improve performance compared to the default " "size of 1. With :class:`ThreadPoolExecutor` " "and :class:`InterpreterPoolExecutor`, *chunksize* has no effect." msgstr "" ":class:`ProcessPoolExecutor` を使う場合、このメソッドは *iterables* を複数の" "チャンクに分割し、それぞれを別々のタスクとしてプールに投入します。\n" "*chunksize* を正の整数に設定すると、各チャンクのおおよそのサイズを指定できま" "す。\n" "非常に長いイテラブルでは、*chunksize* に大きな値を使うと、デフォルトのサイズ " "1 に比べて性能が大幅に向上する場合があります。\n" ":class:`ThreadPoolExecutor` と :class:`InterpreterPoolExecutor` では、" "*chunksize* は効果がありません。" #: ../../library/concurrent.futures.rst:79 msgid "Added the *chunksize* parameter." msgstr "*chunksize* 引数が追加されました。" #: ../../library/concurrent.futures.rst:82 msgid "Added the *buffersize* parameter." msgstr "*buffersize* 引数が追加されました。" #: ../../library/concurrent.futures.rst:87 msgid "" "Signal the executor that it should free any resources that it is using when " "the currently pending futures are done executing. Calls " "to :meth:`Executor.submit` and :meth:`Executor.map` made after shutdown will " "raise :exc:`RuntimeError`." msgstr "" "executor に対して、現在保留中のフューチャーが実行された後で、使用中のすべての" "資源を解放するように伝えます。シャットダウンにより後" "に :meth:`Executor.submit` と :meth:`Executor.map` を呼び出す" "と :exc:`RuntimeError` が送出されます。" #: ../../library/concurrent.futures.rst:92 msgid "" "If *wait* is ``True`` then this method will not return until all the pending " "futures are done executing and the resources associated with the executor " "have been freed. If *wait* is ``False`` then this method will return " "immediately and the resources associated with the executor will be freed " "when all pending futures are done executing. Regardless of the value of " "*wait*, the entire Python program will not exit until all pending futures " "are done executing." msgstr "" "*wait* が ``True`` の場合、すべての未完了のフューチャの実行が完了して " "Executor に関連付けられたリソースが解放されるまで、このメソッドは返りませ" "ん。 *wait* が ``False`` の場合、このメソッドはすぐに返り、すべての未完了の" "フューチャの実行が完了したときに、 Executor に関連付けられたリソースが解放さ" "れます。 *wait* の値に関係なく、すべての未完了のフューチャの実行が完了するま" "で Python プログラム全体は終了しません。" msgid "" "If *cancel_futures* is ``True``, this method will cancel all pending futures " "that the executor has not started running. Any futures that are completed or " "running won't be cancelled, regardless of the value of *cancel_futures*." msgstr "" "*cancel_futures* が ``True`` の場合、このメソッドは executor がまだ実行を開始" "していない未完了のフューチャをすべてキャンセルします。\n" "すでに完了したフューチャや実行中のフューチャは、*cancel_futures* の値にかかわ" "らずキャンセルされません。" msgid "" "If both *cancel_futures* and *wait* are ``True``, all futures that the " "executor has started running will be completed prior to this method " "returning. The remaining futures are cancelled." msgstr "" "*cancel_futures* と *wait* がともに ``True`` の場合、executor が実行を開始し" "たフューチャはすべて、このメソッドが返る前に完了します。\n" "残りのフューチャはキャンセルされます。" msgid "" "You can avoid having to call this method explicitly if you use the executor " "as a :term:`context manager` via the :keyword:`with` statement, which will " "shutdown the :class:`Executor` (waiting as if :meth:`Executor.shutdown` were " "called with *wait* set to ``True``)::" msgstr "" ":keyword:`with` 文で executor を :term:`コンテキストマネージャ <context " "manager>` として使えば、このメソッドを明示的に呼び出す必要はありません。\n" ":class:`Executor` はシャットダウンされます (*wait* を ``True`` にし" "て :meth:`Executor.shutdown` を呼び出した場合と同様に待機します)。 ::" msgid "" "import shutil\n" "with ThreadPoolExecutor(max_workers=4) as e:\n" " e.submit(shutil.copy, 'src1.txt', 'dest1.txt')\n" " e.submit(shutil.copy, 'src2.txt', 'dest2.txt')\n" " e.submit(shutil.copy, 'src3.txt', 'dest3.txt')\n" " e.submit(shutil.copy, 'src4.txt', 'dest4.txt')" msgstr "" "import shutil\n" "with ThreadPoolExecutor(max_workers=4) as e:\n" " e.submit(shutil.copy, 'src1.txt', 'dest1.txt')\n" " e.submit(shutil.copy, 'src2.txt', 'dest2.txt')\n" " e.submit(shutil.copy, 'src3.txt', 'dest3.txt')\n" " e.submit(shutil.copy, 'src4.txt', 'dest4.txt')" #: ../../library/concurrent.futures.rst:121 msgid "Added *cancel_futures*." msgstr "*cancel_futures* が追加されました。" #: ../../library/concurrent.futures.rst:126 msgid "ThreadPoolExecutor" msgstr "ThreadPoolExecutor" #: ../../library/concurrent.futures.rst:128 msgid "" ":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a " "pool of threads to execute calls asynchronously." msgstr "" ":class:`ThreadPoolExecutor` はスレッドのプールを使用して非同期に呼び出しを行" "う、 :class:`Executor` のサブクラスです。" #: ../../library/concurrent.futures.rst:131 msgid "" "Deadlocks can occur when the callable associated with a :class:`Future` " "waits on the results of another :class:`Future`. For example::" msgstr "" ":class:`Future` に関連づけられた呼び出し可能オブジェクトが、別" "の :class:`Future` の結果を待つ時にデッドロックすることがあります。例::" msgid "" "import time\n" "def wait_on_b():\n" " time.sleep(5)\n" " print(b.result()) # b will never complete because it is waiting on a.\n" " return 5\n" "\n" "def wait_on_a():\n" " time.sleep(5)\n" " print(a.result()) # a will never complete because it is waiting on b.\n" " return 6\n" "\n" "\n" "executor = ThreadPoolExecutor(max_workers=2)\n" "a = executor.submit(wait_on_b)\n" "b = executor.submit(wait_on_a)" msgstr "" "import time\n" "def wait_on_b():\n" " time.sleep(5)\n" " print(b.result()) # b は a を待っているため完了しない\n" " return 5\n" "\n" "def wait_on_a():\n" " time.sleep(5)\n" " print(a.result()) # a は b を待っているため完了しない\n" " return 6\n" "\n" "\n" "executor = ThreadPoolExecutor(max_workers=2)\n" "a = executor.submit(wait_on_b)\n" "b = executor.submit(wait_on_a)" #: ../../library/concurrent.futures.rst:150 msgid "And::" msgstr "以下でも同様です::" msgid "" "def wait_on_future():\n" " f = executor.submit(pow, 5, 2)\n" " # This will never complete because there is only one worker thread and\n" " # it is executing this function.\n" " print(f.result())\n" "\n" "executor = ThreadPoolExecutor(max_workers=1)\n" "future = executor.submit(wait_on_future)\n" "# Note: calling future.result() would also cause a deadlock because\n" "# the single worker thread is already waiting for wait_on_future()." msgstr "" "def wait_on_future():\n" " f = executor.submit(pow, 5, 2)\n" " # ワーカースレッドは一つしかなく、この関数を実行しているため\n" " # この処理は完了しない\n" " print(f.result())\n" "\n" "executor = ThreadPoolExecutor(max_workers=1)\n" "future = executor.submit(wait_on_future)\n" "# 注意: future.result() を呼び出してもデッドロックが起こる。\n" "\n" "# 唯一のワーカースレッドはすでに wait_on_future() の終了を待っているためであ" "る" #: ../../library/concurrent.futures.rst:166 msgid "" "An :class:`Executor` subclass that uses a pool of at most *max_workers* " "threads to execute calls asynchronously." msgstr "" "最大で *max_workers* 個のスレッドを非同期実行に使う :class:`Executor` のサブ" "クラスです。" msgid "" "All threads enqueued to ``ThreadPoolExecutor`` will be joined before the " "interpreter can exit. Note that the exit handler which does this is executed " "*before* any exit handlers added using ``atexit``. This means exceptions in " "the main thread must be caught and handled in order to signal threads to " "exit gracefully. For this reason, it is recommended that " "``ThreadPoolExecutor`` not be used for long-running tasks." msgstr "" "``ThreadPoolExecutor`` に登録されたすべてのスレッドは、インタープリタの終了前" "に join されます。\n" "この処理を行う終了ハンドラは、``atexit`` で追加した終了ハンドラよりも *前に* " "実行されることに注意してください。\n" "そのため、スレッドに正常終了を指示できるように、メインスレッドの例外を捕捉し" "て処理しなければなりません。\n" "この理由から、長時間実行するタスクには ``ThreadPoolExecutor`` を使わないこと" "を推奨します。" msgid "" "*initializer* is an optional callable that is called at the start of each " "worker thread; *initargs* is a tuple of arguments passed to the " "initializer. Should *initializer* raise an exception, all currently pending " "jobs will raise a :exc:`~concurrent.futures.thread.BrokenThreadPool`, as " "well as any attempt to submit more jobs to the pool." msgstr "" "*initializer* は省略可能な呼び出し可能オブジェクトで、各ワーカースレッドの開" "始時に呼び出されます。\n" "*initargs* は、この初期化処理に渡す引数のタプルです。\n" "*initializer* が例外を送出した場合、現在未完了のジョブはすべ" "て :exc:`~concurrent.futures.thread.BrokenThreadPool` を送出し、プールへの新" "たなジョブの投入も同じ例外を送出します。" #: ../../library/concurrent.futures.rst:182 msgid "" "If *max_workers* is ``None`` or not given, it will default to the number of " "processors on the machine, multiplied by ``5``, assuming " "that :class:`ThreadPoolExecutor` is often used to overlap I/O instead of CPU " "work and the number of workers should be higher than the number of workers " "for :class:`ProcessPoolExecutor`." msgstr "" "*max_workers* が ``None`` か指定されない場合のデフォルト値はマシンのプロセッ" "サの数に 5 を掛けたものになります。これは、 :class:`ThreadPoolExecutor` は " "CPU の処理ではなく I/O をオーバーラップするのによく使用されるた" "め、 :class:`ProcessPoolExecutor` のワーカーの数よりもこのワーカーの数を増や" "すべきであるという想定に基づいています。" #: ../../library/concurrent.futures.rst:190 msgid "" "Added the *thread_name_prefix* parameter to allow users to control " "the :class:`threading.Thread` names for worker threads created by the pool " "for easier debugging." msgstr "" "*thread_name_prefix* 引数が追加され、デバッグしやすくなるようにプールから作ら" "れたワーカスレッド :class:`threading.Thread` の名前を管理できるようになりまし" "た。" #: ../../library/concurrent.futures.rst:195 #: ../../library/concurrent.futures.rst:400 msgid "Added the *initializer* and *initargs* arguments." msgstr "*initializer* と *initargs* 引数が追加されました。" msgid "" "Default value of *max_workers* is changed to ``min(32, os.cpu_count() + " "4)``. This default value preserves at least 5 workers for I/O bound tasks. " "It utilizes at most 32 CPU cores for CPU bound tasks which release the GIL. " "And it avoids using very large resources implicitly on many-core machines." msgstr "" "*max_workers* のデフォルト値が ``min(32, os.cpu_count() + 4)`` に変更されまし" "た。\n" "このデフォルト値により、I/O バウンドのタスクには少なくとも 5 個のワーカーが確" "保されます。\n" "GIL を解放する CPU バウンドのタスクには最大 32 個の CPU コアを利用します。\n" "また、多数のコアを持つマシンで暗黙に大量のリソースを使うことを避けられます。" msgid "" "ThreadPoolExecutor now reuses idle worker threads before starting " "*max_workers* worker threads too." msgstr "" "ThreadPoolExecutor は、*max_workers* 個のワーカースレッドを起動する前に、待機" "中のワーカースレッドを再利用するようにもなりました。" msgid "" "Default value of *max_workers* is changed to ``min(32, " "(os.process_cpu_count() or 1) + 4)``." msgstr "" "*max_workers* のデフォルト値が ``min(32, (os.process_cpu_count() or 1) + " "4)`` に変更されました。" #: ../../library/concurrent.futures.rst:215 msgid "ThreadPoolExecutor Example" msgstr "ThreadPoolExecutor の例" msgid "" "import concurrent.futures\n" "import urllib.request\n" "\n" "URLS = ['http://www.foxnews.com/',\n" " 'http://www.cnn.com/',\n" " 'http://europe.wsj.com/',\n" " 'http://www.bbc.co.uk/',\n" " 'http://nonexistent-subdomain.python.org/']\n" "\n" "# Retrieve a single page and report the URL and contents\n" "def load_url(url, timeout):\n" " with urllib.request.urlopen(url, timeout=timeout) as conn:\n" " return conn.read()\n" "\n" "# We can use a with statement to ensure threads are cleaned up promptly\n" "with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n" " # Start the load operations and mark each future with its URL\n" " future_to_url = {executor.submit(load_url, url, 60): url for url in " "URLS}\n" " for future in concurrent.futures.as_completed(future_to_url):\n" " url = future_to_url[future]\n" " try:\n" " data = future.result()\n" " except Exception as exc:\n" " print('%r generated an exception: %s' % (url, exc))\n" " else:\n" " print('%r page is %d bytes' % (url, len(data)))" msgstr "" "import concurrent.futures\n" "import urllib.request\n" "\n" "URLS = ['http://www.foxnews.com/',\n" " 'http://www.cnn.com/',\n" " 'http://europe.wsj.com/',\n" " 'http://www.bbc.co.uk/',\n" " 'http://nonexistent-subdomain.python.org/']\n" "\n" "# 一つのページを取得し、URL と内容を報告する\n" "def load_url(url, timeout):\n" " with urllib.request.urlopen(url, timeout=timeout) as conn:\n" " return conn.read()\n" "\n" "# with 文を使えばスレッドを速やかに後始末できる\n" "with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n" " # 読み込みを開始し、各フューチャに URL を対応付ける\n" " future_to_url = {executor.submit(load_url, url, 60): url for url in " "URLS}\n" " for future in concurrent.futures.as_completed(future_to_url):\n" " url = future_to_url[future]\n" " try:\n" " data = future.result()\n" " except Exception as exc:\n" " print('%r generated an exception: %s' % (url, exc))\n" " else:\n" " print('%r page is %d bytes' % (url, len(data)))" #: ../../library/concurrent.futures.rst:247 msgid "InterpreterPoolExecutor" msgstr "InterpreterPoolExecutor" msgid "" "The :class:`InterpreterPoolExecutor` class uses a pool of interpreters to " "execute calls asynchronously. It is a :class:`ThreadPoolExecutor` subclass, " "which means each worker is running in its own thread. The difference here is " "that each worker has its own interpreter, and runs each task using that " "interpreter." msgstr "" ":class:`InterpreterPoolExecutor` クラスは、インタープリタのプールを使って呼び" "出しを非同期に実行します。\n" ":class:`ThreadPoolExecutor` のサブクラスなので、各ワーカーはそれぞれのスレッ" "ドで動作します。\n" "異なる点は、各ワーカーが専用のインタープリタを持ち、それを使って各タスクを実" "行することです。" msgid "" "The biggest benefit to using interpreters instead of only threads is true " "multi-core parallelism. Each interpreter has its own :term:`Global " "Interpreter Lock <global interpreter lock>`, so code running in one " "interpreter can run on one CPU core, while code in another interpreter runs " "unblocked on a different core." msgstr "" "スレッドだけを使う代わりにインタープリタを使う最大の利点は、複数のコアで真に" "並列実行できることです。\n" "各インタープリタはそれぞれの :term:`グローバルインタープリタロック <global " "interpreter lock>` を持ちます。\n" "そのため、一つのインタープリタのコードをある CPU コアで実行しながら、別のイン" "タープリタのコードを他のコアで、妨げられることなく実行できます。" msgid "" "The tradeoff is that writing concurrent code for use with multiple " "interpreters can take extra effort. However, this is because it forces you " "to be deliberate about how and when interpreters interact, and to be " "explicit about what data is shared between interpreters. This results in " "several benefits that help balance the extra effort, including true multi-" "core parallelism, For example, code written this way can make it easier to " "reason about concurrency. Another major benefit is that you don't have to " "deal with several of the big pain points of using threads, like race " "conditions." msgstr "" "その代わり、複数のインタープリタを使う並行コードの作成には、追加の手間がかか" "る場合があります。\n" "しかしこれは、インタープリタがいつ、どのようにやり取りするかを慎重に考え、共" "有するデータを明示する必要があるためです。\n" "このことは、複数コアでの真の並列実行をはじめ、追加の手間に見合ういくつかの利" "点につながります。\n" "例えば、このように書かれたコードでは、並行処理の振る舞いを考えやすくなる場合" "があります。\n" "競合状態など、スレッドを使う際の大きな問題のいくつかに対処せずに済むことも、" "大きな利点です。" msgid "" "Each worker's interpreter is isolated from all the other interpreters. " "\"Isolated\" means each interpreter has its own runtime state and operates " "completely independently. For example, if you redirect :data:`sys.stdout` " "in one interpreter, it will not be automatically redirected to any other " "interpreter. If you import a module in one interpreter, it is not " "automatically imported in any other. You would need to import the module " "separately in interpreter where you need it. In fact, each module imported " "in an interpreter is a completely separate object from the same module in a " "different interpreter, including :mod:`sys`, :mod:`builtins`, and even " "``__main__``." msgstr "" "各ワーカーのインタープリタは、他のすべてのインタープリタから分離されていま" "す。\n" "「分離されている」とは、各インタープリタが独自の実行時の状態を持ち、完全に独" "立して動作することです。\n" "例えば、一つのインタープリタで :data:`sys.stdout` をリダイレクトしても、他の" "インタープリタでは自動的にリダイレクトされません。\n" "一つのインタープリタでモジュールをインポートしても、他のインタープリタでは自" "動的にインポートされません。\n" "そのモジュールを必要とするインタープリタごとに、個別にインポートする必要があ" "ります。\n" "実際、あるインタープリタでインポートしたモジュールは、別のインタープリタの同" "じモジュールとは完全に別のオブジェクトです。\n" "これは :mod:`sys`、:mod:`builtins`、さらには ``__main__`` にも当てはまりま" "す。" msgid "" "Isolation means a mutable object, or other data, cannot be used by more than " "one interpreter at the same time. That effectively means interpreters " "cannot actually share such objects or data. Instead, each interpreter must " "have its own copy, and you will have to synchronize any changes between the " "copies manually. Immutable objects and data, like the builtin singletons, " "strings, and tuples of immutable objects, don't have these limitations." msgstr "" "分離されているため、ミュータブルなオブジェクトやその他のデータを、複数のイン" "タープリタで同時に使うことはできません。\n" "実質的に、インタープリタ間でそのようなオブジェクトやデータを共有することはで" "きないということです。\n" "各インタープリタはそれぞれのコピーを持たなければならず、コピー間の変更は手動" "で同期する必要があります。\n" "組み込みのシングルトン、文字列、イミュータブルなオブジェクトからなるタプルな" "ど、イミュータブルなオブジェクトやデータにはこの制約がありません。" msgid "" "Communicating and synchronizing between interpreters is most effectively " "done using dedicated tools, like those proposed in :pep:`734`. One less " "efficient alternative is to serialize with :mod:`pickle` and then send the " "bytes over a shared :mod:`socket <socket>` or :func:`pipe <os.pipe>`." msgstr "" "インタープリタ間の通信や同期には、:pep:`734` で提案されたような専用のツールを" "使うのが最も効率的です。\n" "効率は劣りますが、:mod:`pickle` でシリアライズしてから、共有の :mod:`ソケッ" "ト <socket>` や :func:`パイプ <os.pipe>` を介してバイト列を送る方法もありま" "す。" msgid "" "A :class:`ThreadPoolExecutor` subclass that executes calls asynchronously " "using a pool of at most *max_workers* threads. Each thread runs tasks in " "its own interpreter. The worker interpreters are isolated from each other, " "which means each has its own runtime state and that they can't share any " "mutable objects or other data. Each interpreter has its own :term:`Global " "Interpreter Lock <global interpreter lock>`, which means code run with this " "executor has true multi-core parallelism." msgstr "" "最大 *max_workers* 個のスレッドからなるプールを使い、呼び出しを非同期に実行す" "る :class:`ThreadPoolExecutor` のサブクラスです。\n" "各スレッドは専用のインタープリタでタスクを実行します。\n" "ワーカーのインタープリタは互いに分離されているため、それぞれが独自の実行時の" "状態を持ち、ミュータブルなオブジェクトやその他のデータを共有できません。\n" "各インタープリタはそれぞれの :term:`グローバルインタープリタロック <global " "interpreter lock>` を持つため、この executor で実行するコードは複数のコアで真" "に並列実行できます。" msgid "" "The optional *initializer* and *initargs* arguments have the same meaning as " "for :class:`!ThreadPoolExecutor`: the initializer is run when each worker is " "created, though in this case it is run in the worker's interpreter. The " "executor serializes the *initializer* and *initargs* using :mod:`pickle` " "when sending them to the worker's interpreter." msgstr "" "省略可能な *initializer* と *initargs* 引数の意味は :class:`!" "ThreadPoolExecutor` と同じです。\n" "初期化処理は各ワーカーの作成時に実行されますが、この場合はワーカーのインター" "プリタ内で実行されます。\n" "executor は、*initializer* と *initargs* をワーカーのインタープリタに送る際" "に :mod:`pickle` でシリアライズします。" msgid "" "The executor may replace uncaught exceptions from *initializer* " "with :class:`~concurrent.interpreters.ExecutionFailed`." msgstr "" "executor は、*initializer* で捕捉されなかった例外" "を :class:`~concurrent.interpreters.ExecutionFailed` に置き換える場合がありま" "す。" msgid "Other caveats from parent :class:`ThreadPoolExecutor` apply here." msgstr "" "親クラス :class:`ThreadPoolExecutor` のその他の注意事項も当てはまります。" msgid "" ":meth:`~Executor.submit` and :meth:`~Executor.map` work like normal, except " "the worker serializes the callable and arguments using :mod:`pickle` when " "sending them to its interpreter. The worker likewise serializes the return " "value when sending it back." msgstr "" ":meth:`~Executor.submit` と :meth:`~Executor.map` は通常どおり動作しますが、" "ワーカーが呼び出し可能オブジェクトと引数を自分のインタープリタに送る際" "に :mod:`pickle` でシリアライズする点が異なります。\n" "戻り値を送り返す際にも、同様にシリアライズします。" msgid "" "When a worker's current task raises an uncaught exception, the worker always " "tries to preserve the exception as-is. If that is successful then it also " "sets the ``__cause__`` to a " "corresponding :class:`~concurrent.interpreters.ExecutionFailed` instance, " "which contains a summary of the original exception. In the uncommon case " "that the worker is not able to preserve the original as-is then it directly " "preserves the " "corresponding :class:`~concurrent.interpreters.ExecutionFailed` instance " "instead." msgstr "" "ワーカーが実行中のタスクで捕捉されない例外が発生すると、ワーカーは常にその例" "外をそのまま保持しようとします。\n" "保持できた場合は、元の例外の要約を含む、対応す" "る :class:`~concurrent.interpreters.ExecutionFailed` インスタンスを " "``__cause__`` にも設定します。\n" "まれに元の例外をそのまま保持できない場合は、対応す" "る :class:`~concurrent.interpreters.ExecutionFailed` インスタンスを直接保持し" "ます。" #: ../../library/concurrent.futures.rst:339 msgid "ProcessPoolExecutor" msgstr "ProcessPoolExecutor" #: ../../library/concurrent.futures.rst:341 msgid "" "The :class:`ProcessPoolExecutor` class is an :class:`Executor` subclass that " "uses a pool of processes to execute calls " "asynchronously. :class:`ProcessPoolExecutor` uses the :mod:`multiprocessing` " "module, which allows it to side-step the :term:`Global Interpreter Lock " "<global interpreter lock>` but also means that only picklable objects can be " "executed and returned." msgstr "" ":class:`ProcessPoolExecutor` はプロセスプールを使って非同期呼び出しを実施す" "る :class:`Executor` のサブクラスです。:class:`ProcessPoolExecutor` " "は :mod:`multiprocessing` モジュールを利用します。このため :term:`Global " "Interpreter Lock <global interpreter lock>` を回避することができますが、" "pickle 化できるオブジェクトしか実行したり返したりすることができません。" #: ../../library/concurrent.futures.rst:348 msgid "" "The ``__main__`` module must be importable by worker subprocesses. This " "means that :class:`ProcessPoolExecutor` will not work in the interactive " "interpreter." msgstr "" "``__main__`` モジュールはワーカサブプロセスでインポート可能でなければなりませ" "ん。\n" "すなわち、 :class:`ProcessPoolExecutor` は対話的インタープリタでは動きませ" "ん。" #: ../../library/concurrent.futures.rst:351 msgid "" "Calling :class:`Executor` or :class:`Future` methods from a callable " "submitted to a :class:`ProcessPoolExecutor` will result in deadlock." msgstr "" ":class:`ProcessPoolExecutor` に渡された呼び出し可能オブジェクトか" "ら :class:`Executor` や :class:`Future` メソッドを呼ぶとデッドロックに陥りま" "す。" msgid "" "Note that the restrictions on functions and arguments needing to picklable " "as per :class:`multiprocessing.Process` apply when " "using :meth:`~Executor.submit` and :meth:`~Executor.map` on " "a :class:`ProcessPoolExecutor`. A function defined in a REPL or a lambda " "should not be expected to work." msgstr "" ":class:`ProcessPoolExecutor` の :meth:`~Executor.submit` " "と :meth:`~Executor.map` を使う際には、:class:`multiprocessing.Process` と同" "様に、関数と引数が pickle 化可能でなければならないという制約があることに注意" "してください。\n" "REPL で定義した関数や lambda が動作することは期待できません。" msgid "" "An :class:`Executor` subclass that executes calls asynchronously using a " "pool of at most *max_workers* processes. If *max_workers* is ``None`` or " "not given, it will default to :func:`os.process_cpu_count`. If *max_workers* " "is less than or equal to ``0``, then a :exc:`ValueError` will be raised. On " "Windows, *max_workers* must be less than or equal to ``61``. If it is not " "then :exc:`ValueError` will be raised. If *max_workers* is ``None``, then " "the default chosen will be at most ``61``, even if more processors are " "available. *mp_context* can be a :mod:`multiprocessing` context or ``None``. " "It will be used to launch the workers. If *mp_context* is ``None`` or not " "given, the default :mod:`multiprocessing` context is used. " "See :ref:`multiprocessing-start-methods`." msgstr "" "最大 *max_workers* 個のプロセスからなるプールを使い、呼び出しを非同期に実行す" "る :class:`Executor` のサブクラスです。\n" "*max_workers* が ``None`` または省略された場合、デフォルト" "で :func:`os.process_cpu_count` が使われます。\n" "*max_workers* が ``0`` 以下の場合は :exc:`ValueError` を送出します。\n" "Windows では、*max_workers* は ``61`` 以下でなければなりません。\n" "そうでない場合は :exc:`ValueError` を送出します。\n" "*max_workers* が ``None`` の場合、利用可能なプロセッサ数がそれより多くても、" "デフォルトで選択される値は最大 ``61`` です。\n" "*mp_context* には :mod:`multiprocessing` のコンテキストまたは ``None`` を指定" "でき、ワーカーの起動に使われます。\n" "*mp_context* が ``None`` または省略された場合、デフォルト" "の :mod:`multiprocessing` コンテキストが使われます。\n" ":ref:`multiprocessing-start-methods` を参照してください。" msgid "" "*initializer* is an optional callable that is called at the start of each " "worker process; *initargs* is a tuple of arguments passed to the " "initializer. Should *initializer* raise an exception, all currently pending " "jobs will raise a :exc:`~concurrent.futures.process.BrokenProcessPool`, as " "well as any attempt to submit more jobs to the pool." msgstr "" "*initializer* は省略可能な呼び出し可能オブジェクトで、各ワーカープロセスの開" "始時に呼び出されます。\n" "*initargs* は、この初期化処理に渡す引数のタプルです。\n" "*initializer* が例外を送出した場合、現在未完了のジョブはすべ" "て :exc:`~concurrent.futures.process.BrokenProcessPool` を送出し、プールへの" "新たなジョブの投入も同じ例外を送出します。" msgid "" "*max_tasks_per_child* is an optional argument that specifies the maximum " "number of tasks a single process can execute before it will exit and be " "replaced with a fresh worker process. By default *max_tasks_per_child* is " "``None`` which means worker processes will live as long as the pool. When a " "max is specified, the \"spawn\" multiprocessing start method will be used by " "default in absence of a *mp_context* parameter. This feature is incompatible " "with the \"fork\" start method." msgstr "" "*max_tasks_per_child* は省略可能な引数で、一つのプロセスが終了して新しいワー" "カープロセスに置き換わるまでに実行できるタスクの最大数を指定します。\n" "デフォルトの *max_tasks_per_child* は ``None`` で、ワーカープロセスはプールが" "存在する限り存続します。\n" "最大数を指定し、*mp_context* パラメータを指定しなかった場合、デフォルトでは " "multiprocessing の開始方式に \"spawn\" が使われます。\n" "この機能は \"fork\" 開始方式とは併用できません。" #: ../../library/concurrent.futures.rst:389 msgid "" "When one of the worker processes terminates abruptly, " "a :exc:`~concurrent.futures.process.BrokenProcessPool` error is now raised. " "Previously, behaviour was undefined but operations on the executor or its " "futures would often freeze or deadlock." msgstr "" "ワーカプロセスの1つが突然終了した場" "合、:exc:`~concurrent.futures.process.BrokenProcessPool` エラーが送出されるよ" "うになりました。\n" "以前は挙動は未定義でしたが、 executor や futures がフリーズしたりデッドロッ" "クを起こすことがしばしばでした。" msgid "" "The *mp_context* argument was added to allow users to control the " "start_method for worker processes created by the pool." msgstr "" "プールが作成するワーカープロセスの開始方式を利用者が制御できるよう、" "*mp_context* 引数が追加されました。" msgid "" "The *max_tasks_per_child* argument was added to allow users to control the " "lifetime of workers in the pool." msgstr "" "プール内のワーカーの存続期間を利用者が制御できるよう、*max_tasks_per_child* " "引数が追加されました。" msgid "" "On POSIX systems, if your application has multiple threads and " "the :mod:`multiprocessing` context uses the ``\"fork\"`` start method: " "The :func:`os.fork` function called internally to spawn workers may raise " "a :exc:`DeprecationWarning`. Pass a *mp_context* configured to use a " "different start method. See the :func:`os.fork` documentation for further " "explanation." msgstr "" "POSIX システムで、アプリケーションが複数のスレッドを持" "ち、:mod:`multiprocessing` コンテキストが ``\"fork\"`` 開始方式を使う場合、" "ワーカーを起動するために内部で呼び出す :func:`os.fork` 関数" "が :exc:`DeprecationWarning` を送出することがあります。\n" "別の開始方式を使うように設定した *mp_context* を渡してください。\n" "詳しくは :func:`os.fork` のドキュメントを参照してください。" msgid "" "*max_workers* uses :func:`os.process_cpu_count` by default, instead " "of :func:`os.cpu_count`." msgstr "" "*max_workers* のデフォルトで、:func:`os.cpu_count` の代わり" "に :func:`os.process_cpu_count` を使うようになりました。" msgid "" "The default process start method (see :ref:`multiprocessing-start-methods`) " "changed away from *fork*. If you require the *fork* start method " "for :class:`ProcessPoolExecutor` you must explicitly pass " "``mp_context=multiprocessing.get_context(\"fork\")``." msgstr "" "プロセスのデフォルトの開始方式 (:ref:`multiprocessing-start-methods` を参照) " "が *fork* 以外に変更されました。\n" ":class:`ProcessPoolExecutor` で *fork* 開始方式が必要な場合は、" "``mp_context=multiprocessing.get_context(\"fork\")`` を明示的に渡さなければな" "りません。" msgid "" "Fixed a deadlock (:gh:`115634`) where the executor could hang after a worker " "process exited upon reaching its *max_tasks_per_child* limit while tasks " "remained queued." msgstr "" "キューにタスクが残っている間にワーカープロセスが *max_tasks_per_child* の上限" "に達して終了すると、executor が停止したままになることがあるデッドロック " "(:gh:`115634`) を修正しました。" msgid "" "Attempt to terminate all living worker processes immediately by " "calling :meth:`Process.terminate <multiprocessing.Process.terminate>` on " "each of them. Internally, it will also call :meth:`Executor.shutdown` to " "ensure that all other resources associated with the executor are freed." msgstr "" "存続中のすべてのワーカープロセスについて :meth:`Process.terminate " "<multiprocessing.Process.terminate>` を呼び出し、直ちに終了させようとしま" "す。\n" "executor に関連するその他のリソースをすべて解放するため、内部で" "は :meth:`Executor.shutdown` も呼び出します。" msgid "" "After calling this method the caller should no longer submit tasks to the " "executor." msgstr "" "このメソッドを呼び出した後は、executor にタスクを投入しないでください。" msgid "" "Attempt to kill all living worker processes immediately by " "calling :meth:`Process.kill <multiprocessing.Process.kill>` on each of them. " "Internally, it will also call :meth:`Executor.shutdown` to ensure that all " "other resources associated with the executor are freed." msgstr "" "存続中のすべてのワーカープロセスについて :meth:`Process.kill " "<multiprocessing.Process.kill>` を呼び出し、直ちに強制終了させようとしま" "す。\n" "executor に関連するその他のリソースをすべて解放するため、内部で" "は :meth:`Executor.shutdown` も呼び出します。" #: ../../library/concurrent.futures.rst:456 msgid "ProcessPoolExecutor Example" msgstr "ProcessPoolExecutor の例" msgid "" "import concurrent.futures\n" "import math\n" "\n" "PRIMES = [\n" " 112272535095293,\n" " 112582705942171,\n" " 112272535095293,\n" " 115280095190773,\n" " 115797848077099,\n" " 1099726899285419]\n" "\n" "def is_prime(n):\n" " if n < 2:\n" " return False\n" " if n == 2:\n" " return True\n" " if n % 2 == 0:\n" " return False\n" "\n" " sqrt_n = int(math.floor(math.sqrt(n)))\n" " for i in range(3, sqrt_n + 1, 2):\n" " if n % i == 0:\n" " return False\n" " return True\n" "\n" "def main():\n" " with concurrent.futures.ProcessPoolExecutor() as executor:\n" " for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):\n" " print('%d is prime: %s' % (number, prime))\n" "\n" "if __name__ == '__main__':\n" " main()" msgstr "" "import concurrent.futures\n" "import math\n" "\n" "PRIMES = [\n" " 112272535095293,\n" " 112582705942171,\n" " 112272535095293,\n" " 115280095190773,\n" " 115797848077099,\n" " 1099726899285419]\n" "\n" "def is_prime(n):\n" " if n < 2:\n" " return False\n" " if n == 2:\n" " return True\n" " if n % 2 == 0:\n" " return False\n" "\n" " sqrt_n = int(math.floor(math.sqrt(n)))\n" " for i in range(3, sqrt_n + 1, 2):\n" " if n % i == 0:\n" " return False\n" " return True\n" "\n" "def main():\n" " with concurrent.futures.ProcessPoolExecutor() as executor:\n" " for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):\n" " print('%d is prime: %s' % (number, prime))\n" "\n" "if __name__ == '__main__':\n" " main()" #: ../../library/concurrent.futures.rst:494 msgid "Future Objects" msgstr "Future オブジェクト" #: ../../library/concurrent.futures.rst:496 msgid "" "The :class:`Future` class encapsulates the asynchronous execution of a " "callable. :class:`Future` instances are created by :meth:`Executor.submit`." msgstr "" ":class:`Future` クラスは呼び出し可能オブジェクトの非同期実行をカプセル化しま" "す。 :class:`Future` のインスタンスは :meth:`Executor.submit` によって生成さ" "れます。" #: ../../library/concurrent.futures.rst:501 msgid "" "Encapsulates the asynchronous execution of a callable. :class:`Future` " "instances are created by :meth:`Executor.submit` and should not be created " "directly except for testing." msgstr "" "呼び出し可能オブジェクトの非同期実行をカプセル化します。 :class:`Future` イン" "スタンスは :meth:`Executor.submit` で生成され、テストを除いて直接生成すべきで" "はありません。" msgid "" "Attempt to cancel the call. If the call is currently being executed or " "finished running and cannot be cancelled then the method will return " "``False``, otherwise the call will be cancelled and the method will return " "``True``." msgstr "" "呼び出しのキャンセルを試みます。\n" "呼び出しがすでに実行中または実行済みで、キャンセルできない場合は ``False`` を" "返します。\n" "それ以外の場合は呼び出しをキャンセルして ``True`` を返します。" #: ../../library/concurrent.futures.rst:514 msgid "Return ``True`` if the call was successfully cancelled." |
| You are visitor 01402520 — GeezerVison does not store the pages you look up. Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required. |