performance advise

Hello,
Assuming funcAsync are mainly readAsync / writeAsync calls to Redis using the StackExchange.Redis client -
which implementation of BatchExecuteAsync would be preferrable for better throughput / efficiency etc. ( especially when considering nature of the multiplexing going on behind the scenes ) ?

Thanks

public static async Task BatchedExecuteAsync<TItem>(this List<TItem> items, Func<TItem, Task> funcAsync, int amountOfParallelism)
{
    
    var tasks = new List<Task>(amountOfParallelism);
    int index = 0;
    for (var i = 0; i < amountOfParallelism; i++)
    {
        tasks.Add(Task.Run(async () =>
        {
            while (true)
            {
                TItem item;
                lock (tasks)
                {
                    if (index >= items.Count)
                    {
                        break;
                    }

                    item = items[index];
                    index++;
                }

                await funcAsync(item);
            }
        }));
    }

    await Task.WhenAll(tasks);
}


 public static async Task BatchedExecuteAsync<TItem>(this IEnumerable<TItem> items, Func<TItem,Task> funcAsync, int amountOfParallelism)
        {

            var tasks = new List<Task>(amountOfParallelism);
            foreach (var item in items)
            {
                tasks.Add(funcAsync ( item));
                if (tasks.Count == amountOfParallelism)
                {
                    await Task.WhenAll(tasks);
                    tasks.Clear();
                }
            }
            if (tasks.Count > 0)
            {
                await Task.WhenAll(tasks);
                
            }
     }

Start by comparing the two BatchedExecuteAsync implementations shown in the issue and review StackExchange.Redis guidance on async operations and multiplexing. Done would require a maintainer-backed recommendation or documented guidance; the issue names no repository files or tests.