How to start and await multiple I/O operations at the same time without wasting threads in F#?

We know there is no point in running I/O operations in separate threads since they are "truly" asynchronous, meaning that they are non-blocking without requiring an extra thread to be run on.

Consider this scenario: I have an I/O function insertProductAsync : DbModels.Product -> Async<unit> and another I/O function insertProductsAsync : DbModels.Product seq -> Async<unit>. Both do exactly what they say they do and there is one condition: insertProductsAsync must use insertProductAsync. This is an educational example, so no need to discuss SQL batch operations and similar concepts.

The workflow I'm looking for for insertProductsAsync is as follows:

1. For each product, start an insertProductAsync task sequentially.
2. While the I/O operations execute, do not use or block the current thread, or any thread.
3. Finally, return a task or similar structure that completes when all the individual insertProductAsync tasks will have been completed. I believe in C# this could be achieved by doing the following:

public Task InsertProductAsync(DbModels.Product product)
{
    // pure 'async'/non-CPU-bound operation
}

public Task InsertProductsAsync(IEnumerable<DbModels.Product> products)
{
    IEnumerable<Task> tasks = products.Select(InsertProductAsync);  // tasks already started to execute, no extra threads used
    return Task.WhenAll(tasks);
}

Which of the following options (if any) match the workflow I described and why? If none, please provide your own option with explanation. When explaining, please provide a good description of what happens behind the scenes.

Option 1 — Async.Sequential

let insertProductsAsync (products : DbModels.Product seq) =
    async {
        return!
            products
            |> Seq.map insertProductAsync
            |> Async.Sequantial // each async block probably awaiting the previous one to complete, probably not what i want
            |> Async.Ignore
    }

Option 2 — Async.Parallel

let insertProductsAsync (products : DbModels.Product seq) =
    async {
        return!
            products
            |> Seq.map insertProductAsync
            |> Async.Parallel // wasting threads probably, I guess
            |> Async.Ignore
    }

Option 3 — ???

Your option here.

To answer your final question, operations that execute in parallel do not block a thread. That would be synchronous behavior. You can see this in the following example:

open System
open System.Threading

let doSomething timeout =
    async {
        Thread.Sleep(timeout : int)
        printfn $"Slept {timeout} milliseconds on thread ID: {Thread.CurrentThread.ManagedThreadId}"
    }

printfn $"Main thread ID: {Thread.CurrentThread.ManagedThreadId}"
doSomething 1000 |> Async.Start

printfn $"Main thread ID: {Thread.CurrentThread.ManagedThreadId}"
doSomething 900 |> Async.Start

printfn $"Main thread ID: {Thread.CurrentThread.ManagedThreadId}"
doSomething 800 |> Async.Start

printfn $"Main thread ID: {Thread.CurrentThread.ManagedThreadId}"
doSomething 700 |> Async.Start

printfn ""
Console.ReadLine() |> ignore

Output:

Main thread ID: 1
Main thread ID: 1
Main thread ID: 1
Main thread ID: 1

Slept 700 milliseconds on thread ID: 10
Slept 800 milliseconds on thread ID: 7
Slept 900 milliseconds on thread ID: 6
Slept 1000 milliseconds on thread ID: 4

Note that the main thread (ID 1) doesn't block during execution.