CodeBlanks Logo Icon CodeBlanks
Login Register

Process

Learn to create processes with multiprocessing.Process.

What is multiprocessing.Process?

multiprocessing.Process starts a new operating system process. Each process has its own memory space, so it is not affected by the GIL (Global Interpreter Lock).

You create a Process by passing a function through the target argument. p.start() launches the process and p.join() waits for it to finish. To share data between processes you use Queue or Manager. This is the primary way to parallelize CPU-bound work.

Process lifecycle

A Process lifecycle has three steps: create, start, wait. You create with Process(target=func), start with .start(), and wait for completion with .join().

Without .start() the process never runs. Without .join() the main program continues without waiting for the process; this can cause early exits. So always calling join after start is a good habit. For inter-process communication you use Queue.

Practice Call greet with Process

Import with from multiprocessing import Process. Define a greet function that does print("merhaba"). Create a process with Process(target=greet), run it with .start() and .join().

Starter code

main.py
# write the greet function
# create and run a process

Sample solution

main.py
from multiprocessing import Process

def greet():
    print("merhaba")

p = Process(target=greet)
p.start()
p.join()

Expected output

merhaba

Questions and answers

Review the lesson questions together with their answers. To test yourself, solve the lesson interactively.

1 What does the Process target parameter take?

main.py
from multiprocessing import Process
p = Process(target=func)
  • A memory address
  • The process ID
  • The function to run Correct answer
  • A file name

Explanation: target takes the function the process will run.

2 Match Process concepts

Term Meaning
Process New process
target Function
start Launches
join Waits

3 Complete the Process definition

Question 
p = ____(target=greet)
Answer 
p = Process(target=greet)

Explanation: Process(target=func) creates a new process.

All lessons in Expert

1 Metaprogramming

  1. type()
  2. Metaclass
  3. __init_subclass__
  4. __class_getitem__
  5. Decorate class
  6. Summary - Metaprogramming

2 Descriptors

  1. Descriptor protocol
  2. Data descriptor
  3. Non-data descriptor
  4. @property
  5. __set_name__
  6. Summary - Descriptors

3 AST

  1. ast.parse
  2. ast.walk
  3. NodeVisitor
  4. NodeTransformer
  5. compile
  6. Summary - AST

4 ctypes and CFFI

  1. ctypes.CDLL
  2. ctypes types
  3. argtypes and restype
  4. cffi
  5. Structure
  6. Summary - ctypes and CFFI

5 Multiprocessing

  1. Process
  2. start and join
  3. Queue
  4. Pool
  5. Manager
  6. Summary - Multiprocessing

6 Threading and asyncio

  1. threading.Thread
  2. Lock
  3. GIL
  4. concurrent.futures
  5. asyncio vs threading
  6. Summary - Threading and asyncio

7 Performance

  1. timeit
  2. cProfile
  3. sys.getsizeof
  4. slots and tuple
  5. numpy vectorization
  6. Summary - Performance

8 Expert final

  1. Project design
  2. Metaprogramming
  3. Multiprocessing
  4. ctypes
  5. Putting it together