How can a task function be notified of pool stop and abort?

[romdr]

Is it possible for a task function to know the state of the pool and exit early if pool.Stop() has been called?

Can the function safely call pool.Stopped() to know if it should abort its work?

[alitto]

Hey!

A few things to note here:

• If you attempt to submit a task to a pool that has already been stopped, then the call to the Submit() method will return a non-nill error.
• If you stop the pool after the task was submitted, then there are 2 possibilities:
  • The task is still in the queue (it hasn't started yet) -> what happens here depends on the method used to stop the pool. If you call Stop() then it won't be executed. If you call StopAndWait() then it will be executed. More info here.
  • The task is being executed -> in this case, the task will continue to execute until it completes.

That said, if we focus on the last scenario (task is running while the pool is stopped) then you have a few alternatives to detect if the pool was stopped.

1. As you pointed out, you could check pool.Stopped() periodically, this is safe to do although probably not the best approach due to the polling.
2. Pass a context.Context to the worker pool and use it to stop it and also pass it to your task function to detect when the pool is stopped. This is an example of this:

// Create a context with a cancel function. We will use the cancel function to stop the pool instead of directly calling Stop() or StopAndWait()
ctx, cancel := context.WithCancel()

// Create a pool and pass the context to it.
pool := pond.New(1, 1000, pond.Context(ctx))

// Submit a task
pool.Submit(func() {
	select {
	case <-time.After(500 * time.Millisecond): // Here we simulate the task's main processing
	        fmt.Println("task function completed")
	case <-ctx.Done(): // If we receive from this channel, it means the pool was stopped.
		fmt.Println("pool was stopped")
	}
})

// Stop the pool
cancel()

Does it make sense?