如何减少基于数据库的多线程通知/电子邮件发件人中的CPU使用率

Question

I am trying to develop a windows service to send notifications to subscriptions. The data is saved in a SQL server database.

Notifications are created by making a web POST request to a REST API endpoint and saved in a database table.

The service starts one Task that keeps reading notifications from this db table and add them to a queue.

Also the service starts few Tasks that keep reading from the queue and do the actual send process.

The code is working good and doing the job needed, but the problem is that CPU usage is 100% when running the service.

I tried to use Thread.Sleep or Task.Delay but neither helped me to reduce the CPU usage.

I have read in this codeprojct page , that I need to use wait handlers and should wait on some condition. I could not have this working properly.

so can anyone advise what can I do to reduce CPU usage for EnqueueTask and DequeueTask ?

Here is the sender code:

static class NotificationSender
{
    static ConcurrentQueue<NotificationDelivery> deliveryQueue = null;
    static Task enqueueTask = null;
    static Task[] dequeueTasks = null;

    public static void StartSending(ServiceState serviceState)
    {
        PushService.InitServices();

        enqueueTask = Task.Factory.StartNew(EnqueueTask, serviceState);

        deliveryQueue = new ConcurrentQueue<NotificationDelivery>();

        int dequeueTasksCount = 10;
        dequeueTasks = new Task[dequeueTasksCount];
        for (int i = 0; i < dequeueTasksCount; i++)
        {
            dequeueTasks[i] = Task.Factory.StartNew(DequeueTask, serviceState);
        }
    }

    public static void EnqueueTask(object state)
    {
        ServiceState serviceState = (ServiceState)state;

        using (DSTeckWebPushNotificationsContext db = new DSTeckWebPushNotificationsContext())
        {
            while (!serviceState.CancellationTokenSource.Token.IsCancellationRequested)
            {
                int toEnqueue = 100 - deliveryQueue.Count;

                if (toEnqueue > 0)
                {
                    // fetch some records from db to be enqueued
                    NotificationDelivery[] deliveries = db.NotificationDeliveries
                        .Include("Subscription")
                        .Include("Notification")
                        .Include("Notification.NotificationLanguages")
                        .Include("Notification.NotificationLanguages.Language")
                        .Where(nd => nd.Status == NotificationDeliveryStatus.Pending && DateTime.Now >= nd.StartSendingAt)
                        .OrderBy(nd => nd.StartSendingAt)
                        .Take(toEnqueue)
                        .ToArray();

                    foreach (NotificationDelivery delivery in deliveries)
                    {
                        delivery.Status = NotificationDeliveryStatus.Queued;
                        deliveryQueue.Enqueue(delivery);
                    }

                    if (deliveries.Length > 0)
                    {
                        db.SaveChanges(); // save Queued state, so not fetched again the next loop
                    }
                }

                // save any changes made by the DequeueTask
                // an event may be used here to know if any changes made
                db.SaveChanges();
            }

            Task.WaitAll(dequeueTasks);
            db.SaveChanges();
        }
    }

    public async static void DequeueTask(object state)
    {
        ServiceState serviceState = (ServiceState)state;

        while (!serviceState.CancellationTokenSource.Token.IsCancellationRequested)
        {
            NotificationDelivery delivery = null;

            if (deliveryQueue.TryDequeue(out delivery))
            {
                NotificationDeliveryStatus ns = NotificationDeliveryStatus.Pending;
                if (delivery.Subscription.Status == SubscriptionStatus.Subscribed)
                {
                    PushResult result = await PushService.DoPushAsync(delivery);

                    switch (result)
                    {
                        case PushResult.Pushed:
                            ns = NotificationDeliveryStatus.Delivered;
                            break;
                        case PushResult.Error:
                            ns = NotificationDeliveryStatus.FailureError;
                            break;
                        case PushResult.NotSupported:
                            ns = NotificationDeliveryStatus.FailureNotSupported;
                            break;
                        case PushResult.UnSubscribed:
                            ns = NotificationDeliveryStatus.FailureUnSubscribed;
                            delivery.Subscription.Status = SubscriptionStatus.UnSubscribed;
                            break;
                    }
                }
                else
                {
                    ns = NotificationDeliveryStatus.FailureUnSubscribed;
                }

                delivery.Status = ns;
                delivery.DeliveredAt = DateTime.Now;
            }
        }
    }

    public static void Wait()
    {
        Task.WaitAll(enqueueTask);
        Task.WaitAll(dequeueTasks);

        enqueueTask.Dispose();
        for(int i = 0; i < dequeueTasks.Length; i++)
        {
            dequeueTasks[i].Dispose();
        }
    }
}

An object of type ServiceState is used to maintain starting and stopping the service, and here is the code for this type:

class ServiceState
{
    public CancellationTokenSource CancellationTokenSource { get; set; }

    public void Start()
    {
        CancellationTokenSource = new CancellationTokenSource();

        NotificationSender.StartSending(this);
    }

    public void Stop()
    {
        CancellationTokenSource.Cancel();

        NotificationSender.Wait();
        CancellationTokenSource.Dispose();
    }
}

Here is the service start and stop code:

protected override void OnStart(string[] args)
{
    _serviceState = new ServiceState();
    _serviceState.Start();
}

protected override void OnStop()
{
    _serviceState.Stop();
}

Answer 1

I think I could finally do good changes to maintain the CPU usage using wait handlers and a timer.

EnqueueTask will wait 5 seconds before trying to fetch data again from the notifications table if no notifications fetched. If no notifications fetched, it will start the timer and reset the wait handle. The timer elapsed callback will then set the wait handle.

Also DequeueTask is now using a wait handle. If no more items in the queue, it will reset the wait handle to stop dequeue-ing empty queue. EnqueueTask will set this wait handle when it adds items to the queue.

CPU usage is now <= 10%

And here is the updated NotificationSender code:

static class NotificationSender
{
    static ConcurrentQueue<NotificationDelivery> deliveryQueue = null;
    static Task enqueueTask = null;
    static Task[] dequeueTasks = null;

    static ManualResetEvent enqueueSignal = null;
    static ManualResetEvent dequeueSignal = null;

    static System.Timers.Timer enqueueTimer = null;

    public static void StartSending(CancellationToken token)
    {
        PushService.InitServices();

        using (DSTeckWebPushNotificationsContext db = new DSTeckWebPushNotificationsContext())
        {
            NotificationDelivery[] queuedDeliveries = db.NotificationDeliveries
                        .Where(nd => nd.Status == NotificationDeliveryStatus.Queued)
                        .ToArray();

            foreach (NotificationDelivery delivery in queuedDeliveries)
            {
                delivery.Status = NotificationDeliveryStatus.Pending;
            }

            db.SaveChanges();
        }

        enqueueSignal = new ManualResetEvent(true);
        dequeueSignal = new ManualResetEvent(false);

        enqueueTimer = new System.Timers.Timer();
        enqueueTimer.Elapsed += EnqueueTimerCallback;
        enqueueTimer.Interval = 5000;
        enqueueTimer.AutoReset = false;
        enqueueTimer.Stop();

        enqueueTask = new Task(EnqueueTask, token, TaskCreationOptions.LongRunning);
        enqueueTask.Start();

        deliveryQueue = new ConcurrentQueue<NotificationDelivery>();

        int dequeueTasksCount = 10;
        dequeueTasks = new Task[dequeueTasksCount];
        for (int i = 0; i < dequeueTasksCount; i++)
        {
            dequeueTasks[i] = new Task(DequeueTask, token, TaskCreationOptions.LongRunning);
            dequeueTasks[i].Start();
        }
    }

    public static void EnqueueTimerCallback(Object source, ElapsedEventArgs e)
    {
        enqueueSignal.Set();
        enqueueTimer.Stop();
    }

    public static void EnqueueTask(object state)
    {
        CancellationToken token = (CancellationToken)state;

        using (DSTeckWebPushNotificationsContext db = new DSTeckWebPushNotificationsContext())
        {
            while (!token.IsCancellationRequested)
            {
                if (enqueueSignal.WaitOne())
                {
                    int toEnqueue = 100 - deliveryQueue.Count;

                    if (toEnqueue > 0)
                    {
                        // fetch some records from db to be enqueued
                        NotificationDelivery[] deliveries = db.NotificationDeliveries
                            .Include("Subscription")
                            .Include("Notification")
                            .Include("Notification.NotificationLanguages")
                            .Include("Notification.NotificationLanguages.Language")
                            .Where(nd => nd.Status == NotificationDeliveryStatus.Pending && DateTime.Now >= nd.StartSendingAt)
                            .OrderBy(nd => nd.StartSendingAt)
                            .Take(toEnqueue)
                            .ToArray();

                        foreach (NotificationDelivery delivery in deliveries)
                        {
                            delivery.Status = NotificationDeliveryStatus.Queued;
                            deliveryQueue.Enqueue(delivery);
                        }

                        if (deliveries.Length > 0)
                        {
                            // save Queued state, so not fetched again the next loop
                            db.SaveChanges();

                            // signal the DequeueTask
                            dequeueSignal.Set();
                        }
                        else
                        {
                            // no more notifications, wait 5 seconds before try fetching again
                            enqueueSignal.Reset();
                            enqueueTimer.Start();
                        }
                    }

                    // save any changes made by the DequeueTask
                    // an event may be used here to know if any changes made
                    db.SaveChanges();
                }
            }

            Task.WaitAll(dequeueTasks);
            db.SaveChanges();
        }
    }

    public async static void DequeueTask(object state)
    {
        CancellationToken token = (CancellationToken)state;

        while (!token.IsCancellationRequested)
        {
            if (dequeueSignal.WaitOne()) // block untill we have items in the queue
            {
                NotificationDelivery delivery = null;

                if (deliveryQueue.TryDequeue(out delivery))
                {
                    NotificationDeliveryStatus ns = NotificationDeliveryStatus.Pending;
                    if (delivery.Subscription.Status == SubscriptionStatus.Subscribed)
                    {
                        PushResult result = await PushService.DoPushAsync(delivery);

                        switch (result)
                        {
                            case PushResult.Pushed:
                                ns = NotificationDeliveryStatus.Delivered;
                                break;
                            case PushResult.Error:
                                ns = NotificationDeliveryStatus.FailureError;
                                break;
                            case PushResult.NotSupported:
                                ns = NotificationDeliveryStatus.FailureNotSupported;
                                break;
                            case PushResult.UnSubscribed:
                                ns = NotificationDeliveryStatus.FailureUnSubscribed;
                                delivery.Subscription.Status = SubscriptionStatus.UnSubscribed;
                                break;
                        }
                    }
                    else
                    {
                        ns = NotificationDeliveryStatus.FailureUnSubscribed;
                    }

                    delivery.Status = ns;
                    delivery.DeliveredAt = DateTime.Now;
                }
                else
                {
                    // empty queue, no more items
                    // stop dequeueing untill new items added by EnqueueTask
                    dequeueSignal.Reset();
                }
            }
        }
    }

    public static void Wait()
    {
        Task.WaitAll(enqueueTask);
        Task.WaitAll(dequeueTasks);

        enqueueTask.Dispose();
        for(int i = 0; i < dequeueTasks.Length; i++)
        {
            dequeueTasks[i].Dispose();
        }
    }
}