Activity

1. HCharlie

   added

   docsDocumentation in the Doc dirDocumentation in the Doc dir

   on Mar 8, 2024
2. HCharlie

   added 3 commits that reference this issue on Mar 8, 2024

   pythonGH-116526 patch Synchronization between processes example

   7f62921

   pythonGH-116526 patch Synchronization between processes example

   12981a5

   pythonGH-116526 patch Synchronization between processes example

   31fe118
3. gaogaotiantian commented on Mar 9, 2024

   

   gaogaotiantian

   on Mar 9, 2024

   Member

   More actions

   To be honest this is a pretty bad example to begin with - because you won't notice any difference if you simply remove the lock so it's pretty confusing when users try it out. The stdout is buffered in most environments and won't flush until seeing a newline. We should probably change this to something more obvious - multiple prints maybe (building a triangle?).

   The exception mentioned in this issue can be reproduced with spawn, but might be hard to repro with fork as fork is too fast.
4. HCharlie commented on Mar 10, 2024

   

   HCharlie

   on Mar 10, 2024

   Last edited by HCharlie

   Author

   More actions

   Hey @gaogaotiantian , thanks for your reply. I think your point makes sense, and it still confuses me when reading it as well. Either with or without the lock, the example doesn't seem to emphasize what difference this lock brings. Tbh, my original intent was to just complete the example to remove some exceptions, now I think maybe a new example is needed.
5. HCharlie commented on Mar 10, 2024

   

   HCharlie

   on Mar 10, 2024

   Last edited by hugovk

   Author

   More actions

   one quick example I could think of is as below, we increment a value 3 times in a process.

   import multiprocessing
   
   # Function to be executed by each process
   def increment_counter(counter, lock, process_id):
       lock.acquire()
       for _ in range(3):
           counter.value += 1
           print(f"Counter value: {counter.value} incremented by the {process_id} process")
       lock.release()
   
   if __name__ == "__main__":
       # Shared counter value
       counter = multiprocessing.Value('i', 0)
       
       # Creating a Lock
       lock = multiprocessing.Lock()
   
       # Creating processes
       processes = []
       for j in range(4):  # Creating 4 processes
           p = multiprocessing.Process(target=increment_counter, args=(counter, lock, j))
           processes.append(p)
           p.start()
   
       # Waiting for all processes to finish
       for p in processes:
           p.join()
   
       # Output the final value of the counter
       print("Final counter value:", counter.value)

   with the lock, the value will consecutively be incremented by the same process, and the example will output something like this

   Counter value: 1 incremented by the 1 process
   Counter value: 2 incremented by the 1 process
   Counter value: 3 incremented by the 1 process
   Counter value: 4 incremented by the 0 process
   Counter value: 5 incremented by the 0 process
   Counter value: 6 incremented by the 0 process
   Counter value: 7 incremented by the 2 process
   Counter value: 8 incremented by the 2 process
   Counter value: 9 incremented by the 2 process
   Counter value: 10 incremented by the 3 process
   Counter value: 11 incremented by the 3 process
   Counter value: 12 incremented by the 3 process
   Final counter value: 12
   

   if we remove the lock-related code,

   import multiprocessing
   
   # Function to be executed by each process
   def increment_counter(counter, process_id):
   
       for _ in range(3):
           counter.value += 1
           print(f"Counter value: {counter.value} incremented by the {process_id} process")
   
   
   if __name__ == "__main__":
       # Shared counter value
       counter = multiprocessing.Value('i', 0)
   
       # Creating processes
       processes = []
       for j in range(4):  # Creating 4 processes
           p = multiprocessing.Process(target=increment_counter, args=(counter, j))
           processes.append(p)
           p.start()
   
       # Waiting for all processes to finish
       for p in processes:
           p.join()
   
       # Output the final value of the counter
       print("Final counter value:", counter.value)

   it will randomly print out some duplicates like below, eventually not even reaching 12.

   Counter value: 1 incremented by the 3 process
   Counter value: 1 incremented by the 2 process
   Counter value: 1 incremented by the 0 process
   Counter value: 2 incremented by the 1 process
   Counter value: 3 incremented by the 3 process
   Counter value: 4 incremented by the 2 process
   Counter value: 4 incremented by the 0 process
   Counter value: 4 incremented by the 1 process
   Counter value: 5 incremented by the 3 process
   Counter value: 6 incremented by the 2 process
   Counter value: 6 incremented by the 0 process
   Counter value: 6 incremented by the 1 process
   Final counter value: 6
   

   wdyt?
6. vstinner

   added

   topic-multiprocessing

   on Mar 26, 2024
7. serhiy-storchaka commented on May 30, 2026

   

   serhiy-storchaka

   on May 30, 2026

   Member

   More actions

   This looks too complicated for a simple example. Would not it be enough to use several prints?

   print('start process', i)
   print('end process', i)