Blazor Server - What is the best way to create/manage a background task/thread?

[DavidThielen]

Blazor server

The specific use case I have is I have an ILoggerProvider and it has a background thread where it reads log message from a ConcurrentQueue and writes them to the log repository (Azure BLOB). So this thread gets spun up when the server starts and lives until the app is shut down.

I figure this is a more general question though. For any case of having a background task/thread that is a worker daemon that has a long lifetime - what is the best way to do this? And a background daemon usually should have a lower priority so it is running when the processor is not that busy.

At present I am using Task.Run() which means I've permanently grabbed a thread from the thread pool. I'm guessing that is not optimum.

??? - thanks - dave

[david-acker]

It sounds like using a hosted service would suit your needs here. This would give you more control over the startup and shutdown as well. Although I'm not aware of anything that would allow you to change the priority of these background services out of the box.

Article: Background tasks with hosted services in ASP.NET Core

[DavidThielen]

That seems a little heavy for my use. Or am I reading more into this than I should? The word "service" makes me think this is for substantial use. Is it designed for very lightweight needs? (All I'm doing is reading a queue and writing the string in the queue to a BLOB.)

Also, for this use case, I think I need the BackgroundService base class. And it has this caveat:

No further services are started until ExecuteAsync becomes asynchronous, such as by calling await.

An ILoggerProvider is weird in that the logging system calls the constructor to set it up, and then starts calling it with log messages. So I don't see where/how I can call await. And I think that would be a problem for any use of this - you want to set up the background task/thread/service and then continue with the code on while it is running on its own.

Am I not understanding something about this?

thanks - dave

[mahald]

messing with thread priorities could lead to unexpected result. usually this is the best way to do something like that:

public class LoggerProvider
{
    private readonly Thread _workerThred;
    public ConcurrentQueue<string> Queue { get; set; } = new ConcurrentQueue<string>();

    public LoggerProvider()
    {
        _workerThred = new Thread(new ThreadStart(MyThread));
        _workerThred.Start();
    }

    private void MyThread()
    {
        while (true)
        {
            while(Queue.TryDequeue(out var data))
            {
                Task.Delay(1).Wait(); // if you need to call async just call it with .Wait() or .Result
            }    
            Thread.Sleep(100);
        }
    }
}

[DavidThielen]

What was suggested by @mahald is, in my opinion, a really bad way to do this. Delay() and Sleep() are almost always signs of a poor approach. You want no clock cycles burned when there's nothing in the queue.

public void Enqueue(string line)
{
	_queue.Enqueue(line);
	_newItemEventSlim.Set();
}

private async Task ProcessQueueAsync()
{
	while (!_cancellationTokenSource.IsCancellationRequested)
			{
		_newItemEventSlim.Wait(_cancellationTokenSource.Token);

		var lines = new List<string>();
		while (_queue.TryDequeue(out var message))
			lines.Add(message);
		await WriteLineAsync(lines);

		await FlushAsync();

		_newItemEventSlim.Reset();
	}

	Trap.Break();
}

[mahald]

@DavidThielen, you're correct about the sleep issue. My intention was to suggest implementing it within a dedicated thread.

To ensure everything operates within this thread, it's best to use the non-async functions provided by libraries. If you encounter a method that only offers an async variant, you can simply use .Wait or .Result to ensure its execution within that thread.
It's worth noting that we shouldn't use async merely because it's available. If you're certain that your task can be managed by a single thread, this approach is often more efficient. And you could set the Thread Priority if you want.

            IsBackground = true,
            Priority = ThreadPriority.BelowNormal

So it could look like this:

public class LoggerProvider
{
    private readonly Thread _workerThred;
    private readonly ConcurrentQueue<string> _queue;
    private readonly ManualResetEventSlim _queueItemEvent;
    private FileStream _logfile;

    public void Log(string message)
    {
        _queue.Enqueue(message);
        _queueItemEvent.Set();
    }

    private void WriteLine(List<string> lines)
    {
        _logfile.Write(Encoding.UTF8.GetBytes(string.Join(Environment.NewLine, lines)));
        _logfile.Write(Encoding.UTF8.GetBytes(Environment.NewLine));
    }

    private void Flush()
    {
        _logfile.Flush();
    }

    public LoggerProvider()
    {
        _logfile = File.OpenWrite("/var/test3.txt");
        _queue = new ConcurrentQueue<string>();
        _queueItemEvent = new ManualResetEventSlim(false);
        _workerThred = new Thread(WorkerThread)
        {
            IsBackground = true,
            Priority = ThreadPriority.BelowNormal
        };

        _workerThred.Start();
    }

    private void WorkerThread()
    {
        while (true)
        {
            _queueItemEvent.Wait();

            var lines = new List<string>();
            while (_queue.TryDequeue(out var data))
            {
                lines.Add(data);
            }
            
            _queueItemEvent.Reset();

            WriteLine(lines);
            Flush();

            
        }
    }
}

[DavidThielen]

thank you

[mahald]

small side note:

In referencing the provided code, there's a potential issue where a consumer might be left waiting while a message remains in the queue.
This is because there's no atomic function to either retrieve the message or wait.
However, there's a wrapper available that introduces this atomic function and is ideally suited for such scenarios.
This solution is the BlockingCollection (using ConcurrentColelction under the hood). To implement it like so:

private readonly BlockingCollection<string> _queue;

...

public void Log(string message)
{
	_queue.Add(message);
}

...

private void WorkerThread()
{
        // This results in an endless loop as it's either blocking or fetching a message from the queue.
	foreach (var data in _queue.GetConsumingEnumerable(_cancellationToken))
	{
		_logfile.WriteLine(data); // this is written to the memory buffer.

		if (_queue.Count == 0)
			_logfile.Flush(); // flush buffer to disk
	}
}

PS: i dropped the List since the streams got buffers to do exactly that (and they can be set to any desired size)