Python Multiprocessing inside a class with inconsistent instance variable IDs

I'm relatively inexperienced with Python multiprocessing programming and struggling to understand what's happening here. I'm intentionally using object-oriented programming because the codebase I'm developing uses OOP principles as part of a large MVC design. The code is running on Ubuntu Linux.

The code does the following:

1. Instantiates an instance of the CallingClass.
2. The __ init __ of CallingClass calls the constructor of parent ParentClass and passes a list of three strings.
3. Loops 3 times. Per iteration:
4. Call the method doTheHardWork()
5. A processor pool is set up. The target self.parallelMethod and I pass in a list of strings (A, B, C,...). I'm not interested in this argument, but I will be later.
6. Each process prints the id of the parent attribute self.parentStuffList.

import multiprocessing

class ParentClass:

    def __init__(self, parentStuffList_X):
        self.parentStuffList = parentStuffList_X

class CallingClass(ParentClass):

    def __init__(self):
        ParentClass.__init__(self, ["foo", "bar", "oh dear!"])

    def parallelMethod(self, stuffPassed):
        # let's explore the data in the parent
        # is the parent list different for every process?
        print(str(id(self.parentStuffList)))

    def doTheHardWork(self):
        stuffToPassList = ["A", "B", "C", "D", "E", "F", "G", "H"]  # not bothered by you, yet!

        pool = multiprocessing.Pool(4)
        for _ in pool.map(self.parallelMethod, stuffToPassList):
            pass

if __name__ == '__main__':
    callingClass = CallingClass()

    # Call this multiple times
    for i in range(3):
        callingClass.doTheHardWork()
        print("..............................")

I would be very grateful if you could help me understand:

1. Why the first iteration's processes yield unique IDs, yet the subsequent iterations all have the same ID. From a comment, the start method (fork, spawn) produce different uniformity in ID values.
2. Given that multiprocessing spawns separate Python interpreters, does this mean there will be N instances of the data inherited through the parent class?

I'm struggling to visualise the interplay of OOP and multiprocessing.

140254041045760
140254041560896
140254041561408
140254041045760
140254041560896
140254041045760
140254041560896
140254041561920

..............................
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
..............................
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
140254040957952
..............................

First, in CPython, the id function does not return the "Universally unique instance ID", but the "address of the object in memory".

Because the execution time of parallelMethod is very short, processing of the previous element is finished and cleaned up before processing of the next element can begin. As a result, the element may be placed at the same address. This is why your code outputs the same ID. Note that the same IDs are used repeatedly for the first iteration as well.

140254041045760 <-- A
140254041560896 <-- B
140254041561408
140254041045760 <-- A
140254041560896 <-- B
140254041045760 <-- A
140254041560896 <-- B
140254041561920

The difference in behavior between the first iteration and subsequent iterations may be timing differences due to memory allocation, cache, etc.

To test this hypothesis, we can make the execution time of the parallelMethod long enough as follows:

    def parallelMethod(self, stuffPassed):
        # let's explore the data in the parent
        # is the parent list different for every process?
        print(str(id(self.parentStuffList)))
        time.sleep(1)  # <-- Simulate the long execution time.

The result is as follows:

2237529526912 <-- A
2829585066624 <-- B
1134667074496 <-- C
1799569073216 <-- D
2829585066624 <-- B
2237529526912 <-- A
1134667074496 <-- C
1799569073216 <-- D
..............................
2009911254528 <-- E
2715173195392 <-- F
1693210775296 <-- G
2660560565632 <-- H
2715173195392 <-- F
2009911254528 <-- E
1693210775296 <-- G
2660560565632 <-- H
..............................
1904427212864 <-- I
2102102948928 <-- J
2602047708288 <-- K
2153079620480 <-- L
1904427212864 <-- I
2102102948928 <-- J
2602047708288 <-- K
2153079620480 <-- L
..............................

As you can see, for each iteration, the first 4 IDs are unique, but the latter 4 IDs are reused. This is because by the time the processing of the latter 4 elements begins, the processing of the first 4 elements is already finished and cleaned up (This is how the pool is supposed to work). If you change the number of processes in the pool to 8, you will see that all IDs will be unique.

And for the 2nd question:

> Given that multiprocessing spawns separate Python interpreters, does this mean there will be N instances of the data inherited through the parent class?

Yes, your understanding is correct. Instances can be placed at the same address as described above, but not simultaneously, so they are different instances. Note, however, that if you set Pool(N), there will be N+1 instances, including one in the main process.