.NET5 后台服务并发

Question

I have a background service that will be started when the application performing startup. The background service will start to create multiple tasks based on how many workers are set. As I do various trials and monitor the open connection on DB. The open connection is always the same value as the worker I set. Let say I set 32 workers, then the connection will be always 32 open connections shown as I use query to check it. FYI I am using Postgres as the DB server. In order to check the open connection, I use the query below to check the connection when the application is running.

select * from pg_stat_activity where application_name = 'myapplication';

Below is the background service code.

public class MessagingService : BackgroundService {
     private int worker = 32;

     protected override async Task ExecuteAsync(CancellationToken cancellationToken) {
         var tasks = new List<Task>();
         for (int i=0; i<worker; i++) {
         tasks.Add(DoJob(cancellationToken));
         }
         while (!cancellationToken.IsCancellationRequested) {
            try {
               var completed = await Task.WhenAny(tasks);
               tasks.Remove(completed);
            } catch (Exception) {
               await Task.Delay(1000, cancellationToken);
            }
            if (!cancellationToken.IsCancellationRequested) {
               tasks.Add(DoJob(cancellationToken));
            }
        }
     }
    private async Task DoJob(CancellationToken cancellationToken) {
        using (var scope = _services.CreateScope()) {
            var service = scope.ServiceProvider
                .GetRequiredService<MessageService>();
            try {
                //do select and update query on db if null return false otherwise send mail
                if (!await service.Run(cancellationToken)) {
                    await Task.Delay(1000, cancellationToken);
                }
            } catch (Exception) {
                await Task.Delay(1000, cancellationToken);
            }
        }
    }
}   

The workflow is not right as it will keep creating the task and leave the connection open and idle. Also, the CPU and memory usage are high when running those tasks. How can I achieve like when there is no record found on DB only keep 1 worker running at the moment? If a record or more is found it will keep increasing until the preset max worker then decreasing the worker when the record is less than the max worker. If this question is too vague or opinion-based then please let me know and I will try my best to make it as specific as possible.

Update Purpose

The purpose of this service is to perform email delivery. There is another API that will be used to create a scheduled job. Once the job is added to the DB, this service will do the email delivery at the scheduled time. Eg, 5k schedule jobs are added to the DB and the scheduled time to perform the job is '2021-12-31 08:00:00' and the time when creating the scheduled job is 2021-12-31 00:00:00'. The service will keep on looping from 00:00:00 until 08:00:00 with 32 workers running at the same time then just start to do the email delivery. How can I improve it to more efficiency like normally when there is no job scheduled only 1 worker is running. When it checked there is 5k scheduled job it will fully utilise all the worker. After 5k job is completed, it will back to 1 workers.

Answer 1

My suggestion is to spare yourself from the burden of manually creating and maintaining worker tasks, by using an ActionBlock<T> from the TPL Dataflow library. This component is a combination of an input queue and an Action<T> delegate. You specify the delegate in its constructor, and you feed it with messages with its Post method. When there are no more messages, you notify it by invoking its Complete method, and then await its Completion so that you know that all work that was delegated to it has completed.

Below is a rough demonstration if how you could use this component:

protected override async Task ExecuteAsync(CancellationToken cancellationToken)
{
    var processor = new ActionBlock<Job>(async job =>
    {
        await ProcessJob(job);
        await MarkJobAsCompleted(job);
    }, new ExecutionDataflowBlockOptions()
    {
        MaxDegreeOfParallelism = 32
    });

    try
    {
        while (true)
        {
            Task delayTask = Task.Delay(TimeSpan.FromSeconds(60), cancellationToken);
            Job[] jobs = await FetchReadyToProcessJobs();
            foreach (var job in jobs)
            {
                processor.Post(job);
                await MarkJobAsPending(job);
            }
            await delayTask; // Will throw when the token is canceled
        }
    }
    finally
    {
        processor.Complete();
        await processor.Completion;
    }
}

The FetchReadyToProcessJobs method is supposed to connect to the database, and fetch all the jobs whose time has come to be processed. In the above example this method is invoked every 60 seconds. The Task.Delay is created before invoking the method, and awaited after the returned jobs have been posted to the ActionBlock<T> . This way the interval between invocations will be stable and consistent.