Chapter 14. Threads and Processes
A thread is a flow of control that shares global
state with other threads; all threads appear to execute
simultaneously. Threads are not easy to master, but once you do, they
may offer a simpler architecture or better performance (faster
response, but typically not better throughput) for some problems.
This chapter covers the facilities that Python provides for dealing
with threads, including the thread,
threading, and Queue
modules.
A process is
an instance of a running program. Sometimes you get better results
with multiple processes than with threads. The operating system
protects processes from one another. Processes that want to
communicate must explicitly arrange to do so, via local inter-process
communication (IPC). Processes may communicate via files (covered in
Chapter 10) or via databases (covered in Chapter 11). In both cases, the general way in which
processes communicate using such data storage mechanisms is that one
process can write data, and another process can later read that data
back. This chapter covers the process-related parts of module
os, including simple IPC by means of pipes, and a
cross-platform IPC mechanism known as memory-mapped files, supplied
to Python programs by module
mmap.
Network mechanisms are well suited for IPC, as they work between
processes that run on different nodes of a network as well as those
that run on the same node. Chapter 19 covers
low-level network mechanisms that provide a flexible basis for IPC.
Other, higher-level mechanisms, known as distributed computing, such
as CORBA, DCOM/COM+, EJB, SOAP, XML-RPC, and .NET, make IPC easier,
whether locally or remotely. However, distributed computing is not
covered in this book.
|