work_queue | tunable work queue , designed to coordinate work

When pool is destroyed at the end of main, your destructor sets done, making your worker threads exit.

You should make the destructor (or possibly main, if you want to make this optional) wait for the queue to drain before setting the flag.

The problem here is that you are calling the functions that should be the "body" of each thread when creating the Threads themselves. Upon executing the line thread_task = threading.Thread(target=task_putter()) Python will resolve first the expession inside the parentheses - it calls the function task_putter, which never returns. None of the subsequent lines on your program is ever run.

What we do when creating threads, and other calls that takes callable objects as arguments, is to pass the function itself, not calling it (which will run the function and evaluate to its return value).

Just change both lines creating the threads to not put the calling parentheses on the target= argument and you will get past this point:

We can see that the index scan returned 250692 rows in order to find 5000 to lock. So apparently we had to skip over 49 other queries worth of locked rows. That is not going to be very efficient, although if static it shouldn't be as slow as you see here. But it has to acquire a transient exclusive lock on a section of memory for each attempt. If it is fighting with many other processes for those locks, you can get a cascading collapse of performance.

If you are launching 4 such statements per second with no cap and without waiting for any previous ones to finish, then you have an unstable situation. The more you have running at one time, the more they fight each other and slow down. If the completion rate goes down but the launch interval does not, then you just get more processes fighting with more other processes and each getting slower. So once you get shoved over the edge, it might never recover on its own.

The role of concurrent insertions is probably just to provide enough noisy load on the system to give the collapse a chance to take a foothold. And of course without concurrent insertion, your deletes are doing to run out of things to delete pretty soon, at which point they will be very fast.

For the fist error of

I think closed = true; does need to be seq_cst to make sure it's visible to other threads before you check producers_num the first time. Otherwise this ordering is possible:

• producer: ++producers_num;
• consumer: producers_num == 0
• producer: if (!closed) finds it still open
• consumer: close.store(true, release) becomes globally visible.
• consumer: work_queue.pop(work) finds the queue empty
• producer: work_queue.push(std::move(work)); adds work to the queue after consumer has stopped looking.

You can still avoid seq_cst if you have the consumer check producers_num == 0 before returning, like

In async def task(name, work_queue) method -> after this line of code blobClient = BlobClient(xxx), you should use the code below: