Lines Matching full:processes
13 :mod:`multiprocessing` is a package that supports spawning processes using an
25 input data across processes (data parallelism). The following example
27 that child processes can successfully import that module. This basic example
47 In :mod:`multiprocessing`, processes are spawned by creating a :class:`Process`
88 Exchanging objects between processes
92 processes:
134 may become corrupted if two processes (or threads) try to read from or write
136 of corruption from processes using different ends of the pipe at the same
140 Synchronization between processes
160 Without using the lock output from the different processes is liable to get all
164 Sharing state between processes
169 using multiple processes.
214 holds Python objects and allows other processes to manipulate them using
251 manager can be shared by processes on different computers over a network.
259 processes. It has methods which allows tasks to be offloaded to the worker
260 processes in a few different ways.
272 pool = Pool(processes=4) # start 4 worker processes
289 # launching multiple evaluations asynchronously *may* use more processes
397 semantics. Multiple processes may be given the same name. The initial
415 processes.
417 Note that a daemonic process is not allowed to create child processes.
420 Unix daemons or services, they are normal processes that will be
421 terminated (and not joined) if non-daemonic processes have exited.
456 Note that descendant processes of the process will *not* be terminated --
465 cause other processes to deadlock.
502 When using multiple processes, one generally uses message passing for
503 communication between processes and avoids having to use any synchronization
507 processes) or a queue (which allows multiple producers and consumers).
544 (2) If multiple processes are enqueuing objects, it is possible for
744 Calling this has the side effect of "joining" any processes which have
792 before they can create child processes. (Windows only)
979 :class:`multiprocessing.Lock` as it applies to either processes or threads,
1069 owned by any process or thread) and if any other processes or threads
1127 inherited by child processes.
1192 processes.
1351 processes. A manager object controls a server process which manages *shared
1352 objects*. Other processes can access the shared objects by using proxies.
1357 can be used for sharing objects between processes. The returned manager
1364 Manager processes will be shutdown as soon as they are garbage collected or
1463 of processes. Objects of this type are returned by
1633 Local processes can also access that queue, using the code from above on the
1686 passed between processes. Note, however, that if a proxy is sent to the
1786 :synopsis: Create pools of processes.
1788 One can create a pool of processes which will carry out tasks submitted to it
1791 .. class:: multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild]]]])
1793 A process pool object which controls a pool of worker processes to which jobs
1797 *processes* is the number of worker processes to use. If *processes* is
1809 means worker processes will live as long as the pool.
1813 Worker processes within a :class:`Pool` typically live for the complete
1878 tasks have been completed the worker processes will exit.
1882 Stops the worker processes immediately without completing outstanding
1888 Wait for the worker processes to exit. One must call :meth:`close` or
1926 pool = Pool(processes=4) # start 4 worker processes
1950 Usually message passing between processes is done using queues or by using
2161 This means that (by default) all processes of a multi-process program will share
2173 handler type) for messages from different processes to get mixed up.
2185 Note that on Windows child processes will only inherit the level of the
2275 between processes.
2278 between processes rather than using the lower level synchronization
2290 (There is never a problem with different processes using the *same* proxy.)
2292 Joining zombie processes
2296 :func:`~multiprocessing.active_children` is called) all completed processes
2300 practice to explicitly join all the processes that you start.
2305 that child processes can use them. However, one should generally avoid
2306 sending shared objects to other processes using pipes or queues. Instead
2310 Avoid terminating processes
2316 processes.
2319 :meth:`Process.terminate <multiprocessing.Process.terminate>` on processes
2322 Joining processes that use queues
2331 process is joined. Otherwise you cannot be sure that processes which have
2333 processes will be joined automatically.
2352 Explicitly pass resources to child processes
2395 in issues with processes-in-processes. This has been changed to::
2400 Which solves the fundamental issue of processes colliding with each other
2403 with output buffering. This danger is that if multiple processes call
2508 processes and collect the results:
2513 An example of how a pool of worker processes can each run a