how to make two mapper functions run parallel? - multithreading

Question

I read this python documentation on multiprocessing.
But I had a requirement like following:
from multiprocessing import Pool
import time
def f(x):
print(x)
time.sleep(100000000000000);
return x*x
def f2(x):
print('**' + str(x) + '**')
time.sleep(100000000000000);
return x*x*x;
if __name__ == '__main__':
p = Pool(5)
print(p.map(f, [1, 2, 3]))
print(p.map(f2,[1,2,3]))
I have a use case where the function f is blocking(in my case it listens to a rabbitmq queue, so it should be blocking. I used a long time delay-100000000000000 to imply the infinite time blocking).
I have simulated blocking with the time.delay here.
but the need is i want the f2 (which is different from f) to start and run parallel. At present it does not even go to f2 as f itself blocks.
Can someone please give some guidance on how to make f and f2 start parallely despite the fact being f and f2 are both blocking.
Update:
Seems like i found a way, but puzzled
from multiprocessing import Pool
import time
def f(x):
print(x)
time.sleep(100000000000000);
return x*x
def f2(x):
print('**' + str(x) + '**')
time.sleep(100000000000000);
return x*x*x;
if __name__ == '__main__':
p = Pool(5)
res = p.apply_async(f, [2])
res = p.apply_async(f2,[4])
res.get()
how even after reassigning res1 it works and it invokes even f ?

Answer 1

Your approach doesn't work since first pool must complete to be able to print the result before the second pool. So the print kind of blocks the second pool from starting.
I used a thread pool to start both wrappers simultaneously, and I get the results asynchronously. I had to make a loop instead of the big sleep because python complained that sleep was too large. But amounts to the same thing.
In my case, there are printouts of 1,2,3 1,2,3 at once. And if I set the wait loop to a reasonable value I even get some correct results.
from multiprocessing import Pool
import concurrent.futures
import time
sleep_times = 1000000
def f(x):
print(x)
for i in range(sleep_times):
time.sleep(10)
return x*x
def f2(x):
print('**' + str(x) + '**')
for i in range(sleep_times):
time.sleep(10)
return x*x*x;
def fwrap(l):
p = Pool(len(l))
return(p.map(f, l))
def fwrap2(l):
p = Pool(len(l))
return(p.map(f2, l))
if __name__ == '__main__':
jr = dict()
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
jr[executor.submit(fwrap, (1, 2, 3))] = "f"
jr[executor.submit(fwrap2, (1, 2, 3))] = "f2"
for future in concurrent.futures.as_completed(jr):
ident = jr[future]
print(ident,future.result())
output (when sleep loop reduced to 1 to avoid waiting for too long)
1
**1**
2
**2**
**3**
3
there it waits a while (blocked by "processing time") then:
('f', [1, 4, 9])
('f2', [1, 8, 27])