Блог

Я создаю свое первое многопоточное приложение на основе C # / .NET, которое будет работать в кластере Azure Service Fabric. Как следует из названия, я хочу запустить переменное количество параллельных параметризуемых потоков типа бесконечного цикла, которые будут использовать метод RunAsync.

Каждый дочерний поток выглядит примерно так:

         public async Task childThreadCall(...argument list...)
        {
            while (true)
            {
                try
                {
                    //long running code
                    //do something useful here
                    //sleep for an independently parameterizable period, then wake up and repeat
                }
                catch (Exception e)
                {
                    //Exception Handling
                }
            }
        }
 

Существует переменное количество таких дочерних потоков, которые вызываются в методе RunAsync. Я хочу сделать что-то вроде этого:

         protected override async Task RunAsync(CancellationToken cancellationToken)
        {
            try
            {
                for (int i = 0; i < input.length; i  )
                {
                    ThreadStart ts[i] = new ThreadStart(childThreadCall(...argument list...));
                    Thread tc[i] = new Thread(ts);
                    tc[i].Start();
                }
            }
            catch (Exception e)
            {
                //Exception Handling
            }
        }

 

Таким образом, в основном каждый из дочерних потоков выполняется независимо от других и продолжает делать это вечно. Возможно ли это сделать? Может ли кто-нибудь указать мне правильное направление? Есть ли какие-либо подводные камни, о которых следует знать?

RunAsync Метод вызывается при запуске службы. Так что да, его можно использовать для выполнения того, что вы хотите. Я предлагаю использовать задачи, поскольку они хорошо сочетаются с токеном отмены. Вот черновик:

 protected override async Task RunAsync(CancellationToken cancellationToken)
{
    var tasks = new List<Task>();
    try
    {
        for (int i = 0; i < input.length; i  )
        {
            tasks.Add(MyTask(cancellationToken, i);
        }
        
        await Task.WhenAll(tasks);
    }
    catch (Exception e)
    {
        //Exception Handling
    }
}

public async Task MyTask(CancellationToken cancellationToken, int a)
{
    while (true)
    {
        cancellationToken.ThrowIfCancellationRequested();

        try
        {
            //long running code, if possible check for cancellation using the token
            //do something useful here
            await SomeUseFullTask(cancellationToken);
            
            //sleep for an independently parameterizable period, then wake up and repeat
            await Task.Delay(TimeSpan.FromHours(1), cancellationToken);
        }
        catch (Exception e)
        {
            //Exception Handling
        }
    }
}
 

Что касается подводных камней, есть хороший список вещей, о которых нужно думать в целом при использовании задач.

Имейте в виду, что задачи лучше всего подходят для работы с вводом-выводом. Если вы можете опубликовать, что именно делается в длительном процессе, пожалуйста, сделайте это, тогда я, возможно, смогу улучшить ответ, чтобы он наилучшим образом соответствовал вашему варианту использования.

Важно учитывать токен отмены, переданный методу RunAsync, поскольку он указывает, что служба собирается остановиться. Это дает вам возможность изящно остановить вашу работу. Из документов:

Убедитесь, что CancellationToken, переданный RunAsync (CancellationToken), соблюден, и как только он был сигнализирован, RunAsync (CancellationToken) завершается корректно как можно скорее. Пожалуйста, обратите внимание, что если RunAsync(CancellationToken) завершил свою предполагаемую работу, ему не нужно ждать сигнала CancellationToken и он может корректно вернуться.

Как вы можете видеть в моем коде, я передаю CancellationToken дочерним методам, чтобы они могли реагировать на возможную отмену. В вашем случае произойдет отмена из-за бесконечного цикла.