Quale costrutto si usa per garantire che 100 attività siano eseguite in parallelo

Attività e discussioni esistono per scopi diversi. Le attività sono pensate per essere brevi cose che devono essere eseguite in background. I thread rappresentano una risorsa operativa per l'esecuzione simultanea.

Internamente, TaskManager utilizza un pool di thread in modo che possa riutilizzare i thread per elaborare più attività. I thread sono costosi da configurare e abbattere in modo che non funzionino correttamente allo scopo di creare Task. Sebbene tu possa influenzare il numero di thread disponibili per il task manager, è comunque responsabile di distribuire il lavoro ai thread.

Garanzia del numero X di client simultanei

L'unico modo per garantirlo è utilizzare Thread anziché Task . Se dovessi ristrutturare un po 'il tuo codice potresti gestire i tuoi client simultanei in questo modo:

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using System.Threading;

namespace IntegrationTests
{
    private static string server;
    private static int port;
    private static TimeSpan clientLifetime;
    private static TimeSpan timeout;
    private static TimeSpan reconnectInterval;
    private static List<string> clientIds;
    private static Barrier barrier;

    class Program
    {
        static void Main(string[] args)
        {
            int          numClients        = int.Parse(ConfigurationManager.AppSettings["numberOfClients"]);
            server            = ConfigurationManager.AppSettings["server"];
            port              = int.Parse(ConfigurationManager.AppSettings["port"]);
            clientLifetime    = TimeSpan.Parse(ConfigurationManager.AppSettings["clientLifetime"]);
            timeout           = TimeSpan.Parse(ConfigurationManager.AppSettings["timeout"]);
            reconnectInterval = TimeSpan.Parse(ConfigurationManager.AppSettings["reconnectInterval"]);
            clientIds         = ConfigurationManager.GetSection("clientIds") as List<string>;
            barrier           = new Barrier(numClients + 1);

            try
            {
                // SNIP configure logging

                // Create the specified number of clients, to carry out test operations, each on their own threads
                Thread[] threads= new Thread[numClients];
                for(int count = 0; count < numClients; ++count)
                {
                    var index = count;
                    threads[count] = new Thread();
                    threads[count].Name = $"Client {count}"; // for debugging
                    threads[count].Start(RunClient);
                }

                // We loose the convenience of awaiting all tasks,
                // but use a thread barrier to block this thread until all the others are done.
                barrier.SignalAndWait();
            }
            catch (Exception e)
            {
                // SNIP - Log it
            }
        }

        private void RunClient()
        {
            try
            {
                // Reuse client Ids, if there are more clients then clientIds.
                // Keep in mind that tasks are not necessarily started in the order they were created in this loop.
                // We may see client id 1 be assigned client id 2 if another client was started before it, but we
                // are using all clientIds
                string clientId = null;
                if (numClients < clientIds.Count)
                {
                    clientId = clientIds[index];
                }
                else
                {
                    clientId = clientIds[index % clientIds.Count];
                }

                // Create the actual client
                Client client = new Client(server, port, clientId, timeout, reconnectInterval);
                client.Startup();

                // Will make an sync request issue a recv.
                // Everytime we get a reponse, it will be logged and another recv will be posted.
                // This will continue until shutdown is called
                client.MakeRequest(symbol);

                System.Threading.Thread.Sleep(clientLifetime);

                client.Shutdown();
            }
            catch(Exception e)
            {
                // SNIP - Log it
            }
            finally
            {
                barrier.SignalAndWait();
            }
        }
    }
}

Non penso che ci sia un problema con il test.

Ho utilizzato un codice simile per il test di carico (di base) e ho visto oltre 100 attività simultanee.

Direi che c'è un problema nel modo in cui stai loggando. Stai semplicemente misurando il numero di connessioni simultanee che il tuo server può gestire?

Ad esempio, il codice seguente conterà fino a 1000.

Tuttavia, notare la differenza se sostituiamo Task.Delay con Thread.Sleep. Questo interrompe l'app perché più di una attività viene eseguita sullo stesso thread.

Ora, se anche cambia l'attività. Aggiungi a:

tasks.Add(Task.Factory.StartNew(async () => Work(),TaskCreationOptions.LongRunning));

Il codice funziona di nuovo, poiché è in grado di creare le nuove attività su nuovi thread

using System;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Collections.Generic;

namespace UnitTestProject1
{
    [TestClass]
    public class UnitTest1
    {
        volatile int count = 0;
        [TestMethod]
        public async Task TestMethod1()
        {
            var tasks = new List<Task>();
            for(int i = 0;i<1000;i++)
            {
                tasks.Add(Work());
            }
            await Task.WhenAll(tasks.ToArray());
            Debug.WriteLine("finished");
        }

        async Task Work()
        {
            count++;
            Debug.WriteLine(count);
            await Task.Delay(10000);
            Debug.WriteLine(count);
            count--;
        }
    }
}