Lines Matching refs:processes
14 :mod:`multiprocessing` is a package that supports spawning processes using an
26 distributing the input data across processes (data parallelism). The following
28 so that child processes can successfully import that module. This basic example
48 In :mod:`multiprocessing`, processes are spawned by creating a :class:`Process`
130 Child processes no longer inherit all of the parents inheritable
135 semaphores created by processes of the program. When all processes
181 processes for a different context. In particular, locks created using
182 the *fork* context cannot be passed to processes started using the
197 Exchanging objects between processes
201 processes:
243 may become corrupted if two processes (or threads) try to read from or write
245 of corruption from processes using different ends of the pipe at the same
249 Synchronization between processes
271 Without using the lock output from the different processes is liable to get all
275 Sharing state between processes
280 using multiple processes.
325 holds Python objects and allows other processes to manipulate them using
361 manager can be shared by processes on different computers over a network.
369 processes. It has methods which allows tasks to be offloaded to the worker
370 processes in a few different ways.
382 # start 4 worker processes
383 with Pool(processes=4) as pool:
400 # launching multiple evaluations asynchronously *may* use more processes
518 only. It has no semantics. Multiple processes may be given the same
541 processes.
543 Note that a daemonic process is not allowed to create child processes.
546 Unix daemons or services, they are normal processes that will be
547 terminated (and not joined) if non-daemonic processes have exited.
597 Note that descendant processes of the process will *not* be terminated --
606 cause other processes to deadlock.
669 When using multiple processes, one generally uses message passing for
670 communication between processes and avoids having to use any synchronization
674 processes) or a queue (which allows multiple producers and consumers).
712 (2) If multiple processes are enqueuing objects, it is possible for
912 Calling this has the side effect of "joining" any processes which have
984 Return the name of start method used for starting processes.
1005 before they can create child processes.
1012 Set the method which should be used to start child processes.
1122 Connection objects themselves can now be transferred between processes
1222 :class:`multiprocessing.Lock` as it applies to either processes or threads,
1314 owned by any process or thread) and if any other processes or threads
1363 inherited by child processes.
1429 processes.
1591 processes, including sharing over a network between processes running on
1593 *shared objects*. Other processes can access the shared objects by using
1599 can be used for sharing objects between processes. The returned manager
1606 Manager processes will be shutdown as soon as they are garbage collected or
1714 of processes. Objects of this type are returned by
1718 number of commonly used data types to be synchronized across processes.
1882 Local processes can also access that queue, using the code from above on the
1936 passed between processes. As such, a referent can contain
2072 :synopsis: Create pools of processes.
2074 One can create a pool of processes which will carry out tasks submitted to it
2077 .. class:: Pool([processes[, initializer[, initargs[, maxtasksperchild [, context]]]]])
2079 A process pool object which controls a pool of worker processes to which jobs
2083 *processes* is the number of worker processes to use. If *processes* is
2092 means worker processes will live as long as the pool.
2095 the worker processes. Usually a pool is created using the
2111 Worker processes within a :class:`Pool` typically live for the complete
2212 tasks have been completed the worker processes will exit.
2216 Stops the worker processes immediately without completing outstanding
2222 Wait for the worker processes to exit. One must call :meth:`close` or
2265 with Pool(processes=4) as pool: # start 4 worker processes
2288 Usually message passing between processes is done using queues or by using
2469 wait for messages from multiple processes at once::
2545 This means that (by default) all processes of a multi-process program will share
2557 handler type) for messages from different processes to get mixed up.
2569 Note that on Windows child processes will only inherit the level of the
2626 between processes.
2629 between processes rather than using the lower level synchronization
2641 (There is never a problem with different processes using the *same* proxy.)
2643 Joining zombie processes
2647 :func:`~multiprocessing.active_children` is called) all completed processes
2651 practice to explicitly join all the processes that you start.
2657 processes can use them. However, one should generally avoid
2658 sending shared objects to other processes using pipes or queues.
2663 Avoid terminating processes
2669 processes.
2672 :meth:`Process.terminate <multiprocessing.Process.terminate>` on processes
2675 Joining processes that use queues
2685 process is joined. Otherwise you cannot be sure that processes which have
2687 processes will be joined automatically.
2706 Explicitly pass resources to child processes
2751 in issues with processes-in-processes. This has been changed to::
2756 Which solves the fundamental issue of processes colliding with each other
2759 with output buffering. This danger is that if multiple processes call
2860 processes and collect the results: